2 * finite state machine for device handling
4 * Copyright IBM Corp. 2002, 2008
5 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
6 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/jiffies.h>
12 #include <linux/string.h>
14 #include <asm/ccwdev.h>
16 #include <asm/chpid.h>
19 #include "cio_debug.h"
26 static int timeout_log_enabled
;
28 static int __init
ccw_timeout_log_setup(char *unused
)
30 timeout_log_enabled
= 1;
34 __setup("ccw_timeout_log", ccw_timeout_log_setup
);
36 static void ccw_timeout_log(struct ccw_device
*cdev
)
39 struct subchannel
*sch
;
40 struct io_subchannel_private
*private;
44 sch
= to_subchannel(cdev
->dev
.parent
);
45 private = to_io_private(sch
);
47 cc
= stsch(sch
->schid
, &schib
);
49 printk(KERN_WARNING
"cio: ccw device timeout occurred at %llx, "
50 "device information:\n", get_tod_clock());
51 printk(KERN_WARNING
"cio: orb:\n");
52 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
53 orb
, sizeof(*orb
), 0);
54 printk(KERN_WARNING
"cio: ccw device bus id: %s\n",
55 dev_name(&cdev
->dev
));
56 printk(KERN_WARNING
"cio: subchannel bus id: %s\n",
58 printk(KERN_WARNING
"cio: subchannel lpm: %02x, opm: %02x, "
59 "vpm: %02x\n", sch
->lpm
, sch
->opm
, sch
->vpm
);
62 printk(KERN_WARNING
"cio: orb indicates transport mode\n");
63 printk(KERN_WARNING
"cio: last tcw:\n");
64 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
65 (void *)(addr_t
)orb
->tm
.tcw
,
66 sizeof(struct tcw
), 0);
68 printk(KERN_WARNING
"cio: orb indicates command mode\n");
69 if ((void *)(addr_t
)orb
->cmd
.cpa
== &private->sense_ccw
||
70 (void *)(addr_t
)orb
->cmd
.cpa
== cdev
->private->iccws
)
71 printk(KERN_WARNING
"cio: last channel program "
74 printk(KERN_WARNING
"cio: last channel program:\n");
76 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
77 (void *)(addr_t
)orb
->cmd
.cpa
,
78 sizeof(struct ccw1
), 0);
80 printk(KERN_WARNING
"cio: ccw device state: %d\n",
81 cdev
->private->state
);
82 printk(KERN_WARNING
"cio: store subchannel returned: cc=%d\n", cc
);
83 printk(KERN_WARNING
"cio: schib:\n");
84 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
85 &schib
, sizeof(schib
), 0);
86 printk(KERN_WARNING
"cio: ccw device flags:\n");
87 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
88 &cdev
->private->flags
, sizeof(cdev
->private->flags
), 0);
92 * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
95 ccw_device_timeout(struct timer_list
*t
)
97 struct ccw_device_private
*priv
= from_timer(priv
, t
, timer
);
98 struct ccw_device
*cdev
= priv
->cdev
;
100 spin_lock_irq(cdev
->ccwlock
);
101 if (timeout_log_enabled
)
102 ccw_timeout_log(cdev
);
103 dev_fsm_event(cdev
, DEV_EVENT_TIMEOUT
);
104 spin_unlock_irq(cdev
->ccwlock
);
111 ccw_device_set_timeout(struct ccw_device
*cdev
, int expires
)
114 del_timer(&cdev
->private->timer
);
117 if (timer_pending(&cdev
->private->timer
)) {
118 if (mod_timer(&cdev
->private->timer
, jiffies
+ expires
))
121 cdev
->private->timer
.expires
= jiffies
+ expires
;
122 add_timer(&cdev
->private->timer
);
126 ccw_device_cancel_halt_clear(struct ccw_device
*cdev
)
128 struct subchannel
*sch
;
131 sch
= to_subchannel(cdev
->dev
.parent
);
132 ret
= cio_cancel_halt_clear(sch
, &cdev
->private->iretry
);
135 CIO_MSG_EVENT(0, "0.%x.%04x: could not stop I/O\n",
136 cdev
->private->dev_id
.ssid
,
137 cdev
->private->dev_id
.devno
);
142 void ccw_device_update_sense_data(struct ccw_device
*cdev
)
144 memset(&cdev
->id
, 0, sizeof(cdev
->id
));
145 cdev
->id
.cu_type
= cdev
->private->senseid
.cu_type
;
146 cdev
->id
.cu_model
= cdev
->private->senseid
.cu_model
;
147 cdev
->id
.dev_type
= cdev
->private->senseid
.dev_type
;
148 cdev
->id
.dev_model
= cdev
->private->senseid
.dev_model
;
151 int ccw_device_test_sense_data(struct ccw_device
*cdev
)
153 return cdev
->id
.cu_type
== cdev
->private->senseid
.cu_type
&&
154 cdev
->id
.cu_model
== cdev
->private->senseid
.cu_model
&&
155 cdev
->id
.dev_type
== cdev
->private->senseid
.dev_type
&&
156 cdev
->id
.dev_model
== cdev
->private->senseid
.dev_model
;
160 * The machine won't give us any notification by machine check if a chpid has
161 * been varied online on the SE so we have to find out by magic (i. e. driving
162 * the channel subsystem to device selection and updating our path masks).
165 __recover_lost_chpids(struct subchannel
*sch
, int old_lpm
)
171 for (i
= 0; i
<8; i
++) {
173 if (!(sch
->lpm
& mask
))
177 chpid
.id
= sch
->schib
.pmcw
.chpid
[i
];
178 if (!chp_is_registered(chpid
))
179 css_schedule_eval_all();
184 * Stop device recognition.
187 ccw_device_recog_done(struct ccw_device
*cdev
, int state
)
189 struct subchannel
*sch
;
192 sch
= to_subchannel(cdev
->dev
.parent
);
194 if (cio_disable_subchannel(sch
))
195 state
= DEV_STATE_NOT_OPER
;
197 * Now that we tried recognition, we have performed device selection
198 * through ssch() and the path information is up to date.
202 /* Check since device may again have become not operational. */
203 if (cio_update_schib(sch
))
204 state
= DEV_STATE_NOT_OPER
;
206 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
208 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
)
209 /* Force reprobe on all chpids. */
211 if (sch
->lpm
!= old_lpm
)
212 __recover_lost_chpids(sch
, old_lpm
);
213 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
&&
214 (state
== DEV_STATE_NOT_OPER
|| state
== DEV_STATE_BOXED
)) {
215 cdev
->private->flags
.recog_done
= 1;
216 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
217 wake_up(&cdev
->private->wait_q
);
220 if (cdev
->private->flags
.resuming
) {
221 cdev
->private->state
= state
;
222 cdev
->private->flags
.recog_done
= 1;
223 wake_up(&cdev
->private->wait_q
);
227 case DEV_STATE_NOT_OPER
:
229 case DEV_STATE_OFFLINE
:
231 ccw_device_update_sense_data(cdev
);
234 cdev
->private->state
= DEV_STATE_OFFLINE
;
235 cdev
->private->flags
.recog_done
= 1;
236 if (ccw_device_test_sense_data(cdev
)) {
237 cdev
->private->flags
.donotify
= 1;
238 ccw_device_online(cdev
);
239 wake_up(&cdev
->private->wait_q
);
241 ccw_device_update_sense_data(cdev
);
242 ccw_device_sched_todo(cdev
, CDEV_TODO_REBIND
);
245 case DEV_STATE_BOXED
:
246 if (cdev
->id
.cu_type
!= 0) { /* device was recognized before */
247 cdev
->private->flags
.recog_done
= 1;
248 cdev
->private->state
= DEV_STATE_BOXED
;
249 wake_up(&cdev
->private->wait_q
);
254 cdev
->private->state
= state
;
255 io_subchannel_recog_done(cdev
);
256 wake_up(&cdev
->private->wait_q
);
260 * Function called from device_id.c after sense id has completed.
263 ccw_device_sense_id_done(struct ccw_device
*cdev
, int err
)
267 ccw_device_recog_done(cdev
, DEV_STATE_OFFLINE
);
269 case -ETIME
: /* Sense id stopped by timeout. */
270 ccw_device_recog_done(cdev
, DEV_STATE_BOXED
);
273 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
279 * ccw_device_notify() - inform the device's driver about an event
280 * @cdev: device for which an event occurred
281 * @event: event that occurred
284 * -%EINVAL if the device is offline or has no driver.
285 * -%EOPNOTSUPP if the device's driver has no notifier registered.
286 * %NOTIFY_OK if the driver wants to keep the device.
287 * %NOTIFY_BAD if the driver doesn't want to keep the device.
289 int ccw_device_notify(struct ccw_device
*cdev
, int event
)
297 CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
298 cdev
->private->dev_id
.ssid
, cdev
->private->dev_id
.devno
,
300 if (!cdev
->drv
->notify
) {
304 if (cdev
->drv
->notify(cdev
, event
))
312 static void ccw_device_oper_notify(struct ccw_device
*cdev
)
314 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
316 if (ccw_device_notify(cdev
, CIO_OPER
) == NOTIFY_OK
) {
317 /* Reenable channel measurements, if needed. */
318 ccw_device_sched_todo(cdev
, CDEV_TODO_ENABLE_CMF
);
319 /* Save indication for new paths. */
320 cdev
->private->path_new_mask
= sch
->vpm
;
323 /* Driver doesn't want device back. */
324 ccw_device_set_notoper(cdev
);
325 ccw_device_sched_todo(cdev
, CDEV_TODO_REBIND
);
329 * Finished with online/offline processing.
332 ccw_device_done(struct ccw_device
*cdev
, int state
)
334 struct subchannel
*sch
;
336 sch
= to_subchannel(cdev
->dev
.parent
);
338 ccw_device_set_timeout(cdev
, 0);
340 if (state
!= DEV_STATE_ONLINE
)
341 cio_disable_subchannel(sch
);
343 /* Reset device status. */
344 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
346 cdev
->private->state
= state
;
349 case DEV_STATE_BOXED
:
350 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
351 cdev
->private->dev_id
.devno
, sch
->schid
.sch_no
);
353 ccw_device_notify(cdev
, CIO_BOXED
) != NOTIFY_OK
)
354 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG
);
355 cdev
->private->flags
.donotify
= 0;
357 case DEV_STATE_NOT_OPER
:
358 CIO_MSG_EVENT(0, "Device %04x gone on subchannel %04x\n",
359 cdev
->private->dev_id
.devno
, sch
->schid
.sch_no
);
360 if (ccw_device_notify(cdev
, CIO_GONE
) != NOTIFY_OK
)
361 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG
);
363 ccw_device_set_disconnected(cdev
);
364 cdev
->private->flags
.donotify
= 0;
366 case DEV_STATE_DISCONNECTED
:
367 CIO_MSG_EVENT(0, "Disconnected device %04x on subchannel "
368 "%04x\n", cdev
->private->dev_id
.devno
,
370 if (ccw_device_notify(cdev
, CIO_NO_PATH
) != NOTIFY_OK
) {
371 cdev
->private->state
= DEV_STATE_NOT_OPER
;
372 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG
);
374 ccw_device_set_disconnected(cdev
);
375 cdev
->private->flags
.donotify
= 0;
381 if (cdev
->private->flags
.donotify
) {
382 cdev
->private->flags
.donotify
= 0;
383 ccw_device_oper_notify(cdev
);
385 wake_up(&cdev
->private->wait_q
);
389 * Start device recognition.
391 void ccw_device_recognition(struct ccw_device
*cdev
)
393 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
396 * We used to start here with a sense pgid to find out whether a device
397 * is locked by someone else. Unfortunately, the sense pgid command
398 * code has other meanings on devices predating the path grouping
399 * algorithm, so we start with sense id and box the device after an
400 * timeout (or if sense pgid during path verification detects the device
401 * is locked, as may happen on newer devices).
403 cdev
->private->flags
.recog_done
= 0;
404 cdev
->private->state
= DEV_STATE_SENSE_ID
;
405 if (cio_enable_subchannel(sch
, (u32
) (addr_t
) sch
)) {
406 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
409 ccw_device_sense_id_start(cdev
);
413 * Handle events for states that use the ccw request infrastructure.
415 static void ccw_device_request_event(struct ccw_device
*cdev
, enum dev_event e
)
418 case DEV_EVENT_NOTOPER
:
419 ccw_request_notoper(cdev
);
421 case DEV_EVENT_INTERRUPT
:
422 ccw_request_handler(cdev
);
424 case DEV_EVENT_TIMEOUT
:
425 ccw_request_timeout(cdev
);
432 static void ccw_device_report_path_events(struct ccw_device
*cdev
)
434 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
438 for (chp
= 0, mask
= 0x80; chp
< 8; chp
++, mask
>>= 1) {
439 path_event
[chp
] = PE_NONE
;
440 if (mask
& cdev
->private->path_gone_mask
& ~(sch
->vpm
))
441 path_event
[chp
] |= PE_PATH_GONE
;
442 if (mask
& cdev
->private->path_new_mask
& sch
->vpm
)
443 path_event
[chp
] |= PE_PATH_AVAILABLE
;
444 if (mask
& cdev
->private->pgid_reset_mask
& sch
->vpm
)
445 path_event
[chp
] |= PE_PATHGROUP_ESTABLISHED
;
447 if (cdev
->online
&& cdev
->drv
->path_event
)
448 cdev
->drv
->path_event(cdev
, path_event
);
451 static void ccw_device_reset_path_events(struct ccw_device
*cdev
)
453 cdev
->private->path_gone_mask
= 0;
454 cdev
->private->path_new_mask
= 0;
455 cdev
->private->pgid_reset_mask
= 0;
458 static void create_fake_irb(struct irb
*irb
, int type
)
460 memset(irb
, 0, sizeof(*irb
));
461 if (type
== FAKE_CMD_IRB
) {
462 struct cmd_scsw
*scsw
= &irb
->scsw
.cmd
;
464 scsw
->fctl
= SCSW_FCTL_START_FUNC
;
465 scsw
->actl
= SCSW_ACTL_START_PEND
;
466 scsw
->stctl
= SCSW_STCTL_STATUS_PEND
;
467 } else if (type
== FAKE_TM_IRB
) {
468 struct tm_scsw
*scsw
= &irb
->scsw
.tm
;
471 scsw
->fctl
= SCSW_FCTL_START_FUNC
;
472 scsw
->actl
= SCSW_ACTL_START_PEND
;
473 scsw
->stctl
= SCSW_STCTL_STATUS_PEND
;
477 static void ccw_device_handle_broken_paths(struct ccw_device
*cdev
)
479 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
480 u8 broken_paths
= (sch
->schib
.pmcw
.pam
& sch
->opm
) ^ sch
->vpm
;
482 if (broken_paths
&& (cdev
->private->path_broken_mask
!= broken_paths
))
483 ccw_device_schedule_recovery();
485 cdev
->private->path_broken_mask
= broken_paths
;
488 void ccw_device_verify_done(struct ccw_device
*cdev
, int err
)
490 struct subchannel
*sch
;
492 sch
= to_subchannel(cdev
->dev
.parent
);
493 /* Update schib - pom may have changed. */
494 if (cio_update_schib(sch
)) {
498 /* Update lpm with verified path mask. */
500 /* Repeat path verification? */
501 if (cdev
->private->flags
.doverify
) {
502 ccw_device_verify_start(cdev
);
508 ccw_device_done(cdev
, DEV_STATE_ONLINE
);
509 /* Deliver fake irb to device driver, if needed. */
510 if (cdev
->private->flags
.fake_irb
) {
511 create_fake_irb(&cdev
->private->irb
,
512 cdev
->private->flags
.fake_irb
);
513 cdev
->private->flags
.fake_irb
= 0;
515 cdev
->handler(cdev
, cdev
->private->intparm
,
516 &cdev
->private->irb
);
517 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
519 ccw_device_report_path_events(cdev
);
520 ccw_device_handle_broken_paths(cdev
);
524 /* Reset oper notify indication after verify error. */
525 cdev
->private->flags
.donotify
= 0;
526 ccw_device_done(cdev
, DEV_STATE_BOXED
);
529 /* Reset oper notify indication after verify error. */
530 cdev
->private->flags
.donotify
= 0;
531 ccw_device_done(cdev
, DEV_STATE_DISCONNECTED
);
534 /* Reset oper notify indication after verify error. */
535 cdev
->private->flags
.donotify
= 0;
536 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
539 ccw_device_reset_path_events(cdev
);
546 ccw_device_online(struct ccw_device
*cdev
)
548 struct subchannel
*sch
;
551 if ((cdev
->private->state
!= DEV_STATE_OFFLINE
) &&
552 (cdev
->private->state
!= DEV_STATE_BOXED
))
554 sch
= to_subchannel(cdev
->dev
.parent
);
555 ret
= cio_enable_subchannel(sch
, (u32
)(addr_t
)sch
);
557 /* Couldn't enable the subchannel for i/o. Sick device. */
559 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
562 /* Start initial path verification. */
563 cdev
->private->state
= DEV_STATE_VERIFY
;
564 ccw_device_verify_start(cdev
);
569 ccw_device_disband_done(struct ccw_device
*cdev
, int err
)
573 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
576 ccw_device_done(cdev
, DEV_STATE_BOXED
);
579 cdev
->private->flags
.donotify
= 0;
580 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
589 ccw_device_offline(struct ccw_device
*cdev
)
591 struct subchannel
*sch
;
593 /* Allow ccw_device_offline while disconnected. */
594 if (cdev
->private->state
== DEV_STATE_DISCONNECTED
||
595 cdev
->private->state
== DEV_STATE_NOT_OPER
) {
596 cdev
->private->flags
.donotify
= 0;
597 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
600 if (cdev
->private->state
== DEV_STATE_BOXED
) {
601 ccw_device_done(cdev
, DEV_STATE_BOXED
);
604 if (ccw_device_is_orphan(cdev
)) {
605 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
608 sch
= to_subchannel(cdev
->dev
.parent
);
609 if (cio_update_schib(sch
))
611 if (scsw_actl(&sch
->schib
.scsw
) != 0)
613 if (cdev
->private->state
!= DEV_STATE_ONLINE
)
615 /* Are we doing path grouping? */
616 if (!cdev
->private->flags
.pgroup
) {
617 /* No, set state offline immediately. */
618 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
621 /* Start Set Path Group commands. */
622 cdev
->private->state
= DEV_STATE_DISBAND_PGID
;
623 ccw_device_disband_start(cdev
);
628 * Handle not operational event in non-special state.
630 static void ccw_device_generic_notoper(struct ccw_device
*cdev
,
631 enum dev_event dev_event
)
633 if (ccw_device_notify(cdev
, CIO_GONE
) != NOTIFY_OK
)
634 ccw_device_sched_todo(cdev
, CDEV_TODO_UNREG
);
636 ccw_device_set_disconnected(cdev
);
640 * Handle path verification event in offline state.
642 static void ccw_device_offline_verify(struct ccw_device
*cdev
,
643 enum dev_event dev_event
)
645 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
647 css_schedule_eval(sch
->schid
);
651 * Handle path verification event.
654 ccw_device_online_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
656 struct subchannel
*sch
;
658 if (cdev
->private->state
== DEV_STATE_W4SENSE
) {
659 cdev
->private->flags
.doverify
= 1;
662 sch
= to_subchannel(cdev
->dev
.parent
);
664 * Since we might not just be coming from an interrupt from the
665 * subchannel we have to update the schib.
667 if (cio_update_schib(sch
)) {
668 ccw_device_verify_done(cdev
, -ENODEV
);
672 if (scsw_actl(&sch
->schib
.scsw
) != 0 ||
673 (scsw_stctl(&sch
->schib
.scsw
) & SCSW_STCTL_STATUS_PEND
) ||
674 (scsw_stctl(&cdev
->private->irb
.scsw
) & SCSW_STCTL_STATUS_PEND
)) {
676 * No final status yet or final status not yet delivered
677 * to the device driver. Can't do path verification now,
678 * delay until final status was delivered.
680 cdev
->private->flags
.doverify
= 1;
683 /* Device is idle, we can do the path verification. */
684 cdev
->private->state
= DEV_STATE_VERIFY
;
685 ccw_device_verify_start(cdev
);
689 * Handle path verification event in boxed state.
691 static void ccw_device_boxed_verify(struct ccw_device
*cdev
,
692 enum dev_event dev_event
)
694 struct subchannel
*sch
= to_subchannel(cdev
->dev
.parent
);
697 if (cio_enable_subchannel(sch
, (u32
) (addr_t
) sch
))
698 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
700 ccw_device_online_verify(cdev
, dev_event
);
702 css_schedule_eval(sch
->schid
);
706 * Pass interrupt to device driver.
708 static int ccw_device_call_handler(struct ccw_device
*cdev
)
714 * we allow for the device action handler if .
715 * - we received ending status
716 * - the action handler requested to see all interrupts
717 * - we received an intermediate status
718 * - fast notification was requested (primary status)
719 * - unsolicited interrupts
721 stctl
= scsw_stctl(&cdev
->private->irb
.scsw
);
722 ending_status
= (stctl
& SCSW_STCTL_SEC_STATUS
) ||
723 (stctl
== (SCSW_STCTL_ALERT_STATUS
| SCSW_STCTL_STATUS_PEND
)) ||
724 (stctl
== SCSW_STCTL_STATUS_PEND
);
725 if (!ending_status
&&
726 !cdev
->private->options
.repall
&&
727 !(stctl
& SCSW_STCTL_INTER_STATUS
) &&
728 !(cdev
->private->options
.fast
&&
729 (stctl
& SCSW_STCTL_PRIM_STATUS
)))
733 ccw_device_set_timeout(cdev
, 0);
736 cdev
->handler(cdev
, cdev
->private->intparm
,
737 &cdev
->private->irb
);
739 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
744 * Got an interrupt for a normal io (state online).
747 ccw_device_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
752 irb
= this_cpu_ptr(&cio_irb
);
753 is_cmd
= !scsw_is_tm(&irb
->scsw
);
754 /* Check for unsolicited interrupt. */
755 if (!scsw_is_solicited(&irb
->scsw
)) {
756 if (is_cmd
&& (irb
->scsw
.cmd
.dstat
& DEV_STAT_UNIT_CHECK
) &&
757 !irb
->esw
.esw0
.erw
.cons
) {
758 /* Unit check but no sense data. Need basic sense. */
759 if (ccw_device_do_sense(cdev
, irb
) != 0)
760 goto call_handler_unsol
;
761 memcpy(&cdev
->private->irb
, irb
, sizeof(struct irb
));
762 cdev
->private->state
= DEV_STATE_W4SENSE
;
763 cdev
->private->intparm
= 0;
768 cdev
->handler (cdev
, 0, irb
);
769 if (cdev
->private->flags
.doverify
)
770 ccw_device_online_verify(cdev
, 0);
773 /* Accumulate status and find out if a basic sense is needed. */
774 ccw_device_accumulate_irb(cdev
, irb
);
775 if (is_cmd
&& cdev
->private->flags
.dosense
) {
776 if (ccw_device_do_sense(cdev
, irb
) == 0) {
777 cdev
->private->state
= DEV_STATE_W4SENSE
;
781 /* Call the handler. */
782 if (ccw_device_call_handler(cdev
) && cdev
->private->flags
.doverify
)
783 /* Start delayed path verification. */
784 ccw_device_online_verify(cdev
, 0);
788 * Got an timeout in online state.
791 ccw_device_online_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
795 ccw_device_set_timeout(cdev
, 0);
796 cdev
->private->iretry
= 255;
797 ret
= ccw_device_cancel_halt_clear(cdev
);
799 ccw_device_set_timeout(cdev
, 3*HZ
);
800 cdev
->private->state
= DEV_STATE_TIMEOUT_KILL
;
804 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
805 else if (cdev
->handler
)
806 cdev
->handler(cdev
, cdev
->private->intparm
,
807 ERR_PTR(-ETIMEDOUT
));
811 * Got an interrupt for a basic sense.
814 ccw_device_w4sense(struct ccw_device
*cdev
, enum dev_event dev_event
)
818 irb
= this_cpu_ptr(&cio_irb
);
819 /* Check for unsolicited interrupt. */
820 if (scsw_stctl(&irb
->scsw
) ==
821 (SCSW_STCTL_STATUS_PEND
| SCSW_STCTL_ALERT_STATUS
)) {
822 if (scsw_cc(&irb
->scsw
) == 1)
823 /* Basic sense hasn't started. Try again. */
824 ccw_device_do_sense(cdev
, irb
);
826 CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
827 "interrupt during w4sense...\n",
828 cdev
->private->dev_id
.ssid
,
829 cdev
->private->dev_id
.devno
);
831 cdev
->handler (cdev
, 0, irb
);
836 * Check if a halt or clear has been issued in the meanwhile. If yes,
837 * only deliver the halt/clear interrupt to the device driver as if it
838 * had killed the original request.
840 if (scsw_fctl(&irb
->scsw
) &
841 (SCSW_FCTL_CLEAR_FUNC
| SCSW_FCTL_HALT_FUNC
)) {
842 cdev
->private->flags
.dosense
= 0;
843 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
844 ccw_device_accumulate_irb(cdev
, irb
);
847 /* Add basic sense info to irb. */
848 ccw_device_accumulate_basic_sense(cdev
, irb
);
849 if (cdev
->private->flags
.dosense
) {
850 /* Another basic sense is needed. */
851 ccw_device_do_sense(cdev
, irb
);
855 cdev
->private->state
= DEV_STATE_ONLINE
;
856 /* In case sensing interfered with setting the device online */
857 wake_up(&cdev
->private->wait_q
);
858 /* Call the handler. */
859 if (ccw_device_call_handler(cdev
) && cdev
->private->flags
.doverify
)
860 /* Start delayed path verification. */
861 ccw_device_online_verify(cdev
, 0);
865 ccw_device_killing_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
867 ccw_device_set_timeout(cdev
, 0);
868 /* Start delayed path verification. */
869 ccw_device_online_verify(cdev
, 0);
870 /* OK, i/o is dead now. Call interrupt handler. */
872 cdev
->handler(cdev
, cdev
->private->intparm
,
877 ccw_device_killing_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
881 ret
= ccw_device_cancel_halt_clear(cdev
);
883 ccw_device_set_timeout(cdev
, 3*HZ
);
886 /* Start delayed path verification. */
887 ccw_device_online_verify(cdev
, 0);
889 cdev
->handler(cdev
, cdev
->private->intparm
,
893 void ccw_device_kill_io(struct ccw_device
*cdev
)
897 cdev
->private->iretry
= 255;
898 ret
= ccw_device_cancel_halt_clear(cdev
);
900 ccw_device_set_timeout(cdev
, 3*HZ
);
901 cdev
->private->state
= DEV_STATE_TIMEOUT_KILL
;
904 /* Start delayed path verification. */
905 ccw_device_online_verify(cdev
, 0);
907 cdev
->handler(cdev
, cdev
->private->intparm
,
912 ccw_device_delay_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
914 /* Start verification after current task finished. */
915 cdev
->private->flags
.doverify
= 1;
919 ccw_device_start_id(struct ccw_device
*cdev
, enum dev_event dev_event
)
921 struct subchannel
*sch
;
923 sch
= to_subchannel(cdev
->dev
.parent
);
924 if (cio_enable_subchannel(sch
, (u32
)(addr_t
)sch
) != 0)
925 /* Couldn't enable the subchannel for i/o. Sick device. */
927 cdev
->private->state
= DEV_STATE_DISCONNECTED_SENSE_ID
;
928 ccw_device_sense_id_start(cdev
);
931 void ccw_device_trigger_reprobe(struct ccw_device
*cdev
)
933 struct subchannel
*sch
;
935 if (cdev
->private->state
!= DEV_STATE_DISCONNECTED
)
938 sch
= to_subchannel(cdev
->dev
.parent
);
939 /* Update some values. */
940 if (cio_update_schib(sch
))
943 * The pim, pam, pom values may not be accurate, but they are the best
944 * we have before performing device selection :/
946 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
948 * Use the initial configuration since we can't be shure that the old
951 io_subchannel_init_config(sch
);
952 if (cio_commit_config(sch
))
955 /* We should also udate ssd info, but this has to wait. */
956 /* Check if this is another device which appeared on the same sch. */
957 if (sch
->schib
.pmcw
.dev
!= cdev
->private->dev_id
.devno
)
958 css_schedule_eval(sch
->schid
);
960 ccw_device_start_id(cdev
, 0);
963 static void ccw_device_disabled_irq(struct ccw_device
*cdev
,
964 enum dev_event dev_event
)
966 struct subchannel
*sch
;
968 sch
= to_subchannel(cdev
->dev
.parent
);
970 * An interrupt in a disabled state means a previous disable was not
971 * successful - should not happen, but we try to disable again.
973 cio_disable_subchannel(sch
);
977 ccw_device_change_cmfstate(struct ccw_device
*cdev
, enum dev_event dev_event
)
979 retry_set_schib(cdev
);
980 cdev
->private->state
= DEV_STATE_ONLINE
;
981 dev_fsm_event(cdev
, dev_event
);
984 static void ccw_device_update_cmfblock(struct ccw_device
*cdev
,
985 enum dev_event dev_event
)
987 cmf_retry_copy_block(cdev
);
988 cdev
->private->state
= DEV_STATE_ONLINE
;
989 dev_fsm_event(cdev
, dev_event
);
993 ccw_device_quiesce_done(struct ccw_device
*cdev
, enum dev_event dev_event
)
995 ccw_device_set_timeout(cdev
, 0);
996 cdev
->private->state
= DEV_STATE_NOT_OPER
;
997 wake_up(&cdev
->private->wait_q
);
1001 ccw_device_quiesce_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
1005 ret
= ccw_device_cancel_halt_clear(cdev
);
1006 if (ret
== -EBUSY
) {
1007 ccw_device_set_timeout(cdev
, HZ
/10);
1009 cdev
->private->state
= DEV_STATE_NOT_OPER
;
1010 wake_up(&cdev
->private->wait_q
);
1015 * No operation action. This is used e.g. to ignore a timeout event in
1019 ccw_device_nop(struct ccw_device
*cdev
, enum dev_event dev_event
)
1024 * device statemachine
1026 fsm_func_t
*dev_jumptable
[NR_DEV_STATES
][NR_DEV_EVENTS
] = {
1027 [DEV_STATE_NOT_OPER
] = {
1028 [DEV_EVENT_NOTOPER
] = ccw_device_nop
,
1029 [DEV_EVENT_INTERRUPT
] = ccw_device_disabled_irq
,
1030 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1031 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1033 [DEV_STATE_SENSE_ID
] = {
1034 [DEV_EVENT_NOTOPER
] = ccw_device_request_event
,
1035 [DEV_EVENT_INTERRUPT
] = ccw_device_request_event
,
1036 [DEV_EVENT_TIMEOUT
] = ccw_device_request_event
,
1037 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1039 [DEV_STATE_OFFLINE
] = {
1040 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1041 [DEV_EVENT_INTERRUPT
] = ccw_device_disabled_irq
,
1042 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1043 [DEV_EVENT_VERIFY
] = ccw_device_offline_verify
,
1045 [DEV_STATE_VERIFY
] = {
1046 [DEV_EVENT_NOTOPER
] = ccw_device_request_event
,
1047 [DEV_EVENT_INTERRUPT
] = ccw_device_request_event
,
1048 [DEV_EVENT_TIMEOUT
] = ccw_device_request_event
,
1049 [DEV_EVENT_VERIFY
] = ccw_device_delay_verify
,
1051 [DEV_STATE_ONLINE
] = {
1052 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1053 [DEV_EVENT_INTERRUPT
] = ccw_device_irq
,
1054 [DEV_EVENT_TIMEOUT
] = ccw_device_online_timeout
,
1055 [DEV_EVENT_VERIFY
] = ccw_device_online_verify
,
1057 [DEV_STATE_W4SENSE
] = {
1058 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1059 [DEV_EVENT_INTERRUPT
] = ccw_device_w4sense
,
1060 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1061 [DEV_EVENT_VERIFY
] = ccw_device_online_verify
,
1063 [DEV_STATE_DISBAND_PGID
] = {
1064 [DEV_EVENT_NOTOPER
] = ccw_device_request_event
,
1065 [DEV_EVENT_INTERRUPT
] = ccw_device_request_event
,
1066 [DEV_EVENT_TIMEOUT
] = ccw_device_request_event
,
1067 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1069 [DEV_STATE_BOXED
] = {
1070 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1071 [DEV_EVENT_INTERRUPT
] = ccw_device_nop
,
1072 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1073 [DEV_EVENT_VERIFY
] = ccw_device_boxed_verify
,
1075 /* states to wait for i/o completion before doing something */
1076 [DEV_STATE_TIMEOUT_KILL
] = {
1077 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1078 [DEV_EVENT_INTERRUPT
] = ccw_device_killing_irq
,
1079 [DEV_EVENT_TIMEOUT
] = ccw_device_killing_timeout
,
1080 [DEV_EVENT_VERIFY
] = ccw_device_nop
, //FIXME
1082 [DEV_STATE_QUIESCE
] = {
1083 [DEV_EVENT_NOTOPER
] = ccw_device_quiesce_done
,
1084 [DEV_EVENT_INTERRUPT
] = ccw_device_quiesce_done
,
1085 [DEV_EVENT_TIMEOUT
] = ccw_device_quiesce_timeout
,
1086 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1088 /* special states for devices gone not operational */
1089 [DEV_STATE_DISCONNECTED
] = {
1090 [DEV_EVENT_NOTOPER
] = ccw_device_nop
,
1091 [DEV_EVENT_INTERRUPT
] = ccw_device_start_id
,
1092 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1093 [DEV_EVENT_VERIFY
] = ccw_device_start_id
,
1095 [DEV_STATE_DISCONNECTED_SENSE_ID
] = {
1096 [DEV_EVENT_NOTOPER
] = ccw_device_request_event
,
1097 [DEV_EVENT_INTERRUPT
] = ccw_device_request_event
,
1098 [DEV_EVENT_TIMEOUT
] = ccw_device_request_event
,
1099 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1101 [DEV_STATE_CMFCHANGE
] = {
1102 [DEV_EVENT_NOTOPER
] = ccw_device_change_cmfstate
,
1103 [DEV_EVENT_INTERRUPT
] = ccw_device_change_cmfstate
,
1104 [DEV_EVENT_TIMEOUT
] = ccw_device_change_cmfstate
,
1105 [DEV_EVENT_VERIFY
] = ccw_device_change_cmfstate
,
1107 [DEV_STATE_CMFUPDATE
] = {
1108 [DEV_EVENT_NOTOPER
] = ccw_device_update_cmfblock
,
1109 [DEV_EVENT_INTERRUPT
] = ccw_device_update_cmfblock
,
1110 [DEV_EVENT_TIMEOUT
] = ccw_device_update_cmfblock
,
1111 [DEV_EVENT_VERIFY
] = ccw_device_update_cmfblock
,
1113 [DEV_STATE_STEAL_LOCK
] = {
1114 [DEV_EVENT_NOTOPER
] = ccw_device_request_event
,
1115 [DEV_EVENT_INTERRUPT
] = ccw_device_request_event
,
1116 [DEV_EVENT_TIMEOUT
] = ccw_device_request_event
,
1117 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1121 EXPORT_SYMBOL_GPL(ccw_device_set_timeout
);