2 * drivers/s390/cio/device_fsm.c
3 * finite state machine for device handling
5 * Copyright IBM Corp. 2002,2008
6 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
7 * Martin Schwidefsky (schwidefsky@de.ibm.com)
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/jiffies.h>
13 #include <linux/string.h>
15 #include <asm/ccwdev.h>
17 #include <asm/chpid.h>
20 #include "cio_debug.h"
27 static int timeout_log_enabled
;
29 static int __init
ccw_timeout_log_setup(char *unused
)
31 timeout_log_enabled
= 1;
35 __setup("ccw_timeout_log", ccw_timeout_log_setup
);
37 static void ccw_timeout_log(struct ccw_device
*cdev
)
40 struct subchannel
*sch
;
41 struct io_subchannel_private
*private;
45 sch
= to_subchannel(cdev
->dev
.parent
);
46 private = to_io_private(sch
);
48 cc
= stsch(sch
->schid
, &schib
);
50 printk(KERN_WARNING
"cio: ccw device timeout occurred at %llx, "
51 "device information:\n", get_clock());
52 printk(KERN_WARNING
"cio: orb:\n");
53 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
54 orb
, sizeof(*orb
), 0);
55 printk(KERN_WARNING
"cio: ccw device bus id: %s\n",
56 dev_name(&cdev
->dev
));
57 printk(KERN_WARNING
"cio: subchannel bus id: %s\n",
59 printk(KERN_WARNING
"cio: subchannel lpm: %02x, opm: %02x, "
60 "vpm: %02x\n", sch
->lpm
, sch
->opm
, sch
->vpm
);
63 printk(KERN_WARNING
"cio: orb indicates transport mode\n");
64 printk(KERN_WARNING
"cio: last tcw:\n");
65 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
66 (void *)(addr_t
)orb
->tm
.tcw
,
67 sizeof(struct tcw
), 0);
69 printk(KERN_WARNING
"cio: orb indicates command mode\n");
70 if ((void *)(addr_t
)orb
->cmd
.cpa
== &private->sense_ccw
||
71 (void *)(addr_t
)orb
->cmd
.cpa
== cdev
->private->iccws
)
72 printk(KERN_WARNING
"cio: last channel program "
75 printk(KERN_WARNING
"cio: last channel program:\n");
77 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
78 (void *)(addr_t
)orb
->cmd
.cpa
,
79 sizeof(struct ccw1
), 0);
81 printk(KERN_WARNING
"cio: ccw device state: %d\n",
82 cdev
->private->state
);
83 printk(KERN_WARNING
"cio: store subchannel returned: cc=%d\n", cc
);
84 printk(KERN_WARNING
"cio: schib:\n");
85 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
86 &schib
, sizeof(schib
), 0);
87 printk(KERN_WARNING
"cio: ccw device flags:\n");
88 print_hex_dump(KERN_WARNING
, "cio: ", DUMP_PREFIX_NONE
, 16, 1,
89 &cdev
->private->flags
, sizeof(cdev
->private->flags
), 0);
93 * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
96 ccw_device_timeout(unsigned long data
)
98 struct ccw_device
*cdev
;
100 cdev
= (struct ccw_device
*) data
;
101 spin_lock_irq(cdev
->ccwlock
);
102 if (timeout_log_enabled
)
103 ccw_timeout_log(cdev
);
104 dev_fsm_event(cdev
, DEV_EVENT_TIMEOUT
);
105 spin_unlock_irq(cdev
->ccwlock
);
112 ccw_device_set_timeout(struct ccw_device
*cdev
, int expires
)
115 del_timer(&cdev
->private->timer
);
118 if (timer_pending(&cdev
->private->timer
)) {
119 if (mod_timer(&cdev
->private->timer
, jiffies
+ expires
))
122 cdev
->private->timer
.function
= ccw_device_timeout
;
123 cdev
->private->timer
.data
= (unsigned long) cdev
;
124 cdev
->private->timer
.expires
= jiffies
+ expires
;
125 add_timer(&cdev
->private->timer
);
129 * Cancel running i/o. This is called repeatedly since halt/clear are
130 * asynchronous operations. We do one try with cio_cancel, two tries
131 * with cio_halt, 255 tries with cio_clear. If everythings fails panic.
132 * Returns 0 if device now idle, -ENODEV for device not operational and
133 * -EBUSY if an interrupt is expected (either from halt/clear or from a
137 ccw_device_cancel_halt_clear(struct ccw_device
*cdev
)
139 struct subchannel
*sch
;
142 sch
= to_subchannel(cdev
->dev
.parent
);
143 if (cio_update_schib(sch
))
145 if (!sch
->schib
.pmcw
.ena
)
146 /* Not operational -> done. */
148 /* Stage 1: cancel io. */
149 if (!(scsw_actl(&sch
->schib
.scsw
) & SCSW_ACTL_HALT_PEND
) &&
150 !(scsw_actl(&sch
->schib
.scsw
) & SCSW_ACTL_CLEAR_PEND
)) {
151 if (!scsw_is_tm(&sch
->schib
.scsw
)) {
152 ret
= cio_cancel(sch
);
156 /* cancel io unsuccessful or not applicable (transport mode).
157 * Continue with asynchronous instructions. */
158 cdev
->private->iretry
= 3; /* 3 halt retries. */
160 if (!(scsw_actl(&sch
->schib
.scsw
) & SCSW_ACTL_CLEAR_PEND
)) {
161 /* Stage 2: halt io. */
162 if (cdev
->private->iretry
) {
163 cdev
->private->iretry
--;
166 return (ret
== 0) ? -EBUSY
: ret
;
168 /* halt io unsuccessful. */
169 cdev
->private->iretry
= 255; /* 255 clear retries. */
171 /* Stage 3: clear io. */
172 if (cdev
->private->iretry
) {
173 cdev
->private->iretry
--;
174 ret
= cio_clear (sch
);
175 return (ret
== 0) ? -EBUSY
: ret
;
177 panic("Can't stop i/o on subchannel.\n");
181 ccw_device_handle_oper(struct ccw_device
*cdev
)
183 struct subchannel
*sch
;
185 sch
= to_subchannel(cdev
->dev
.parent
);
186 cdev
->private->flags
.recog_done
= 1;
188 * Check if cu type and device type still match. If
189 * not, it is certainly another device and we have to
190 * de- and re-register.
192 if (cdev
->id
.cu_type
!= cdev
->private->senseid
.cu_type
||
193 cdev
->id
.cu_model
!= cdev
->private->senseid
.cu_model
||
194 cdev
->id
.dev_type
!= cdev
->private->senseid
.dev_type
||
195 cdev
->id
.dev_model
!= cdev
->private->senseid
.dev_model
) {
196 PREPARE_WORK(&cdev
->private->kick_work
,
197 ccw_device_do_unreg_rereg
);
198 queue_work(ccw_device_work
, &cdev
->private->kick_work
);
201 cdev
->private->flags
.donotify
= 1;
206 * The machine won't give us any notification by machine check if a chpid has
207 * been varied online on the SE so we have to find out by magic (i. e. driving
208 * the channel subsystem to device selection and updating our path masks).
211 __recover_lost_chpids(struct subchannel
*sch
, int old_lpm
)
217 for (i
= 0; i
<8; i
++) {
219 if (!(sch
->lpm
& mask
))
223 chpid
.id
= sch
->schib
.pmcw
.chpid
[i
];
224 if (!chp_is_registered(chpid
))
225 css_schedule_eval_all();
230 * Stop device recognition.
233 ccw_device_recog_done(struct ccw_device
*cdev
, int state
)
235 struct subchannel
*sch
;
236 int notify
, old_lpm
, same_dev
;
238 sch
= to_subchannel(cdev
->dev
.parent
);
240 ccw_device_set_timeout(cdev
, 0);
241 cio_disable_subchannel(sch
);
243 * Now that we tried recognition, we have performed device selection
244 * through ssch() and the path information is up to date.
248 /* Check since device may again have become not operational. */
249 if (cio_update_schib(sch
))
250 state
= DEV_STATE_NOT_OPER
;
252 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
254 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
)
255 /* Force reprobe on all chpids. */
257 if (sch
->lpm
!= old_lpm
)
258 __recover_lost_chpids(sch
, old_lpm
);
259 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
) {
260 if (state
== DEV_STATE_NOT_OPER
) {
261 cdev
->private->flags
.recog_done
= 1;
262 cdev
->private->state
= DEV_STATE_DISCONNECTED
;
265 /* Boxed devices don't need extra treatment. */
268 same_dev
= 0; /* Keep the compiler quiet... */
270 case DEV_STATE_NOT_OPER
:
271 CIO_MSG_EVENT(2, "SenseID : unknown device %04x on "
272 "subchannel 0.%x.%04x\n",
273 cdev
->private->dev_id
.devno
,
274 sch
->schid
.ssid
, sch
->schid
.sch_no
);
276 case DEV_STATE_OFFLINE
:
277 if (cdev
->private->state
== DEV_STATE_DISCONNECTED_SENSE_ID
) {
278 same_dev
= ccw_device_handle_oper(cdev
);
281 /* fill out sense information */
282 memset(&cdev
->id
, 0, sizeof(cdev
->id
));
283 cdev
->id
.cu_type
= cdev
->private->senseid
.cu_type
;
284 cdev
->id
.cu_model
= cdev
->private->senseid
.cu_model
;
285 cdev
->id
.dev_type
= cdev
->private->senseid
.dev_type
;
286 cdev
->id
.dev_model
= cdev
->private->senseid
.dev_model
;
288 cdev
->private->state
= DEV_STATE_OFFLINE
;
290 /* Get device online again. */
291 ccw_device_online(cdev
);
292 wake_up(&cdev
->private->wait_q
);
296 /* Issue device info message. */
297 CIO_MSG_EVENT(4, "SenseID : device 0.%x.%04x reports: "
298 "CU Type/Mod = %04X/%02X, Dev Type/Mod = "
300 cdev
->private->dev_id
.ssid
,
301 cdev
->private->dev_id
.devno
,
302 cdev
->id
.cu_type
, cdev
->id
.cu_model
,
303 cdev
->id
.dev_type
, cdev
->id
.dev_model
);
305 case DEV_STATE_BOXED
:
306 CIO_MSG_EVENT(0, "SenseID : boxed device %04x on "
307 " subchannel 0.%x.%04x\n",
308 cdev
->private->dev_id
.devno
,
309 sch
->schid
.ssid
, sch
->schid
.sch_no
);
312 cdev
->private->state
= state
;
313 io_subchannel_recog_done(cdev
);
314 if (state
!= DEV_STATE_NOT_OPER
)
315 wake_up(&cdev
->private->wait_q
);
319 * Function called from device_id.c after sense id has completed.
322 ccw_device_sense_id_done(struct ccw_device
*cdev
, int err
)
326 ccw_device_recog_done(cdev
, DEV_STATE_OFFLINE
);
328 case -ETIME
: /* Sense id stopped by timeout. */
329 ccw_device_recog_done(cdev
, DEV_STATE_BOXED
);
332 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
337 int ccw_device_notify(struct ccw_device
*cdev
, int event
)
343 CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
344 cdev
->private->dev_id
.ssid
, cdev
->private->dev_id
.devno
,
346 return cdev
->drv
->notify
? cdev
->drv
->notify(cdev
, event
) : 0;
349 static void cmf_reenable_delayed(struct work_struct
*work
)
351 struct ccw_device_private
*priv
;
352 struct ccw_device
*cdev
;
354 priv
= container_of(work
, struct ccw_device_private
, kick_work
);
359 static void ccw_device_oper_notify(struct ccw_device
*cdev
)
361 if (ccw_device_notify(cdev
, CIO_OPER
)) {
362 /* Reenable channel measurements, if needed. */
363 PREPARE_WORK(&cdev
->private->kick_work
, cmf_reenable_delayed
);
364 queue_work(ccw_device_work
, &cdev
->private->kick_work
);
367 /* Driver doesn't want device back. */
368 ccw_device_set_notoper(cdev
);
369 PREPARE_WORK(&cdev
->private->kick_work
, ccw_device_do_unreg_rereg
);
370 queue_work(ccw_device_work
, &cdev
->private->kick_work
);
374 * Finished with online/offline processing.
377 ccw_device_done(struct ccw_device
*cdev
, int state
)
379 struct subchannel
*sch
;
381 sch
= to_subchannel(cdev
->dev
.parent
);
383 ccw_device_set_timeout(cdev
, 0);
385 if (state
!= DEV_STATE_ONLINE
)
386 cio_disable_subchannel(sch
);
388 /* Reset device status. */
389 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
391 cdev
->private->state
= state
;
394 if (state
== DEV_STATE_BOXED
)
395 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
396 cdev
->private->dev_id
.devno
, sch
->schid
.sch_no
);
398 if (cdev
->private->flags
.donotify
) {
399 cdev
->private->flags
.donotify
= 0;
400 ccw_device_oper_notify(cdev
);
402 wake_up(&cdev
->private->wait_q
);
405 static int cmp_pgid(struct pgid
*p1
, struct pgid
*p2
)
413 return memcmp(c1
+ 1, c2
+ 1, sizeof(struct pgid
) - 1);
416 static void __ccw_device_get_common_pgid(struct ccw_device
*cdev
)
422 for (i
= 0; i
< 8; i
++) {
423 if (cdev
->private->pgid
[i
].inf
.ps
.state1
== SNID_STATE1_RESET
)
426 if (cdev
->private->pgid
[last
].inf
.ps
.state1
==
428 /* First non-zero PGID */
432 if (cmp_pgid(&cdev
->private->pgid
[i
],
433 &cdev
->private->pgid
[last
]) == 0)
434 /* Non-conflicting PGIDs */
437 /* PGID mismatch, can't pathgroup. */
438 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
439 "0.%x.%04x, can't pathgroup\n",
440 cdev
->private->dev_id
.ssid
,
441 cdev
->private->dev_id
.devno
);
442 cdev
->private->options
.pgroup
= 0;
445 if (cdev
->private->pgid
[last
].inf
.ps
.state1
==
447 /* No previous pgid found */
448 memcpy(&cdev
->private->pgid
[0],
449 &channel_subsystems
[0]->global_pgid
,
450 sizeof(struct pgid
));
452 /* Use existing pgid */
453 memcpy(&cdev
->private->pgid
[0], &cdev
->private->pgid
[last
],
454 sizeof(struct pgid
));
458 * Function called from device_pgid.c after sense path ground has completed.
461 ccw_device_sense_pgid_done(struct ccw_device
*cdev
, int err
)
463 struct subchannel
*sch
;
465 sch
= to_subchannel(cdev
->dev
.parent
);
467 case -EOPNOTSUPP
: /* path grouping not supported, use nop instead. */
468 cdev
->private->options
.pgroup
= 0;
470 case 0: /* success */
471 case -EACCES
: /* partial success, some paths not operational */
472 /* Check if all pgids are equal or 0. */
473 __ccw_device_get_common_pgid(cdev
);
475 case -ETIME
: /* Sense path group id stopped by timeout. */
476 case -EUSERS
: /* device is reserved for someone else. */
477 ccw_device_done(cdev
, DEV_STATE_BOXED
);
480 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
483 /* Start Path Group verification. */
484 cdev
->private->state
= DEV_STATE_VERIFY
;
485 cdev
->private->flags
.doverify
= 0;
486 ccw_device_verify_start(cdev
);
490 * Start device recognition.
493 ccw_device_recognition(struct ccw_device
*cdev
)
495 struct subchannel
*sch
;
498 if ((cdev
->private->state
!= DEV_STATE_NOT_OPER
) &&
499 (cdev
->private->state
!= DEV_STATE_BOXED
))
501 sch
= to_subchannel(cdev
->dev
.parent
);
502 ret
= cio_enable_subchannel(sch
, (u32
)(addr_t
)sch
);
504 /* Couldn't enable the subchannel for i/o. Sick device. */
507 /* After 60s the device recognition is considered to have failed. */
508 ccw_device_set_timeout(cdev
, 60*HZ
);
511 * We used to start here with a sense pgid to find out whether a device
512 * is locked by someone else. Unfortunately, the sense pgid command
513 * code has other meanings on devices predating the path grouping
514 * algorithm, so we start with sense id and box the device after an
515 * timeout (or if sense pgid during path verification detects the device
516 * is locked, as may happen on newer devices).
518 cdev
->private->flags
.recog_done
= 0;
519 cdev
->private->state
= DEV_STATE_SENSE_ID
;
520 ccw_device_sense_id_start(cdev
);
525 * Handle timeout in device recognition.
528 ccw_device_recog_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
532 ret
= ccw_device_cancel_halt_clear(cdev
);
535 ccw_device_recog_done(cdev
, DEV_STATE_BOXED
);
538 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
541 ccw_device_set_timeout(cdev
, 3*HZ
);
547 ccw_device_verify_done(struct ccw_device
*cdev
, int err
)
549 struct subchannel
*sch
;
551 sch
= to_subchannel(cdev
->dev
.parent
);
552 /* Update schib - pom may have changed. */
553 if (cio_update_schib(sch
)) {
554 cdev
->private->flags
.donotify
= 0;
555 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
558 /* Update lpm with verified path mask. */
560 /* Repeat path verification? */
561 if (cdev
->private->flags
.doverify
) {
562 cdev
->private->flags
.doverify
= 0;
563 ccw_device_verify_start(cdev
);
567 case -EOPNOTSUPP
: /* path grouping not supported, just set online. */
568 cdev
->private->options
.pgroup
= 0;
570 ccw_device_done(cdev
, DEV_STATE_ONLINE
);
571 /* Deliver fake irb to device driver, if needed. */
572 if (cdev
->private->flags
.fake_irb
) {
573 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
574 cdev
->private->irb
.scsw
.cmd
.cc
= 1;
575 cdev
->private->irb
.scsw
.cmd
.fctl
= SCSW_FCTL_START_FUNC
;
576 cdev
->private->irb
.scsw
.cmd
.actl
= SCSW_ACTL_START_PEND
;
577 cdev
->private->irb
.scsw
.cmd
.stctl
=
578 SCSW_STCTL_STATUS_PEND
;
579 cdev
->private->flags
.fake_irb
= 0;
581 cdev
->handler(cdev
, cdev
->private->intparm
,
582 &cdev
->private->irb
);
583 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
587 /* Reset oper notify indication after verify error. */
588 cdev
->private->flags
.donotify
= 0;
589 ccw_device_done(cdev
, DEV_STATE_BOXED
);
592 /* Reset oper notify indication after verify error. */
593 cdev
->private->flags
.donotify
= 0;
595 ccw_device_set_timeout(cdev
, 0);
596 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
598 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
607 ccw_device_online(struct ccw_device
*cdev
)
609 struct subchannel
*sch
;
612 if ((cdev
->private->state
!= DEV_STATE_OFFLINE
) &&
613 (cdev
->private->state
!= DEV_STATE_BOXED
))
615 sch
= to_subchannel(cdev
->dev
.parent
);
616 ret
= cio_enable_subchannel(sch
, (u32
)(addr_t
)sch
);
618 /* Couldn't enable the subchannel for i/o. Sick device. */
620 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
623 /* Do we want to do path grouping? */
624 if (!cdev
->private->options
.pgroup
) {
625 /* Start initial path verification. */
626 cdev
->private->state
= DEV_STATE_VERIFY
;
627 cdev
->private->flags
.doverify
= 0;
628 ccw_device_verify_start(cdev
);
631 /* Do a SensePGID first. */
632 cdev
->private->state
= DEV_STATE_SENSE_PGID
;
633 ccw_device_sense_pgid_start(cdev
);
638 ccw_device_disband_done(struct ccw_device
*cdev
, int err
)
642 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
645 ccw_device_done(cdev
, DEV_STATE_BOXED
);
648 cdev
->private->flags
.donotify
= 0;
649 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
650 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
659 ccw_device_offline(struct ccw_device
*cdev
)
661 struct subchannel
*sch
;
663 /* Allow ccw_device_offline while disconnected. */
664 if (cdev
->private->state
== DEV_STATE_DISCONNECTED
||
665 cdev
->private->state
== DEV_STATE_NOT_OPER
) {
666 cdev
->private->flags
.donotify
= 0;
667 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
670 if (ccw_device_is_orphan(cdev
)) {
671 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
674 sch
= to_subchannel(cdev
->dev
.parent
);
675 if (cio_update_schib(sch
))
677 if (scsw_actl(&sch
->schib
.scsw
) != 0)
679 if (cdev
->private->state
!= DEV_STATE_ONLINE
)
681 /* Are we doing path grouping? */
682 if (!cdev
->private->options
.pgroup
) {
683 /* No, set state offline immediately. */
684 ccw_device_done(cdev
, DEV_STATE_OFFLINE
);
687 /* Start Set Path Group commands. */
688 cdev
->private->state
= DEV_STATE_DISBAND_PGID
;
689 ccw_device_disband_start(cdev
);
694 * Handle timeout in device online/offline process.
697 ccw_device_onoff_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
701 ret
= ccw_device_cancel_halt_clear(cdev
);
704 ccw_device_done(cdev
, DEV_STATE_BOXED
);
707 ccw_device_done(cdev
, DEV_STATE_NOT_OPER
);
710 ccw_device_set_timeout(cdev
, 3*HZ
);
715 * Handle not oper event in device recognition.
718 ccw_device_recog_notoper(struct ccw_device
*cdev
, enum dev_event dev_event
)
720 ccw_device_recog_done(cdev
, DEV_STATE_NOT_OPER
);
724 * Handle not operational event in non-special state.
726 static void ccw_device_generic_notoper(struct ccw_device
*cdev
,
727 enum dev_event dev_event
)
729 struct subchannel
*sch
;
731 cdev
->private->state
= DEV_STATE_NOT_OPER
;
732 sch
= to_subchannel(cdev
->dev
.parent
);
733 css_schedule_eval(sch
->schid
);
737 * Handle path verification event.
740 ccw_device_online_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
742 struct subchannel
*sch
;
744 if (cdev
->private->state
== DEV_STATE_W4SENSE
) {
745 cdev
->private->flags
.doverify
= 1;
748 sch
= to_subchannel(cdev
->dev
.parent
);
750 * Since we might not just be coming from an interrupt from the
751 * subchannel we have to update the schib.
753 if (cio_update_schib(sch
)) {
754 ccw_device_verify_done(cdev
, -ENODEV
);
758 if (scsw_actl(&sch
->schib
.scsw
) != 0 ||
759 (scsw_stctl(&sch
->schib
.scsw
) & SCSW_STCTL_STATUS_PEND
) ||
760 (scsw_stctl(&cdev
->private->irb
.scsw
) & SCSW_STCTL_STATUS_PEND
)) {
762 * No final status yet or final status not yet delivered
763 * to the device driver. Can't do path verfication now,
764 * delay until final status was delivered.
766 cdev
->private->flags
.doverify
= 1;
769 /* Device is idle, we can do the path verification. */
770 cdev
->private->state
= DEV_STATE_VERIFY
;
771 cdev
->private->flags
.doverify
= 0;
772 ccw_device_verify_start(cdev
);
776 * Got an interrupt for a normal io (state online).
779 ccw_device_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
784 irb
= (struct irb
*) __LC_IRB
;
785 is_cmd
= !scsw_is_tm(&irb
->scsw
);
786 /* Check for unsolicited interrupt. */
787 if (!scsw_is_solicited(&irb
->scsw
)) {
788 if (is_cmd
&& (irb
->scsw
.cmd
.dstat
& DEV_STAT_UNIT_CHECK
) &&
789 !irb
->esw
.esw0
.erw
.cons
) {
790 /* Unit check but no sense data. Need basic sense. */
791 if (ccw_device_do_sense(cdev
, irb
) != 0)
792 goto call_handler_unsol
;
793 memcpy(&cdev
->private->irb
, irb
, sizeof(struct irb
));
794 cdev
->private->state
= DEV_STATE_W4SENSE
;
795 cdev
->private->intparm
= 0;
800 cdev
->handler (cdev
, 0, irb
);
801 if (cdev
->private->flags
.doverify
)
802 ccw_device_online_verify(cdev
, 0);
805 /* Accumulate status and find out if a basic sense is needed. */
806 ccw_device_accumulate_irb(cdev
, irb
);
807 if (is_cmd
&& cdev
->private->flags
.dosense
) {
808 if (ccw_device_do_sense(cdev
, irb
) == 0) {
809 cdev
->private->state
= DEV_STATE_W4SENSE
;
813 /* Call the handler. */
814 if (ccw_device_call_handler(cdev
) && cdev
->private->flags
.doverify
)
815 /* Start delayed path verification. */
816 ccw_device_online_verify(cdev
, 0);
820 * Got an timeout in online state.
823 ccw_device_online_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
827 ccw_device_set_timeout(cdev
, 0);
828 ret
= ccw_device_cancel_halt_clear(cdev
);
830 ccw_device_set_timeout(cdev
, 3*HZ
);
831 cdev
->private->state
= DEV_STATE_TIMEOUT_KILL
;
835 dev_fsm_event(cdev
, DEV_EVENT_NOTOPER
);
836 else if (cdev
->handler
)
837 cdev
->handler(cdev
, cdev
->private->intparm
,
838 ERR_PTR(-ETIMEDOUT
));
842 * Got an interrupt for a basic sense.
845 ccw_device_w4sense(struct ccw_device
*cdev
, enum dev_event dev_event
)
849 irb
= (struct irb
*) __LC_IRB
;
850 /* Check for unsolicited interrupt. */
851 if (scsw_stctl(&irb
->scsw
) ==
852 (SCSW_STCTL_STATUS_PEND
| SCSW_STCTL_ALERT_STATUS
)) {
853 if (scsw_cc(&irb
->scsw
) == 1)
854 /* Basic sense hasn't started. Try again. */
855 ccw_device_do_sense(cdev
, irb
);
857 CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
858 "interrupt during w4sense...\n",
859 cdev
->private->dev_id
.ssid
,
860 cdev
->private->dev_id
.devno
);
862 cdev
->handler (cdev
, 0, irb
);
867 * Check if a halt or clear has been issued in the meanwhile. If yes,
868 * only deliver the halt/clear interrupt to the device driver as if it
869 * had killed the original request.
871 if (scsw_fctl(&irb
->scsw
) &
872 (SCSW_FCTL_CLEAR_FUNC
| SCSW_FCTL_HALT_FUNC
)) {
873 /* Retry Basic Sense if requested. */
874 if (cdev
->private->flags
.intretry
) {
875 cdev
->private->flags
.intretry
= 0;
876 ccw_device_do_sense(cdev
, irb
);
879 cdev
->private->flags
.dosense
= 0;
880 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
881 ccw_device_accumulate_irb(cdev
, irb
);
884 /* Add basic sense info to irb. */
885 ccw_device_accumulate_basic_sense(cdev
, irb
);
886 if (cdev
->private->flags
.dosense
) {
887 /* Another basic sense is needed. */
888 ccw_device_do_sense(cdev
, irb
);
892 cdev
->private->state
= DEV_STATE_ONLINE
;
893 /* Call the handler. */
894 if (ccw_device_call_handler(cdev
) && cdev
->private->flags
.doverify
)
895 /* Start delayed path verification. */
896 ccw_device_online_verify(cdev
, 0);
900 ccw_device_clear_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
904 irb
= (struct irb
*) __LC_IRB
;
905 /* Accumulate status. We don't do basic sense. */
906 ccw_device_accumulate_irb(cdev
, irb
);
907 /* Remember to clear irb to avoid residuals. */
908 memset(&cdev
->private->irb
, 0, sizeof(struct irb
));
909 /* Try to start delayed device verification. */
910 ccw_device_online_verify(cdev
, 0);
911 /* Note: Don't call handler for cio initiated clear! */
915 ccw_device_killing_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
917 struct subchannel
*sch
;
919 sch
= to_subchannel(cdev
->dev
.parent
);
920 ccw_device_set_timeout(cdev
, 0);
921 /* Start delayed path verification. */
922 ccw_device_online_verify(cdev
, 0);
923 /* OK, i/o is dead now. Call interrupt handler. */
925 cdev
->handler(cdev
, cdev
->private->intparm
,
930 ccw_device_killing_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
934 ret
= ccw_device_cancel_halt_clear(cdev
);
936 ccw_device_set_timeout(cdev
, 3*HZ
);
939 /* Start delayed path verification. */
940 ccw_device_online_verify(cdev
, 0);
942 cdev
->handler(cdev
, cdev
->private->intparm
,
946 void ccw_device_kill_io(struct ccw_device
*cdev
)
950 ret
= ccw_device_cancel_halt_clear(cdev
);
952 ccw_device_set_timeout(cdev
, 3*HZ
);
953 cdev
->private->state
= DEV_STATE_TIMEOUT_KILL
;
956 /* Start delayed path verification. */
957 ccw_device_online_verify(cdev
, 0);
959 cdev
->handler(cdev
, cdev
->private->intparm
,
964 ccw_device_delay_verify(struct ccw_device
*cdev
, enum dev_event dev_event
)
966 /* Start verification after current task finished. */
967 cdev
->private->flags
.doverify
= 1;
971 ccw_device_stlck_done(struct ccw_device
*cdev
, enum dev_event dev_event
)
976 case DEV_EVENT_INTERRUPT
:
977 irb
= (struct irb
*) __LC_IRB
;
978 /* Check for unsolicited interrupt. */
979 if ((scsw_stctl(&irb
->scsw
) ==
980 (SCSW_STCTL_STATUS_PEND
| SCSW_STCTL_ALERT_STATUS
)) &&
981 (!scsw_cc(&irb
->scsw
)))
982 /* FIXME: we should restart stlck here, but this
983 * is extremely unlikely ... */
986 ccw_device_accumulate_irb(cdev
, irb
);
987 /* We don't care about basic sense etc. */
989 default: /* timeout */
993 wake_up(&cdev
->private->wait_q
);
997 ccw_device_start_id(struct ccw_device
*cdev
, enum dev_event dev_event
)
999 struct subchannel
*sch
;
1001 sch
= to_subchannel(cdev
->dev
.parent
);
1002 if (cio_enable_subchannel(sch
, (u32
)(addr_t
)sch
) != 0)
1003 /* Couldn't enable the subchannel for i/o. Sick device. */
1006 /* After 60s the device recognition is considered to have failed. */
1007 ccw_device_set_timeout(cdev
, 60*HZ
);
1009 cdev
->private->state
= DEV_STATE_DISCONNECTED_SENSE_ID
;
1010 ccw_device_sense_id_start(cdev
);
1013 void ccw_device_trigger_reprobe(struct ccw_device
*cdev
)
1015 struct subchannel
*sch
;
1017 if (cdev
->private->state
!= DEV_STATE_DISCONNECTED
)
1020 sch
= to_subchannel(cdev
->dev
.parent
);
1021 /* Update some values. */
1022 if (cio_update_schib(sch
))
1025 * The pim, pam, pom values may not be accurate, but they are the best
1026 * we have before performing device selection :/
1028 sch
->lpm
= sch
->schib
.pmcw
.pam
& sch
->opm
;
1030 * Use the initial configuration since we can't be shure that the old
1033 io_subchannel_init_config(sch
);
1034 if (cio_commit_config(sch
))
1037 /* We should also udate ssd info, but this has to wait. */
1038 /* Check if this is another device which appeared on the same sch. */
1039 if (sch
->schib
.pmcw
.dev
!= cdev
->private->dev_id
.devno
) {
1040 PREPARE_WORK(&cdev
->private->kick_work
,
1041 ccw_device_move_to_orphanage
);
1042 queue_work(slow_path_wq
, &cdev
->private->kick_work
);
1044 ccw_device_start_id(cdev
, 0);
1048 ccw_device_offline_irq(struct ccw_device
*cdev
, enum dev_event dev_event
)
1050 struct subchannel
*sch
;
1052 sch
= to_subchannel(cdev
->dev
.parent
);
1054 * An interrupt in state offline means a previous disable was not
1055 * successful. Try again.
1057 cio_disable_subchannel(sch
);
1061 ccw_device_change_cmfstate(struct ccw_device
*cdev
, enum dev_event dev_event
)
1063 retry_set_schib(cdev
);
1064 cdev
->private->state
= DEV_STATE_ONLINE
;
1065 dev_fsm_event(cdev
, dev_event
);
1068 static void ccw_device_update_cmfblock(struct ccw_device
*cdev
,
1069 enum dev_event dev_event
)
1071 cmf_retry_copy_block(cdev
);
1072 cdev
->private->state
= DEV_STATE_ONLINE
;
1073 dev_fsm_event(cdev
, dev_event
);
1077 ccw_device_quiesce_done(struct ccw_device
*cdev
, enum dev_event dev_event
)
1079 ccw_device_set_timeout(cdev
, 0);
1080 if (dev_event
== DEV_EVENT_NOTOPER
)
1081 cdev
->private->state
= DEV_STATE_NOT_OPER
;
1083 cdev
->private->state
= DEV_STATE_OFFLINE
;
1084 wake_up(&cdev
->private->wait_q
);
1088 ccw_device_quiesce_timeout(struct ccw_device
*cdev
, enum dev_event dev_event
)
1092 ret
= ccw_device_cancel_halt_clear(cdev
);
1095 cdev
->private->state
= DEV_STATE_OFFLINE
;
1096 wake_up(&cdev
->private->wait_q
);
1099 cdev
->private->state
= DEV_STATE_NOT_OPER
;
1100 wake_up(&cdev
->private->wait_q
);
1103 ccw_device_set_timeout(cdev
, HZ
/10);
1108 * No operation action. This is used e.g. to ignore a timeout event in
1112 ccw_device_nop(struct ccw_device
*cdev
, enum dev_event dev_event
)
1117 * Bug operation action.
1120 ccw_device_bug(struct ccw_device
*cdev
, enum dev_event dev_event
)
1122 CIO_MSG_EVENT(0, "Internal state [%i][%i] not handled for device "
1123 "0.%x.%04x\n", cdev
->private->state
, dev_event
,
1124 cdev
->private->dev_id
.ssid
,
1125 cdev
->private->dev_id
.devno
);
1130 * device statemachine
1132 fsm_func_t
*dev_jumptable
[NR_DEV_STATES
][NR_DEV_EVENTS
] = {
1133 [DEV_STATE_NOT_OPER
] = {
1134 [DEV_EVENT_NOTOPER
] = ccw_device_nop
,
1135 [DEV_EVENT_INTERRUPT
] = ccw_device_bug
,
1136 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1137 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1139 [DEV_STATE_SENSE_PGID
] = {
1140 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1141 [DEV_EVENT_INTERRUPT
] = ccw_device_sense_pgid_irq
,
1142 [DEV_EVENT_TIMEOUT
] = ccw_device_onoff_timeout
,
1143 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1145 [DEV_STATE_SENSE_ID
] = {
1146 [DEV_EVENT_NOTOPER
] = ccw_device_recog_notoper
,
1147 [DEV_EVENT_INTERRUPT
] = ccw_device_sense_id_irq
,
1148 [DEV_EVENT_TIMEOUT
] = ccw_device_recog_timeout
,
1149 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1151 [DEV_STATE_OFFLINE
] = {
1152 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1153 [DEV_EVENT_INTERRUPT
] = ccw_device_offline_irq
,
1154 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1155 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1157 [DEV_STATE_VERIFY
] = {
1158 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1159 [DEV_EVENT_INTERRUPT
] = ccw_device_verify_irq
,
1160 [DEV_EVENT_TIMEOUT
] = ccw_device_onoff_timeout
,
1161 [DEV_EVENT_VERIFY
] = ccw_device_delay_verify
,
1163 [DEV_STATE_ONLINE
] = {
1164 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1165 [DEV_EVENT_INTERRUPT
] = ccw_device_irq
,
1166 [DEV_EVENT_TIMEOUT
] = ccw_device_online_timeout
,
1167 [DEV_EVENT_VERIFY
] = ccw_device_online_verify
,
1169 [DEV_STATE_W4SENSE
] = {
1170 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1171 [DEV_EVENT_INTERRUPT
] = ccw_device_w4sense
,
1172 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1173 [DEV_EVENT_VERIFY
] = ccw_device_online_verify
,
1175 [DEV_STATE_DISBAND_PGID
] = {
1176 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1177 [DEV_EVENT_INTERRUPT
] = ccw_device_disband_irq
,
1178 [DEV_EVENT_TIMEOUT
] = ccw_device_onoff_timeout
,
1179 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1181 [DEV_STATE_BOXED
] = {
1182 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1183 [DEV_EVENT_INTERRUPT
] = ccw_device_stlck_done
,
1184 [DEV_EVENT_TIMEOUT
] = ccw_device_stlck_done
,
1185 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1187 /* states to wait for i/o completion before doing something */
1188 [DEV_STATE_CLEAR_VERIFY
] = {
1189 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1190 [DEV_EVENT_INTERRUPT
] = ccw_device_clear_verify
,
1191 [DEV_EVENT_TIMEOUT
] = ccw_device_nop
,
1192 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1194 [DEV_STATE_TIMEOUT_KILL
] = {
1195 [DEV_EVENT_NOTOPER
] = ccw_device_generic_notoper
,
1196 [DEV_EVENT_INTERRUPT
] = ccw_device_killing_irq
,
1197 [DEV_EVENT_TIMEOUT
] = ccw_device_killing_timeout
,
1198 [DEV_EVENT_VERIFY
] = ccw_device_nop
, //FIXME
1200 [DEV_STATE_QUIESCE
] = {
1201 [DEV_EVENT_NOTOPER
] = ccw_device_quiesce_done
,
1202 [DEV_EVENT_INTERRUPT
] = ccw_device_quiesce_done
,
1203 [DEV_EVENT_TIMEOUT
] = ccw_device_quiesce_timeout
,
1204 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1206 /* special states for devices gone not operational */
1207 [DEV_STATE_DISCONNECTED
] = {
1208 [DEV_EVENT_NOTOPER
] = ccw_device_nop
,
1209 [DEV_EVENT_INTERRUPT
] = ccw_device_start_id
,
1210 [DEV_EVENT_TIMEOUT
] = ccw_device_bug
,
1211 [DEV_EVENT_VERIFY
] = ccw_device_start_id
,
1213 [DEV_STATE_DISCONNECTED_SENSE_ID
] = {
1214 [DEV_EVENT_NOTOPER
] = ccw_device_recog_notoper
,
1215 [DEV_EVENT_INTERRUPT
] = ccw_device_sense_id_irq
,
1216 [DEV_EVENT_TIMEOUT
] = ccw_device_recog_timeout
,
1217 [DEV_EVENT_VERIFY
] = ccw_device_nop
,
1219 [DEV_STATE_CMFCHANGE
] = {
1220 [DEV_EVENT_NOTOPER
] = ccw_device_change_cmfstate
,
1221 [DEV_EVENT_INTERRUPT
] = ccw_device_change_cmfstate
,
1222 [DEV_EVENT_TIMEOUT
] = ccw_device_change_cmfstate
,
1223 [DEV_EVENT_VERIFY
] = ccw_device_change_cmfstate
,
1225 [DEV_STATE_CMFUPDATE
] = {
1226 [DEV_EVENT_NOTOPER
] = ccw_device_update_cmfblock
,
1227 [DEV_EVENT_INTERRUPT
] = ccw_device_update_cmfblock
,
1228 [DEV_EVENT_TIMEOUT
] = ccw_device_update_cmfblock
,
1229 [DEV_EVENT_VERIFY
] = ccw_device_update_cmfblock
,
1233 EXPORT_SYMBOL_GPL(ccw_device_set_timeout
);