2 * drivers/s390/cio/device_fsm.c
3 * finite state machine for device handling
5 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
7 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
8 * Martin Schwidefsky (schwidefsky@de.ibm.com)
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/jiffies.h>
14 #include <linux/string.h>
16 #include <asm/ccwdev.h>
20 #include "cio_debug.h"
27 device_is_online(struct subchannel
*sch
)
29 struct ccw_device
*cdev
;
31 if (!sch
->dev
.driver_data
)
33 cdev
= sch
->dev
.driver_data
;
34 return (cdev
->private->state
== DEV_STATE_ONLINE
);
38 device_is_disconnected(struct subchannel
*sch
)
40 struct ccw_device
*cdev
;
42 if (!sch
->dev
.driver_data
)
44 cdev
= sch
->dev
.driver_data
;
45 return (cdev
->private->state
== DEV_STATE_DISCONNECTED
||
46 cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
);
50 device_set_disconnected(struct subchannel
*sch
)
52 struct ccw_device
*cdev
;
54 if (!sch
->dev
.driver_data
)
56 cdev
= sch
->dev
.driver_data
;
57 ccw_device_set_timeout(cdev
, 0);
58 cdev
->private->flags
.fake_irb
= 0;
59 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
63 * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
66 ccw_device_timeout(unsigned long data
)
68 struct ccw_device
*cdev
;
70 cdev
= (struct ccw_device
*) data
;
71 spin_lock_irq(cdev
->ccwlock
);
72 dev_fsm_event(cdev
, DEV_EVENT_TIMEOUT
);
73 spin_unlock_irq(cdev
->ccwlock
);
80 ccw_device_set_timeout(struct ccw_device
*cdev
, int expires
)
83 del_timer(&cdev
->private->timer
);
86 if (timer_pending(&cdev
->private->timer
)) {
87 if (mod_timer(&cdev
->private->timer
, jiffies
+ expires
))
90 cdev
->private->timer
.function
= ccw_device_timeout
;
91 cdev
->private->timer
.data
= (unsigned long) cdev
;
92 cdev
->private->timer
.expires
= jiffies
+ expires
;
93 add_timer(&cdev
->private->timer
);
96 /* Kill any pending timers after machine check. */
98 device_kill_pending_timer(struct subchannel
*sch
)
100 struct ccw_device
*cdev
;
102 if (!sch
->dev
.driver_data
)
104 cdev
= sch
->dev
.driver_data
;
105 ccw_device_set_timeout(cdev
, 0);
109 * Cancel running i/o. This is called repeatedly since halt/clear are
110 * asynchronous operations. We do one try with cio_cancel, two tries
111 * with cio_halt, 255 tries with cio_clear. If everythings fails panic.
112 * Returns 0 if device now idle, -ENODEV for device not operational and
113 * -EBUSY if an interrupt is expected (either from halt/clear or from a
117 ccw_device_cancel_halt_clear(struct ccw_device
*cdev
)
119 struct subchannel
*sch
;
122 sch
= to_subchannel(cdev
->dev
.parent
);
123 ret
= stsch(sch
->schid
, &sch
->schib
);
124 if (ret
|| !sch
->schib
.pmcw
.dnv
)
126 if (!sch
->schib
.pmcw
.ena
|| sch
->schib
.scsw
.actl
== 0)
127 /* Not operational or no activity -> done. */
129 /* Stage 1: cancel io. */
130 if (!(sch
->schib
.scsw
.actl
& SCSW_ACTL_HALT_PEND
) &&
131 !(sch
->schib
.scsw
.actl
& SCSW_ACTL_CLEAR_PEND
)) {
132 ret
= cio_cancel(sch
);
135 /* cancel io unsuccessful. From now on it is asynchronous. */
136 cdev
->private->iretry
= 3; /* 3 halt retries. */
138 if (!(sch
->schib
.scsw
.actl
& SCSW_ACTL_CLEAR_PEND
)) {
139 /* Stage 2: halt io. */
140 if (cdev
->private->iretry
) {
141 cdev
->private->iretry
--;
144 return (ret
== 0) ? -EBUSY
: ret
;
146 /* halt io unsuccessful. */
147 cdev
->private->iretry
= 255; /* 255 clear retries. */
149 /* Stage 3: clear io. */
150 if (cdev
->private->iretry
) {
151 cdev
->private->iretry
--;
152 ret
= cio_clear (sch
);
153 return (ret
== 0) ? -EBUSY
: ret
;
155 panic("Can't stop i/o on subchannel.\n");
159 ccw_device_handle_oper(struct ccw_device
*cdev
)
161 struct subchannel
*sch
;
163 sch
= to_subchannel(cdev
->dev
.parent
);
164 cdev
->private->flags
.recog_done
= 1;
166 * Check if cu type and device type still match. If
167 * not, it is certainly another device and we have to
168 * de- and re-register. Also check here for non-matching devno.
170 if (cdev
->id
.cu_type
!= cdev
->private->senseid
.cu_type
||
171 cdev
->id
.cu_model
!= cdev
->private->senseid
.cu_model
||
172 cdev
->id
.dev_type
!= cdev
->private->senseid
.dev_type
||
173 cdev
->id
.dev_model
!= cdev
->private->senseid
.dev_model
||
174 cdev
->private->dev_id
.devno
!= sch
->schib
.pmcw
.dev
) {
175 PREPARE_WORK(&cdev
->private->kick_work
,
176 ccw_device_do_unreg_rereg
, cdev
);
177 queue_work(ccw_device_work
, &cdev
->private->kick_work
);
180 cdev
->private->flags
.donotify
= 1;
185 * The machine won't give us any notification by machine check if a chpid has
186 * been varied online on the SE so we have to find out by magic (i. e. driving
187 * the channel subsystem to device selection and updating our path masks).
190 __recover_lost_chpids(struct subchannel
*sch
, int old_lpm
)
194 for (i
= 0; i
<8; i
++) {
196 if (!(sch
->lpm
& mask
))
200 chpid_is_actually_online(sch
->schib
.pmcw
.chpid
[i
]);
205 * Stop device recognition.
208 ccw_device_recog_done(struct ccw_device
*cdev
, int state
)
210 struct subchannel
*sch
;
211 int notify
, old_lpm
, same_dev
;
213 sch
= to_subchannel(cdev
->dev
.parent
);
215 ccw_device_set_timeout(cdev
, 0);
216 cio_disable_subchannel(sch
);
218 * Now that we tried recognition, we have performed device selection
219 * through ssch() and the path information is up to date.
222 stsch(sch
->schid
, &sch
->schib
);
223 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
224 /* Check since device may again have become not operational. */
225 if (!sch
->schib
.pmcw
.dnv
)
226 state
= DEV_STATE_NOT_OPER
;
227 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
)
228 /* Force reprobe on all chpids. */
230 if (sch
->lpm
!= old_lpm
)
231 __recover_lost_chpids(sch
, old_lpm
);
232 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
) {
233 if (state
== DEV_STATE_NOT_OPER
) {
234 cdev
->private->flags
.recog_done
= 1;
235 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
238 /* Boxed devices don't need extra treatment. */
241 same_dev
= 0; /* Keep the compiler quiet... */
243 case DEV_STATE_NOT_OPER
:
244 CIO_DEBUG(KERN_WARNING
, 2,
245 "SenseID : unknown device %04x on subchannel "
246 "0.%x.%04x\n", cdev
->private->dev_id
.devno
,
247 sch
->schid
.ssid
, sch
->schid
.sch_no
);
249 case DEV_STATE_OFFLINE
:
250 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
) {
251 same_dev
= ccw_device_handle_oper(cdev
);
254 /* fill out sense information */
255 memset(&cdev
->id
, 0, sizeof(cdev
->id
));
256 cdev
->id
.cu_type
= cdev
->private->senseid
.cu_type
;
257 cdev
->id
.cu_model
= cdev
->private->senseid
.cu_model
;
258 cdev
->id
.dev_type
= cdev
->private->senseid
.dev_type
;
259 cdev
->id
.dev_model
= cdev
->private->senseid
.dev_model
;
261 cdev
->private->state
= DEV_STATE_OFFLINE
;
263 /* Get device online again. */
264 ccw_device_online(cdev
);
265 wake_up(&cdev
->private->wait_q
);
269 /* Issue device info message. */
270 CIO_DEBUG(KERN_INFO
, 2, "SenseID : device 0.%x.%04x reports: "
271 "CU Type/Mod = %04X/%02X, Dev Type/Mod = "
273 cdev
->private->dev_id
.ssid
,
274 cdev
->private->dev_id
.devno
,
275 cdev
->id
.cu_type
, cdev
->id
.cu_model
,
276 cdev
->id
.dev_type
, cdev
->id
.dev_model
);
278 case DEV_STATE_BOXED
:
279 CIO_DEBUG(KERN_WARNING
, 2,
280 "SenseID : boxed device %04x on subchannel "
281 "0.%x.%04x\n", cdev
->private->dev_id
.devno
,
282 sch
->schid
.ssid
, sch
->schid
.sch_no
);
285 cdev
->private->state
= state
;
286 io_subchannel_recog_done(cdev
);
287 if (state
!= DEV_STATE_NOT_OPER
)
288 wake_up(&cdev
->private->wait_q
);
292 * Function called from device_id.c after sense id has completed.
295 ccw_device_sense_id_done(struct ccw_device
*cdev
, int err
)
299 ccw_device_recog_done(cdev
, DEV_STATE_OFFLINE
);
301 case -ETIME
: /* Sense id stopped by timeout. */
302 ccw_device_recog_done(cdev
, DEV_STATE_BOXED
);
305 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
311 ccw_device_oper_notify(void *data
)
313 struct ccw_device
*cdev
;
314 struct subchannel
*sch
;
318 sch
= to_subchannel(cdev
->dev
.parent
);
319 ret
= (sch
->driver
&& sch
->driver
->notify
) ?
320 sch
->driver
->notify(&sch
->dev
, CIO_OPER
) : 0;
322 /* Driver doesn't want device back. */
323 ccw_device_do_unreg_rereg(cdev
);
325 /* Reenable channel measurements, if needed. */
327 wake_up(&cdev
->private->wait_q
);
332 * Finished with online/offline processing.
335 ccw_device_done(struct ccw_device
*cdev
, int state
)
337 struct subchannel
*sch
;
339 sch
= to_subchannel(cdev
->dev
.parent
);
341 ccw_device_set_timeout(cdev
, 0);
343 if (state
!= DEV_STATE_ONLINE
)
344 cio_disable_subchannel(sch
);
346 /* Reset device status. */
347 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
349 cdev
->private->state
= state
;
352 if (state
== DEV_STATE_BOXED
)
353 CIO_DEBUG(KERN_WARNING
, 2,
354 "Boxed device %04x on subchannel %04x\n",
355 cdev
->private->dev_id
.devno
, sch
->schid
.sch_no
);
357 if (cdev
->private->flags
.donotify
) {
358 cdev
->private->flags
.donotify
= 0;
359 PREPARE_WORK(&cdev
->private->kick_work
, ccw_device_oper_notify
,
361 queue_work(ccw_device_notify_work
, &cdev
->private->kick_work
);
363 wake_up(&cdev
->private->wait_q
);
365 if (css_init_done
&& state
!= DEV_STATE_ONLINE
)
366 put_device (&cdev
->dev
);
369 static inline int cmp_pgid(struct pgid
*p1
, struct pgid
*p2
)
377 return memcmp(c1
+ 1, c2
+ 1, sizeof(struct pgid
) - 1);
380 static void __ccw_device_get_common_pgid(struct ccw_device
*cdev
)
386 for (i
= 0; i
< 8; i
++) {
387 if (cdev
->private->pgid
[i
].inf
.ps
.state1
== SNID_STATE1_RESET
)
390 if (cdev
->private->pgid
[last
].inf
.ps
.state1
==
392 /* First non-zero PGID */
396 if (cmp_pgid(&cdev
->private->pgid
[i
],
397 &cdev
->private->pgid
[last
]) == 0)
398 /* Non-conflicting PGIDs */
401 /* PGID mismatch, can't pathgroup. */
402 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
403 "0.%x.%04x, can't pathgroup\n",
404 cdev
->private->dev_id
.ssid
,
405 cdev
->private->dev_id
.devno
);
406 cdev
->private->options
.pgroup
= 0;
409 if (cdev
->private->pgid
[last
].inf
.ps
.state1
==
411 /* No previous pgid found */
412 memcpy(&cdev
->private->pgid
[0], &css
[0]->global_pgid
,
413 sizeof(struct pgid
));
415 /* Use existing pgid */
416 memcpy(&cdev
->private->pgid
[0], &cdev
->private->pgid
[last
],
417 sizeof(struct pgid
));
421 * Function called from device_pgid.c after sense path ground has completed.
424 ccw_device_sense_pgid_done(struct ccw_device
*cdev
, int err
)
426 struct subchannel
*sch
;
428 sch
= to_subchannel(cdev
->dev
.parent
);
430 case -EOPNOTSUPP
: /* path grouping not supported, use nop instead. */
431 cdev
->private->options
.pgroup
= 0;
433 case 0: /* success */
434 case -EACCES
: /* partial success, some paths not operational */
435 /* Check if all pgids are equal or 0. */
436 __ccw_device_get_common_pgid(cdev
);
438 case -ETIME
: /* Sense path group id stopped by timeout. */
439 case -EUSERS
: /* device is reserved for someone else. */
440 ccw_device_done(cdev
, DEV_STATE_BOXED
);
443 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
446 /* Start Path Group verification. */
447 cdev
->private->state
= DEV_STATE_VERIFY
;
448 cdev
->private->flags
.doverify
= 0;
449 ccw_device_verify_start(cdev
);
453 * Start device recognition.
456 ccw_device_recognition(struct ccw_device
*cdev
)
458 struct subchannel
*sch
;
461 if ((cdev
->private->state
!= DEV_STATE_NOT_OPER
) &&
462 (cdev
->private->state
!= DEV_STATE_BOXED
))
464 sch
= to_subchannel(cdev
->dev
.parent
);
465 ret
= cio_enable_subchannel(sch
, sch
->schib
.pmcw
.isc
);
467 /* Couldn't enable the subchannel for i/o. Sick device. */
470 /* After 60s the device recognition is considered to have failed. */
471 ccw_device_set_timeout(cdev
, 60*HZ
);
474 * We used to start here with a sense pgid to find out whether a device
475 * is locked by someone else. Unfortunately, the sense pgid command
476 * code has other meanings on devices predating the path grouping
477 * algorithm, so we start with sense id and box the device after an
478 * timeout (or if sense pgid during path verification detects the device
479 * is locked, as may happen on newer devices).
481 cdev
->private->flags
.recog_done
= 0;
482 cdev
->private->state
= DEV_STATE_SENSE_ID
;
483 ccw_device_sense_id_start(cdev
);
488 * Handle timeout in device recognition.
491 ccw_device_recog_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
495 ret
= ccw_device_cancel_halt_clear(cdev
);
498 ccw_device_recog_done(cdev
, DEV_STATE_BOXED
);
501 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
504 ccw_device_set_timeout(cdev
, 3*HZ
);
510 ccw_device_nopath_notify(void *data
)
512 struct ccw_device
*cdev
;
513 struct subchannel
*sch
;
517 sch
= to_subchannel(cdev
->dev
.parent
);
521 ret
= (sch
->driver
&& sch
->driver
->notify
) ?
522 sch
->driver
->notify(&sch
->dev
, CIO_NO_PATH
) : 0;
524 if (get_device(&sch
->dev
)) {
525 /* Driver doesn't want to keep device. */
526 cio_disable_subchannel(sch
);
527 if (get_device(&cdev
->dev
)) {
528 PREPARE_WORK(&cdev
->private->kick_work
,
529 ccw_device_call_sch_unregister
,
531 queue_work(ccw_device_work
,
532 &cdev
->private->kick_work
);
534 put_device(&sch
->dev
);
537 cio_disable_subchannel(sch
);
538 ccw_device_set_timeout(cdev
, 0);
539 cdev
->private->flags
.fake_irb
= 0;
540 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
541 wake_up(&cdev
->private->wait_q
);
546 ccw_device_verify_done(struct ccw_device
*cdev
, int err
)
548 struct subchannel
*sch
;
550 sch
= to_subchannel(cdev
->dev
.parent
);
551 /* Update schib - pom may have changed. */
552 stsch(sch
->schid
, &sch
->schib
);
553 /* Update lpm with verified path mask. */
555 /* Repeat path verification? */
556 if (cdev
->private->flags
.doverify
) {
557 cdev
->private->flags
.doverify
= 0;
558 ccw_device_verify_start(cdev
);
562 case -EOPNOTSUPP
: /* path grouping not supported, just set online. */
563 cdev
->private->options
.pgroup
= 0;
565 ccw_device_done(cdev
, DEV_STATE_ONLINE
);
566 /* Deliver fake irb to device driver, if needed. */
567 if (cdev
->private->flags
.fake_irb
) {
568 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
569 cdev
->private->irb
.scsw
.cc
= 1;
570 cdev
->private->irb
.scsw
.fctl
= SCSW_FCTL_START_FUNC
;
571 cdev
->private->irb
.scsw
.actl
= SCSW_ACTL_START_PEND
;
572 cdev
->private->irb
.scsw
.stctl
= SCSW_STCTL_STATUS_PEND
;
573 cdev
->private->flags
.fake_irb
= 0;
575 cdev
->handler(cdev
, cdev
->private->intparm
,
576 &cdev
->private->irb
);
577 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
581 /* Reset oper notify indication after verify error. */
582 cdev
->private->flags
.donotify
= 0;
583 ccw_device_done(cdev
, DEV_STATE_BOXED
);
586 /* Reset oper notify indication after verify error. */
587 cdev
->private->flags
.donotify
= 0;
588 PREPARE_WORK(&cdev
->private->kick_work
,
589 ccw_device_nopath_notify
, cdev
);
590 queue_work(ccw_device_notify_work
, &cdev
->private->kick_work
);
591 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
600 ccw_device_online(struct ccw_device
*cdev
)
602 struct subchannel
*sch
;
605 if ((cdev
->private->state
!= DEV_STATE_OFFLINE
) &&
606 (cdev
->private->state
!= DEV_STATE_BOXED
))
608 sch
= to_subchannel(cdev
->dev
.parent
);
609 if (css_init_done
&& !get_device(&cdev
->dev
))
611 ret
= cio_enable_subchannel(sch
, sch
->schib
.pmcw
.isc
);
613 /* Couldn't enable the subchannel for i/o. Sick device. */
615 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
618 /* Do we want to do path grouping? */
619 if (!cdev
->private->options
.pgroup
) {
620 /* Start initial path verification. */
621 cdev
->private->state
= DEV_STATE_VERIFY
;
622 cdev
->private->flags
.doverify
= 0;
623 ccw_device_verify_start(cdev
);
626 /* Do a SensePGID first. */
627 cdev
->private->state
= DEV_STATE_SENSE_PGID
;
628 ccw_device_sense_pgid_start(cdev
);
633 ccw_device_disband_done(struct ccw_device
*cdev
, int err
)
637 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
640 ccw_device_done(cdev
, DEV_STATE_BOXED
);
643 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
652 ccw_device_offline(struct ccw_device
*cdev
)
654 struct subchannel
*sch
;
656 sch
= to_subchannel(cdev
->dev
.parent
);
657 if (stsch(sch
->schid
, &sch
->schib
) || !sch
->schib
.pmcw
.dnv
)
659 if (cdev
->private->state
!= DEV_STATE_ONLINE
) {
660 if (sch
->schib
.scsw
.actl
!= 0)
664 if (sch
->schib
.scsw
.actl
!= 0)
666 /* Are we doing path grouping? */
667 if (!cdev
->private->options
.pgroup
) {
668 /* No, set state offline immediately. */
669 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
672 /* Start Set Path Group commands. */
673 cdev
->private->state
= DEV_STATE_DISBAND_PGID
;
674 ccw_device_disband_start(cdev
);
679 * Handle timeout in device online/offline process.
682 ccw_device_onoff_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
686 ret
= ccw_device_cancel_halt_clear(cdev
);
689 ccw_device_done(cdev
, DEV_STATE_BOXED
);
692 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
695 ccw_device_set_timeout(cdev
, 3*HZ
);
700 * Handle not oper event in device recognition.
703 ccw_device_recog_notoper(struct ccw_device
*cdev
, enum dev_event dev_event
)
705 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
709 * Handle not operational event while offline.
712 ccw_device_offline_notoper(struct ccw_device
*cdev
, enum dev_event dev_event
)
714 struct subchannel
*sch
;
716 cdev
->private->state
= DEV_STATE_NOT_OPER
;
717 sch
= to_subchannel(cdev
->dev
.parent
);
718 if (get_device(&cdev
->dev
)) {
719 PREPARE_WORK(&cdev
->private->kick_work
,
720 ccw_device_call_sch_unregister
, cdev
);
721 queue_work(ccw_device_work
, &cdev
->private->kick_work
);
723 wake_up(&cdev
->private->wait_q
);
727 * Handle not operational event while online.
730 ccw_device_online_notoper(struct ccw_device
*cdev
, enum dev_event dev_event
)
732 struct subchannel
*sch
;
734 sch
= to_subchannel(cdev
->dev
.parent
);
735 if (sch
->driver
->notify
&&
736 sch
->driver
->notify(&sch
->dev
, sch
->lpm
? CIO_GONE
: CIO_NO_PATH
)) {
737 ccw_device_set_timeout(cdev
, 0);
738 cdev
->private->flags
.fake_irb
= 0;
739 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
740 wake_up(&cdev
->private->wait_q
);
743 cdev
->private->state
= DEV_STATE_NOT_OPER
;
744 cio_disable_subchannel(sch
);
745 if (sch
->schib
.scsw
.actl
!= 0) {
746 // FIXME: not-oper indication to device driver ?
747 ccw_device_call_handler(cdev
);
749 if (get_device(&cdev
->dev
)) {
750 PREPARE_WORK(&cdev
->private->kick_work
,
751 ccw_device_call_sch_unregister
, cdev
);
752 queue_work(ccw_device_work
, &cdev
->private->kick_work
);
754 wake_up(&cdev
->private->wait_q
);
758 * Handle path verification event.
761 ccw_device_online_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
763 struct subchannel
*sch
;
765 if (cdev
->private->state
== DEV_STATE_W4SENSE
) {
766 cdev
->private->flags
.doverify
= 1;
769 sch
= to_subchannel(cdev
->dev
.parent
);
771 * Since we might not just be coming from an interrupt from the
772 * subchannel we have to update the schib.
774 stsch(sch
->schid
, &sch
->schib
);
776 if (sch
->schib
.scsw
.actl
!= 0 ||
777 (sch
->schib
.scsw
.stctl
& SCSW_STCTL_STATUS_PEND
) ||
778 (cdev
->private->irb
.scsw
.stctl
& SCSW_STCTL_STATUS_PEND
)) {
780 * No final status yet or final status not yet delivered
781 * to the device driver. Can't do path verfication now,
782 * delay until final status was delivered.
784 cdev
->private->flags
.doverify
= 1;
787 /* Device is idle, we can do the path verification. */
788 cdev
->private->state
= DEV_STATE_VERIFY
;
789 cdev
->private->flags
.doverify
= 0;
790 ccw_device_verify_start(cdev
);
794 * Got an interrupt for a normal io (state online).
797 ccw_device_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
801 irb
= (struct irb
*) __LC_IRB
;
802 /* Check for unsolicited interrupt. */
803 if ((irb
->scsw
.stctl
==
804 (SCSW_STCTL_STATUS_PEND
| SCSW_STCTL_ALERT_STATUS
))
805 && (!irb
->scsw
.cc
)) {
806 if ((irb
->scsw
.dstat
& DEV_STAT_UNIT_CHECK
) &&
807 !irb
->esw
.esw0
.erw
.cons
) {
808 /* Unit check but no sense data. Need basic sense. */
809 if (ccw_device_do_sense(cdev
, irb
) != 0)
810 goto call_handler_unsol
;
811 memcpy(&cdev
->private->irb
, irb
, sizeof(struct irb
));
812 cdev
->private->state
= DEV_STATE_W4SENSE
;
813 cdev
->private->intparm
= 0;
818 cdev
->handler (cdev
, 0, irb
);
821 /* Accumulate status and find out if a basic sense is needed. */
822 ccw_device_accumulate_irb(cdev
, irb
);
823 if (cdev
->private->flags
.dosense
) {
824 if (ccw_device_do_sense(cdev
, irb
) == 0) {
825 cdev
->private->state
= DEV_STATE_W4SENSE
;
829 /* Call the handler. */
830 if (ccw_device_call_handler(cdev
) && cdev
->private->flags
.doverify
)
831 /* Start delayed path verification. */
832 ccw_device_online_verify(cdev
, 0);
836 * Got an timeout in online state.
839 ccw_device_online_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
843 ccw_device_set_timeout(cdev
, 0);
844 ret
= ccw_device_cancel_halt_clear(cdev
);
846 ccw_device_set_timeout(cdev
, 3*HZ
);
847 cdev
->private->state
= DEV_STATE_TIMEOUT_KILL
;
850 if (ret
== -ENODEV
) {
851 struct subchannel
*sch
;
853 sch
= to_subchannel(cdev
->dev
.parent
);
855 PREPARE_WORK(&cdev
->private->kick_work
,
856 ccw_device_nopath_notify
, cdev
);
857 queue_work(ccw_device_notify_work
,
858 &cdev
->private->kick_work
);
860 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
861 } else if (cdev
->handler
)
862 cdev
->handler(cdev
, cdev
->private->intparm
,
863 ERR_PTR(-ETIMEDOUT
));
867 * Got an interrupt for a basic sense.
870 ccw_device_w4sense(struct ccw_device
*cdev
, enum dev_event dev_event
)
874 irb
= (struct irb
*) __LC_IRB
;
875 /* Check for unsolicited interrupt. */
876 if (irb
->scsw
.stctl
==
877 (SCSW_STCTL_STATUS_PEND
| SCSW_STCTL_ALERT_STATUS
)) {
878 if (irb
->scsw
.cc
== 1)
879 /* Basic sense hasn't started. Try again. */
880 ccw_device_do_sense(cdev
, irb
);
882 printk(KERN_INFO
"Huh? %s(%s): unsolicited "
884 __FUNCTION__
, cdev
->dev
.bus_id
);
886 cdev
->handler (cdev
, 0, irb
);
891 * Check if a halt or clear has been issued in the meanwhile. If yes,
892 * only deliver the halt/clear interrupt to the device driver as if it
893 * had killed the original request.
895 if (irb
->scsw
.fctl
& (SCSW_FCTL_CLEAR_FUNC
| SCSW_FCTL_HALT_FUNC
)) {
896 cdev
->private->flags
.dosense
= 0;
897 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
898 ccw_device_accumulate_irb(cdev
, irb
);
901 /* Add basic sense info to irb. */
902 ccw_device_accumulate_basic_sense(cdev
, irb
);
903 if (cdev
->private->flags
.dosense
) {
904 /* Another basic sense is needed. */
905 ccw_device_do_sense(cdev
, irb
);
909 cdev
->private->state
= DEV_STATE_ONLINE
;
910 /* Call the handler. */
911 if (ccw_device_call_handler(cdev
) && cdev
->private->flags
.doverify
)
912 /* Start delayed path verification. */
913 ccw_device_online_verify(cdev
, 0);
917 ccw_device_clear_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
921 irb
= (struct irb
*) __LC_IRB
;
922 /* Accumulate status. We don't do basic sense. */
923 ccw_device_accumulate_irb(cdev
, irb
);
924 /* Remember to clear irb to avoid residuals. */
925 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
926 /* Try to start delayed device verification. */
927 ccw_device_online_verify(cdev
, 0);
928 /* Note: Don't call handler for cio initiated clear! */
932 ccw_device_killing_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
934 struct subchannel
*sch
;
936 sch
= to_subchannel(cdev
->dev
.parent
);
937 ccw_device_set_timeout(cdev
, 0);
938 /* OK, i/o is dead now. Call interrupt handler. */
939 cdev
->private->state
= DEV_STATE_ONLINE
;
941 cdev
->handler(cdev
, cdev
->private->intparm
,
944 PREPARE_WORK(&cdev
->private->kick_work
,
945 ccw_device_nopath_notify
, cdev
);
946 queue_work(ccw_device_notify_work
, &cdev
->private->kick_work
);
947 } else if (cdev
->private->flags
.doverify
)
948 /* Start delayed path verification. */
949 ccw_device_online_verify(cdev
, 0);
953 ccw_device_killing_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
957 ret
= ccw_device_cancel_halt_clear(cdev
);
959 ccw_device_set_timeout(cdev
, 3*HZ
);
962 if (ret
== -ENODEV
) {
963 struct subchannel
*sch
;
965 sch
= to_subchannel(cdev
->dev
.parent
);
967 PREPARE_WORK(&cdev
->private->kick_work
,
968 ccw_device_nopath_notify
, cdev
);
969 queue_work(ccw_device_notify_work
,
970 &cdev
->private->kick_work
);
972 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
975 //FIXME: Can we get here?
976 cdev
->private->state
= DEV_STATE_ONLINE
;
978 cdev
->handler(cdev
, cdev
->private->intparm
,
982 void device_kill_io(struct subchannel
*sch
)
985 struct ccw_device
*cdev
;
987 cdev
= sch
->dev
.driver_data
;
988 ret
= ccw_device_cancel_halt_clear(cdev
);
990 ccw_device_set_timeout(cdev
, 3*HZ
);
991 cdev
->private->state
= DEV_STATE_TIMEOUT_KILL
;
994 if (ret
== -ENODEV
) {
996 PREPARE_WORK(&cdev
->private->kick_work
,
997 ccw_device_nopath_notify
, cdev
);
998 queue_work(ccw_device_notify_work
,
999 &cdev
->private->kick_work
);
1001 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
1005 cdev
->handler(cdev
, cdev
->private->intparm
,
1008 PREPARE_WORK(&cdev
->private->kick_work
,
1009 ccw_device_nopath_notify
, cdev
);
1010 queue_work(ccw_device_notify_work
, &cdev
->private->kick_work
);
1012 /* Start delayed path verification. */
1013 ccw_device_online_verify(cdev
, 0);
1017 ccw_device_delay_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
1019 /* Start verification after current task finished. */
1020 cdev
->private->flags
.doverify
= 1;
1024 ccw_device_stlck_done(struct ccw_device
*cdev
, enum dev_event dev_event
)
1028 switch (dev_event
) {
1029 case DEV_EVENT_INTERRUPT
:
1030 irb
= (struct irb
*) __LC_IRB
;
1031 /* Check for unsolicited interrupt. */
1032 if ((irb
->scsw
.stctl
==
1033 (SCSW_STCTL_STATUS_PEND
| SCSW_STCTL_ALERT_STATUS
)) &&
1035 /* FIXME: we should restart stlck here, but this
1036 * is extremely unlikely ... */
1039 ccw_device_accumulate_irb(cdev
, irb
);
1040 /* We don't care about basic sense etc. */
1042 default: /* timeout */
1046 wake_up(&cdev
->private->wait_q
);
1050 ccw_device_start_id(struct ccw_device
*cdev
, enum dev_event dev_event
)
1052 struct subchannel
*sch
;
1054 sch
= to_subchannel(cdev
->dev
.parent
);
1055 if (cio_enable_subchannel(sch
, sch
->schib
.pmcw
.isc
) != 0)
1056 /* Couldn't enable the subchannel for i/o. Sick device. */
1059 /* After 60s the device recognition is considered to have failed. */
1060 ccw_device_set_timeout(cdev
, 60*HZ
);
1062 cdev
->private->state
= DEV_STATE_DISCONNECTED_SENSE_ID
;
1063 ccw_device_sense_id_start(cdev
);
1067 device_trigger_reprobe(struct subchannel
*sch
)
1069 struct ccw_device
*cdev
;
1071 if (!sch
->dev
.driver_data
)
1073 cdev
= sch
->dev
.driver_data
;
1074 if (cdev
->private->state
!= DEV_STATE_DISCONNECTED
)
1077 /* Update some values. */
1078 if (stsch(sch
->schid
, &sch
->schib
))
1082 * The pim, pam, pom values may not be accurate, but they are the best
1083 * we have before performing device selection :/
1085 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
1086 /* Re-set some bits in the pmcw that were lost. */
1087 sch
->schib
.pmcw
.isc
= 3;
1088 sch
->schib
.pmcw
.csense
= 1;
1089 sch
->schib
.pmcw
.ena
= 0;
1090 if ((sch
->lpm
& (sch
->lpm
- 1)) != 0)
1091 sch
->schib
.pmcw
.mp
= 1;
1092 sch
->schib
.pmcw
.intparm
= (__u32
)(unsigned long)sch
;
1093 /* We should also udate ssd info, but this has to wait. */
1094 ccw_device_start_id(cdev
, 0);
1098 ccw_device_offline_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
1100 struct subchannel
*sch
;
1102 sch
= to_subchannel(cdev
->dev
.parent
);
1104 * An interrupt in state offline means a previous disable was not
1105 * successful. Try again.
1107 cio_disable_subchannel(sch
);
1111 ccw_device_change_cmfstate(struct ccw_device
*cdev
, enum dev_event dev_event
)
1113 retry_set_schib(cdev
);
1114 cdev
->private->state
= DEV_STATE_ONLINE
;
1115 dev_fsm_event(cdev
, dev_event
);
1118 static void ccw_device_update_cmfblock(struct ccw_device
*cdev
,
1119 enum dev_event dev_event
)
1121 cmf_retry_copy_block(cdev
);
1122 cdev
->private->state
= DEV_STATE_ONLINE
;
1123 dev_fsm_event(cdev
, dev_event
);
1127 ccw_device_quiesce_done(struct ccw_device
*cdev
, enum dev_event dev_event
)
1129 ccw_device_set_timeout(cdev
, 0);
1130 if (dev_event
== DEV_EVENT_NOTOPER
)
1131 cdev
->private->state
= DEV_STATE_NOT_OPER
;
1133 cdev
->private->state
= DEV_STATE_OFFLINE
;
1134 wake_up(&cdev
->private->wait_q
);
1138 ccw_device_quiesce_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
1142 ret
= ccw_device_cancel_halt_clear(cdev
);
1145 cdev
->private->state
= DEV_STATE_OFFLINE
;
1146 wake_up(&cdev
->private->wait_q
);
1149 cdev
->private->state
= DEV_STATE_NOT_OPER
;
1150 wake_up(&cdev
->private->wait_q
);
1153 ccw_device_set_timeout(cdev
, HZ
/10);
1158 * No operation action. This is used e.g. to ignore a timeout event in
1162 ccw_device_nop(struct ccw_device
*cdev
, enum dev_event dev_event
)
1167 * Bug operation action.
1170 ccw_device_bug(struct ccw_device
*cdev
, enum dev_event dev_event
)
1172 printk(KERN_EMERG
"dev_jumptable[%i][%i] == NULL\n",
1173 cdev
->private->state
, dev_event
);
1178 * device statemachine
1180 fsm_func_t
*dev_jumptable
[NR_DEV_STATES
][NR_DEV_EVENTS
] = {
1181 [DEV_STATE_NOT_OPER
] = {
1182 [DEV_EVENT_NOTOPER
] = ccw_device_nop
,
1183 [DEV_EVENT_INTERRUPT
] = ccw_device_bug
,
1184 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1185 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1187 [DEV_STATE_SENSE_PGID
] = {
1188 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1189 [DEV_EVENT_INTERRUPT
] = ccw_device_sense_pgid_irq
,
1190 [DEV_EVENT_TIMEOUT
] = ccw_device_onoff_timeout
,
1191 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1193 [DEV_STATE_SENSE_ID
] = {
1194 [DEV_EVENT_NOTOPER
] = ccw_device_recog_notoper
,
1195 [DEV_EVENT_INTERRUPT
] = ccw_device_sense_id_irq
,
1196 [DEV_EVENT_TIMEOUT
] = ccw_device_recog_timeout
,
1197 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1199 [DEV_STATE_OFFLINE
] = {
1200 [DEV_EVENT_NOTOPER
] = ccw_device_offline_notoper
,
1201 [DEV_EVENT_INTERRUPT
] = ccw_device_offline_irq
,
1202 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1203 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1205 [DEV_STATE_VERIFY
] = {
1206 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1207 [DEV_EVENT_INTERRUPT
] = ccw_device_verify_irq
,
1208 [DEV_EVENT_TIMEOUT
] = ccw_device_onoff_timeout
,
1209 [DEV_EVENT_VERIFY
] = ccw_device_delay_verify
,
1211 [DEV_STATE_ONLINE
] = {
1212 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1213 [DEV_EVENT_INTERRUPT
] = ccw_device_irq
,
1214 [DEV_EVENT_TIMEOUT
] = ccw_device_online_timeout
,
1215 [DEV_EVENT_VERIFY
] = ccw_device_online_verify
,
1217 [DEV_STATE_W4SENSE
] = {
1218 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1219 [DEV_EVENT_INTERRUPT
] = ccw_device_w4sense
,
1220 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1221 [DEV_EVENT_VERIFY
] = ccw_device_online_verify
,
1223 [DEV_STATE_DISBAND_PGID
] = {
1224 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1225 [DEV_EVENT_INTERRUPT
] = ccw_device_disband_irq
,
1226 [DEV_EVENT_TIMEOUT
] = ccw_device_onoff_timeout
,
1227 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1229 [DEV_STATE_BOXED
] = {
1230 [DEV_EVENT_NOTOPER
] = ccw_device_offline_notoper
,
1231 [DEV_EVENT_INTERRUPT
] = ccw_device_stlck_done
,
1232 [DEV_EVENT_TIMEOUT
] = ccw_device_stlck_done
,
1233 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1235 /* states to wait for i/o completion before doing something */
1236 [DEV_STATE_CLEAR_VERIFY
] = {
1237 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1238 [DEV_EVENT_INTERRUPT
] = ccw_device_clear_verify
,
1239 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1240 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1242 [DEV_STATE_TIMEOUT_KILL
] = {
1243 [DEV_EVENT_NOTOPER
] = ccw_device_online_notoper
,
1244 [DEV_EVENT_INTERRUPT
] = ccw_device_killing_irq
,
1245 [DEV_EVENT_TIMEOUT
] = ccw_device_killing_timeout
,
1246 [DEV_EVENT_VERIFY
] = ccw_device_nop
, //FIXME
1248 [DEV_STATE_QUIESCE
] = {
1249 [DEV_EVENT_NOTOPER
] = ccw_device_quiesce_done
,
1250 [DEV_EVENT_INTERRUPT
] = ccw_device_quiesce_done
,
1251 [DEV_EVENT_TIMEOUT
] = ccw_device_quiesce_timeout
,
1252 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1254 /* special states for devices gone not operational */
1255 [DEV_STATE_DISCONNECTED
] = {
1256 [DEV_EVENT_NOTOPER
] = ccw_device_nop
,
1257 [DEV_EVENT_INTERRUPT
] = ccw_device_start_id
,
1258 [DEV_EVENT_TIMEOUT
] = ccw_device_bug
,
1259 [DEV_EVENT_VERIFY
] = ccw_device_start_id
,
1261 [DEV_STATE_DISCONNECTED_SENSE_ID
] = {
1262 [DEV_EVENT_NOTOPER
] = ccw_device_recog_notoper
,
1263 [DEV_EVENT_INTERRUPT
] = ccw_device_sense_id_irq
,
1264 [DEV_EVENT_TIMEOUT
] = ccw_device_recog_timeout
,
1265 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1267 [DEV_STATE_CMFCHANGE
] = {
1268 [DEV_EVENT_NOTOPER
] = ccw_device_change_cmfstate
,
1269 [DEV_EVENT_INTERRUPT
] = ccw_device_change_cmfstate
,
1270 [DEV_EVENT_TIMEOUT
] = ccw_device_change_cmfstate
,
1271 [DEV_EVENT_VERIFY
] = ccw_device_change_cmfstate
,
1273 [DEV_STATE_CMFUPDATE
] = {
1274 [DEV_EVENT_NOTOPER
] = ccw_device_update_cmfblock
,
1275 [DEV_EVENT_INTERRUPT
] = ccw_device_update_cmfblock
,
1276 [DEV_EVENT_TIMEOUT
] = ccw_device_update_cmfblock
,
1277 [DEV_EVENT_VERIFY
] = ccw_device_update_cmfblock
,
1282 * io_subchannel_irq is called for "real" interrupts or for status
1283 * pending conditions on msch.
1286 io_subchannel_irq (struct device
*pdev
)
1288 struct ccw_device
*cdev
;
1290 cdev
= to_subchannel(pdev
)->dev
.driver_data
;
1292 CIO_TRACE_EVENT (3, "IRQ");
1293 CIO_TRACE_EVENT (3, pdev
->bus_id
);
1295 dev_fsm_event(cdev
, DEV_EVENT_INTERRUPT
);
1298 EXPORT_SYMBOL_GPL(ccw_device_set_timeout
);