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;
44 sch = to_subchannel(cdev->dev.parent);
45 private = to_io_private(sch);
46 cc = stsch(sch->schid, &schib);
48 printk(KERN_WARNING "cio: ccw device timeout occurred at %llx, "
49 "device information:\n", get_clock());
50 printk(KERN_WARNING "cio: orb:\n");
51 print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,
52 &private->orb, sizeof(private->orb), 0);
53 printk(KERN_WARNING "cio: ccw device bus id: %s\n", cdev->dev.bus_id);
54 printk(KERN_WARNING "cio: subchannel bus id: %s\n", sch->dev.bus_id);
55 printk(KERN_WARNING "cio: subchannel lpm: %02x, opm: %02x, "
56 "vpm: %02x\n", sch->lpm, sch->opm, sch->vpm);
58 if ((void *)(addr_t)private->orb.cpa == &private->sense_ccw ||
59 (void *)(addr_t)private->orb.cpa == cdev->private->iccws)
60 printk(KERN_WARNING "cio: last channel program (intern):\n");
62 printk(KERN_WARNING "cio: last channel program:\n");
64 print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,
65 (void *)(addr_t)private->orb.cpa,
66 sizeof(struct ccw1), 0);
67 printk(KERN_WARNING "cio: ccw device state: %d\n",
68 cdev->private->state);
69 printk(KERN_WARNING "cio: store subchannel returned: cc=%d\n", cc);
70 printk(KERN_WARNING "cio: schib:\n");
71 print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,
72 &schib, sizeof(schib), 0);
73 printk(KERN_WARNING "cio: ccw device flags:\n");
74 print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,
75 &cdev->private->flags, sizeof(cdev->private->flags), 0);
79 * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
82 ccw_device_timeout(unsigned long data)
84 struct ccw_device *cdev;
86 cdev = (struct ccw_device *) data;
87 spin_lock_irq(cdev->ccwlock);
88 if (timeout_log_enabled)
89 ccw_timeout_log(cdev);
90 dev_fsm_event(cdev, DEV_EVENT_TIMEOUT);
91 spin_unlock_irq(cdev->ccwlock);
98 ccw_device_set_timeout(struct ccw_device *cdev, int expires)
101 del_timer(&cdev->private->timer);
104 if (timer_pending(&cdev->private->timer)) {
105 if (mod_timer(&cdev->private->timer, jiffies + expires))
108 cdev->private->timer.function = ccw_device_timeout;
109 cdev->private->timer.data = (unsigned long) cdev;
110 cdev->private->timer.expires = jiffies + expires;
111 add_timer(&cdev->private->timer);
115 * Cancel running i/o. This is called repeatedly since halt/clear are
116 * asynchronous operations. We do one try with cio_cancel, two tries
117 * with cio_halt, 255 tries with cio_clear. If everythings fails panic.
118 * Returns 0 if device now idle, -ENODEV for device not operational and
119 * -EBUSY if an interrupt is expected (either from halt/clear or from a
123 ccw_device_cancel_halt_clear(struct ccw_device *cdev)
125 struct subchannel *sch;
128 sch = to_subchannel(cdev->dev.parent);
129 ret = stsch(sch->schid, &sch->schib);
130 if (ret || !sch->schib.pmcw.dnv)
132 if (!sch->schib.pmcw.ena)
133 /* Not operational -> done. */
135 /* Stage 1: cancel io. */
136 if (!(sch->schib.scsw.actl & SCSW_ACTL_HALT_PEND) &&
137 !(sch->schib.scsw.actl & SCSW_ACTL_CLEAR_PEND)) {
138 ret = cio_cancel(sch);
141 /* cancel io unsuccessful. From now on it is asynchronous. */
142 cdev->private->iretry = 3; /* 3 halt retries. */
144 if (!(sch->schib.scsw.actl & SCSW_ACTL_CLEAR_PEND)) {
145 /* Stage 2: halt io. */
146 if (cdev->private->iretry) {
147 cdev->private->iretry--;
150 return (ret == 0) ? -EBUSY : ret;
152 /* halt io unsuccessful. */
153 cdev->private->iretry = 255; /* 255 clear retries. */
155 /* Stage 3: clear io. */
156 if (cdev->private->iretry) {
157 cdev->private->iretry--;
158 ret = cio_clear (sch);
159 return (ret == 0) ? -EBUSY : ret;
161 panic("Can't stop i/o on subchannel.\n");
165 ccw_device_handle_oper(struct ccw_device *cdev)
167 struct subchannel *sch;
169 sch = to_subchannel(cdev->dev.parent);
170 cdev->private->flags.recog_done = 1;
172 * Check if cu type and device type still match. If
173 * not, it is certainly another device and we have to
174 * de- and re-register.
176 if (cdev->id.cu_type != cdev->private->senseid.cu_type ||
177 cdev->id.cu_model != cdev->private->senseid.cu_model ||
178 cdev->id.dev_type != cdev->private->senseid.dev_type ||
179 cdev->id.dev_model != cdev->private->senseid.dev_model) {
180 PREPARE_WORK(&cdev->private->kick_work,
181 ccw_device_do_unreg_rereg);
182 queue_work(ccw_device_work, &cdev->private->kick_work);
185 cdev->private->flags.donotify = 1;
190 * The machine won't give us any notification by machine check if a chpid has
191 * been varied online on the SE so we have to find out by magic (i. e. driving
192 * the channel subsystem to device selection and updating our path masks).
195 __recover_lost_chpids(struct subchannel *sch, int old_lpm)
201 for (i = 0; i<8; i++) {
203 if (!(sch->lpm & mask))
207 chpid.id = sch->schib.pmcw.chpid[i];
208 if (!chp_is_registered(chpid))
209 css_schedule_eval_all();
214 * Stop device recognition.
217 ccw_device_recog_done(struct ccw_device *cdev, int state)
219 struct subchannel *sch;
220 int notify, old_lpm, same_dev;
222 sch = to_subchannel(cdev->dev.parent);
224 ccw_device_set_timeout(cdev, 0);
225 cio_disable_subchannel(sch);
227 * Now that we tried recognition, we have performed device selection
228 * through ssch() and the path information is up to date.
231 stsch(sch->schid, &sch->schib);
232 sch->lpm = sch->schib.pmcw.pam & sch->opm;
233 /* Check since device may again have become not operational. */
234 if (!sch->schib.pmcw.dnv)
235 state = DEV_STATE_NOT_OPER;
236 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
237 /* Force reprobe on all chpids. */
239 if (sch->lpm != old_lpm)
240 __recover_lost_chpids(sch, old_lpm);
241 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
242 if (state == DEV_STATE_NOT_OPER) {
243 cdev->private->flags.recog_done = 1;
244 cdev->private->state = DEV_STATE_DISCONNECTED;
247 /* Boxed devices don't need extra treatment. */
250 same_dev = 0; /* Keep the compiler quiet... */
252 case DEV_STATE_NOT_OPER:
253 CIO_MSG_EVENT(2, "SenseID : unknown device %04x on "
254 "subchannel 0.%x.%04x\n",
255 cdev->private->dev_id.devno,
256 sch->schid.ssid, sch->schid.sch_no);
258 case DEV_STATE_OFFLINE:
259 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
260 same_dev = ccw_device_handle_oper(cdev);
263 /* fill out sense information */
264 memset(&cdev->id, 0, sizeof(cdev->id));
265 cdev->id.cu_type = cdev->private->senseid.cu_type;
266 cdev->id.cu_model = cdev->private->senseid.cu_model;
267 cdev->id.dev_type = cdev->private->senseid.dev_type;
268 cdev->id.dev_model = cdev->private->senseid.dev_model;
270 cdev->private->state = DEV_STATE_OFFLINE;
272 /* Get device online again. */
273 ccw_device_online(cdev);
274 wake_up(&cdev->private->wait_q);
278 /* Issue device info message. */
279 CIO_MSG_EVENT(4, "SenseID : device 0.%x.%04x reports: "
280 "CU Type/Mod = %04X/%02X, Dev Type/Mod = "
282 cdev->private->dev_id.ssid,
283 cdev->private->dev_id.devno,
284 cdev->id.cu_type, cdev->id.cu_model,
285 cdev->id.dev_type, cdev->id.dev_model);
287 case DEV_STATE_BOXED:
288 CIO_MSG_EVENT(0, "SenseID : boxed device %04x on "
289 " subchannel 0.%x.%04x\n",
290 cdev->private->dev_id.devno,
291 sch->schid.ssid, sch->schid.sch_no);
294 cdev->private->state = state;
295 io_subchannel_recog_done(cdev);
296 if (state != DEV_STATE_NOT_OPER)
297 wake_up(&cdev->private->wait_q);
301 * Function called from device_id.c after sense id has completed.
304 ccw_device_sense_id_done(struct ccw_device *cdev, int err)
308 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
310 case -ETIME: /* Sense id stopped by timeout. */
311 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
314 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
319 int ccw_device_notify(struct ccw_device *cdev, int event)
325 return cdev->drv->notify ? cdev->drv->notify(cdev, event) : 0;
329 ccw_device_oper_notify(struct work_struct *work)
331 struct ccw_device_private *priv;
332 struct ccw_device *cdev;
336 priv = container_of(work, struct ccw_device_private, kick_work);
338 ret = ccw_device_notify(cdev, CIO_OPER);
339 spin_lock_irqsave(cdev->ccwlock, flags);
341 /* Reenable channel measurements, if needed. */
342 spin_unlock_irqrestore(cdev->ccwlock, flags);
344 spin_lock_irqsave(cdev->ccwlock, flags);
345 wake_up(&cdev->private->wait_q);
347 spin_unlock_irqrestore(cdev->ccwlock, flags);
349 /* Driver doesn't want device back. */
350 ccw_device_do_unreg_rereg(work);
354 * Finished with online/offline processing.
357 ccw_device_done(struct ccw_device *cdev, int state)
359 struct subchannel *sch;
361 sch = to_subchannel(cdev->dev.parent);
363 ccw_device_set_timeout(cdev, 0);
365 if (state != DEV_STATE_ONLINE)
366 cio_disable_subchannel(sch);
368 /* Reset device status. */
369 memset(&cdev->private->irb, 0, sizeof(struct irb));
371 cdev->private->state = state;
374 if (state == DEV_STATE_BOXED)
375 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
376 cdev->private->dev_id.devno, sch->schid.sch_no);
378 if (cdev->private->flags.donotify) {
379 cdev->private->flags.donotify = 0;
380 PREPARE_WORK(&cdev->private->kick_work, ccw_device_oper_notify);
381 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
383 wake_up(&cdev->private->wait_q);
385 if (css_init_done && state != DEV_STATE_ONLINE)
386 put_device (&cdev->dev);
389 static int cmp_pgid(struct pgid *p1, struct pgid *p2)
397 return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
400 static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
406 for (i = 0; i < 8; i++) {
407 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
410 if (cdev->private->pgid[last].inf.ps.state1 ==
412 /* First non-zero PGID */
416 if (cmp_pgid(&cdev->private->pgid[i],
417 &cdev->private->pgid[last]) == 0)
418 /* Non-conflicting PGIDs */
421 /* PGID mismatch, can't pathgroup. */
422 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
423 "0.%x.%04x, can't pathgroup\n",
424 cdev->private->dev_id.ssid,
425 cdev->private->dev_id.devno);
426 cdev->private->options.pgroup = 0;
429 if (cdev->private->pgid[last].inf.ps.state1 ==
431 /* No previous pgid found */
432 memcpy(&cdev->private->pgid[0],
433 &channel_subsystems[0]->global_pgid,
434 sizeof(struct pgid));
436 /* Use existing pgid */
437 memcpy(&cdev->private->pgid[0], &cdev->private->pgid[last],
438 sizeof(struct pgid));
442 * Function called from device_pgid.c after sense path ground has completed.
445 ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
447 struct subchannel *sch;
449 sch = to_subchannel(cdev->dev.parent);
451 case -EOPNOTSUPP: /* path grouping not supported, use nop instead. */
452 cdev->private->options.pgroup = 0;
454 case 0: /* success */
455 case -EACCES: /* partial success, some paths not operational */
456 /* Check if all pgids are equal or 0. */
457 __ccw_device_get_common_pgid(cdev);
459 case -ETIME: /* Sense path group id stopped by timeout. */
460 case -EUSERS: /* device is reserved for someone else. */
461 ccw_device_done(cdev, DEV_STATE_BOXED);
464 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
467 /* Start Path Group verification. */
468 cdev->private->state = DEV_STATE_VERIFY;
469 cdev->private->flags.doverify = 0;
470 ccw_device_verify_start(cdev);
474 * Start device recognition.
477 ccw_device_recognition(struct ccw_device *cdev)
479 struct subchannel *sch;
482 if ((cdev->private->state != DEV_STATE_NOT_OPER) &&
483 (cdev->private->state != DEV_STATE_BOXED))
485 sch = to_subchannel(cdev->dev.parent);
486 ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
488 /* Couldn't enable the subchannel for i/o. Sick device. */
491 /* After 60s the device recognition is considered to have failed. */
492 ccw_device_set_timeout(cdev, 60*HZ);
495 * We used to start here with a sense pgid to find out whether a device
496 * is locked by someone else. Unfortunately, the sense pgid command
497 * code has other meanings on devices predating the path grouping
498 * algorithm, so we start with sense id and box the device after an
499 * timeout (or if sense pgid during path verification detects the device
500 * is locked, as may happen on newer devices).
502 cdev->private->flags.recog_done = 0;
503 cdev->private->state = DEV_STATE_SENSE_ID;
504 ccw_device_sense_id_start(cdev);
509 * Handle timeout in device recognition.
512 ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
516 ret = ccw_device_cancel_halt_clear(cdev);
519 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
522 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
525 ccw_device_set_timeout(cdev, 3*HZ);
531 ccw_device_verify_done(struct ccw_device *cdev, int err)
533 struct subchannel *sch;
535 sch = to_subchannel(cdev->dev.parent);
536 /* Update schib - pom may have changed. */
537 stsch(sch->schid, &sch->schib);
538 /* Update lpm with verified path mask. */
540 /* Repeat path verification? */
541 if (cdev->private->flags.doverify) {
542 cdev->private->flags.doverify = 0;
543 ccw_device_verify_start(cdev);
547 case -EOPNOTSUPP: /* path grouping not supported, just set online. */
548 cdev->private->options.pgroup = 0;
550 ccw_device_done(cdev, DEV_STATE_ONLINE);
551 /* Deliver fake irb to device driver, if needed. */
552 if (cdev->private->flags.fake_irb) {
553 memset(&cdev->private->irb, 0, sizeof(struct irb));
554 cdev->private->irb.scsw.cc = 1;
555 cdev->private->irb.scsw.fctl = SCSW_FCTL_START_FUNC;
556 cdev->private->irb.scsw.actl = SCSW_ACTL_START_PEND;
557 cdev->private->irb.scsw.stctl = SCSW_STCTL_STATUS_PEND;
558 cdev->private->flags.fake_irb = 0;
560 cdev->handler(cdev, cdev->private->intparm,
561 &cdev->private->irb);
562 memset(&cdev->private->irb, 0, sizeof(struct irb));
566 /* Reset oper notify indication after verify error. */
567 cdev->private->flags.donotify = 0;
568 ccw_device_done(cdev, DEV_STATE_BOXED);
571 /* Reset oper notify indication after verify error. */
572 cdev->private->flags.donotify = 0;
574 ccw_device_set_timeout(cdev, 0);
575 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
577 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
586 ccw_device_online(struct ccw_device *cdev)
588 struct subchannel *sch;
591 if ((cdev->private->state != DEV_STATE_OFFLINE) &&
592 (cdev->private->state != DEV_STATE_BOXED))
594 sch = to_subchannel(cdev->dev.parent);
595 if (css_init_done && !get_device(&cdev->dev))
597 ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
599 /* Couldn't enable the subchannel for i/o. Sick device. */
601 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
604 /* Do we want to do path grouping? */
605 if (!cdev->private->options.pgroup) {
606 /* Start initial path verification. */
607 cdev->private->state = DEV_STATE_VERIFY;
608 cdev->private->flags.doverify = 0;
609 ccw_device_verify_start(cdev);
612 /* Do a SensePGID first. */
613 cdev->private->state = DEV_STATE_SENSE_PGID;
614 ccw_device_sense_pgid_start(cdev);
619 ccw_device_disband_done(struct ccw_device *cdev, int err)
623 ccw_device_done(cdev, DEV_STATE_OFFLINE);
626 ccw_device_done(cdev, DEV_STATE_BOXED);
629 cdev->private->flags.donotify = 0;
630 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
631 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
640 ccw_device_offline(struct ccw_device *cdev)
642 struct subchannel *sch;
644 if (ccw_device_is_orphan(cdev)) {
645 ccw_device_done(cdev, DEV_STATE_OFFLINE);
648 sch = to_subchannel(cdev->dev.parent);
649 if (stsch(sch->schid, &sch->schib) || !sch->schib.pmcw.dnv)
651 if (cdev->private->state != DEV_STATE_ONLINE) {
652 if (sch->schib.scsw.actl != 0)
656 if (sch->schib.scsw.actl != 0)
658 /* Are we doing path grouping? */
659 if (!cdev->private->options.pgroup) {
660 /* No, set state offline immediately. */
661 ccw_device_done(cdev, DEV_STATE_OFFLINE);
664 /* Start Set Path Group commands. */
665 cdev->private->state = DEV_STATE_DISBAND_PGID;
666 ccw_device_disband_start(cdev);
671 * Handle timeout in device online/offline process.
674 ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
678 ret = ccw_device_cancel_halt_clear(cdev);
681 ccw_device_done(cdev, DEV_STATE_BOXED);
684 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
687 ccw_device_set_timeout(cdev, 3*HZ);
692 * Handle not oper event in device recognition.
695 ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
697 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
701 * Handle not operational event in non-special state.
703 static void ccw_device_generic_notoper(struct ccw_device *cdev,
704 enum dev_event dev_event)
706 struct subchannel *sch;
708 cdev->private->state = DEV_STATE_NOT_OPER;
709 sch = to_subchannel(cdev->dev.parent);
710 css_schedule_eval(sch->schid);
714 * Handle path verification event.
717 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
719 struct subchannel *sch;
721 if (cdev->private->state == DEV_STATE_W4SENSE) {
722 cdev->private->flags.doverify = 1;
725 sch = to_subchannel(cdev->dev.parent);
727 * Since we might not just be coming from an interrupt from the
728 * subchannel we have to update the schib.
730 stsch(sch->schid, &sch->schib);
732 if (sch->schib.scsw.actl != 0 ||
733 (sch->schib.scsw.stctl & SCSW_STCTL_STATUS_PEND) ||
734 (cdev->private->irb.scsw.stctl & SCSW_STCTL_STATUS_PEND)) {
736 * No final status yet or final status not yet delivered
737 * to the device driver. Can't do path verfication now,
738 * delay until final status was delivered.
740 cdev->private->flags.doverify = 1;
743 /* Device is idle, we can do the path verification. */
744 cdev->private->state = DEV_STATE_VERIFY;
745 cdev->private->flags.doverify = 0;
746 ccw_device_verify_start(cdev);
750 * Got an interrupt for a normal io (state online).
753 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
757 irb = (struct irb *) __LC_IRB;
758 /* Check for unsolicited interrupt. */
759 if ((irb->scsw.stctl ==
760 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS))
761 && (!irb->scsw.cc)) {
762 if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
763 !irb->esw.esw0.erw.cons) {
764 /* Unit check but no sense data. Need basic sense. */
765 if (ccw_device_do_sense(cdev, irb) != 0)
766 goto call_handler_unsol;
767 memcpy(&cdev->private->irb, irb, sizeof(struct irb));
768 cdev->private->state = DEV_STATE_W4SENSE;
769 cdev->private->intparm = 0;
774 cdev->handler (cdev, 0, irb);
775 if (cdev->private->flags.doverify)
776 ccw_device_online_verify(cdev, 0);
779 /* Accumulate status and find out if a basic sense is needed. */
780 ccw_device_accumulate_irb(cdev, irb);
781 if (cdev->private->flags.dosense) {
782 if (ccw_device_do_sense(cdev, irb) == 0) {
783 cdev->private->state = DEV_STATE_W4SENSE;
787 /* Call the handler. */
788 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
789 /* Start delayed path verification. */
790 ccw_device_online_verify(cdev, 0);
794 * Got an timeout in online state.
797 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
801 ccw_device_set_timeout(cdev, 0);
802 ret = ccw_device_cancel_halt_clear(cdev);
804 ccw_device_set_timeout(cdev, 3*HZ);
805 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
809 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
810 else if (cdev->handler)
811 cdev->handler(cdev, cdev->private->intparm,
812 ERR_PTR(-ETIMEDOUT));
816 * Got an interrupt for a basic sense.
819 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
823 irb = (struct irb *) __LC_IRB;
824 /* Check for unsolicited interrupt. */
825 if (irb->scsw.stctl ==
826 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
827 if (irb->scsw.cc == 1)
828 /* Basic sense hasn't started. Try again. */
829 ccw_device_do_sense(cdev, irb);
831 CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
832 "interrupt during w4sense...\n",
833 cdev->private->dev_id.ssid,
834 cdev->private->dev_id.devno);
836 cdev->handler (cdev, 0, irb);
841 * Check if a halt or clear has been issued in the meanwhile. If yes,
842 * only deliver the halt/clear interrupt to the device driver as if it
843 * had killed the original request.
845 if (irb->scsw.fctl & (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
846 /* Retry Basic Sense if requested. */
847 if (cdev->private->flags.intretry) {
848 cdev->private->flags.intretry = 0;
849 ccw_device_do_sense(cdev, irb);
852 cdev->private->flags.dosense = 0;
853 memset(&cdev->private->irb, 0, sizeof(struct irb));
854 ccw_device_accumulate_irb(cdev, irb);
857 /* Add basic sense info to irb. */
858 ccw_device_accumulate_basic_sense(cdev, irb);
859 if (cdev->private->flags.dosense) {
860 /* Another basic sense is needed. */
861 ccw_device_do_sense(cdev, irb);
865 cdev->private->state = DEV_STATE_ONLINE;
866 /* Call the handler. */
867 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
868 /* Start delayed path verification. */
869 ccw_device_online_verify(cdev, 0);
873 ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
877 irb = (struct irb *) __LC_IRB;
878 /* Accumulate status. We don't do basic sense. */
879 ccw_device_accumulate_irb(cdev, irb);
880 /* Remember to clear irb to avoid residuals. */
881 memset(&cdev->private->irb, 0, sizeof(struct irb));
882 /* Try to start delayed device verification. */
883 ccw_device_online_verify(cdev, 0);
884 /* Note: Don't call handler for cio initiated clear! */
888 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
890 struct subchannel *sch;
892 sch = to_subchannel(cdev->dev.parent);
893 ccw_device_set_timeout(cdev, 0);
894 /* Start delayed path verification. */
895 ccw_device_online_verify(cdev, 0);
896 /* OK, i/o is dead now. Call interrupt handler. */
898 cdev->handler(cdev, cdev->private->intparm,
903 ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
907 ret = ccw_device_cancel_halt_clear(cdev);
909 ccw_device_set_timeout(cdev, 3*HZ);
912 /* Start delayed path verification. */
913 ccw_device_online_verify(cdev, 0);
915 cdev->handler(cdev, cdev->private->intparm,
919 void ccw_device_kill_io(struct ccw_device *cdev)
923 ret = ccw_device_cancel_halt_clear(cdev);
925 ccw_device_set_timeout(cdev, 3*HZ);
926 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
929 /* Start delayed path verification. */
930 ccw_device_online_verify(cdev, 0);
932 cdev->handler(cdev, cdev->private->intparm,
937 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
939 /* Start verification after current task finished. */
940 cdev->private->flags.doverify = 1;
944 ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
949 case DEV_EVENT_INTERRUPT:
950 irb = (struct irb *) __LC_IRB;
951 /* Check for unsolicited interrupt. */
952 if ((irb->scsw.stctl ==
953 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
955 /* FIXME: we should restart stlck here, but this
956 * is extremely unlikely ... */
959 ccw_device_accumulate_irb(cdev, irb);
960 /* We don't care about basic sense etc. */
962 default: /* timeout */
966 wake_up(&cdev->private->wait_q);
970 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
972 struct subchannel *sch;
974 sch = to_subchannel(cdev->dev.parent);
975 if (cio_enable_subchannel(sch, (u32)(addr_t)sch) != 0)
976 /* Couldn't enable the subchannel for i/o. Sick device. */
979 /* After 60s the device recognition is considered to have failed. */
980 ccw_device_set_timeout(cdev, 60*HZ);
982 cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
983 ccw_device_sense_id_start(cdev);
986 void ccw_device_trigger_reprobe(struct ccw_device *cdev)
988 struct subchannel *sch;
990 if (cdev->private->state != DEV_STATE_DISCONNECTED)
993 sch = to_subchannel(cdev->dev.parent);
994 /* Update some values. */
995 if (stsch(sch->schid, &sch->schib))
997 if (!sch->schib.pmcw.dnv)
1000 * The pim, pam, pom values may not be accurate, but they are the best
1001 * we have before performing device selection :/
1003 sch->lpm = sch->schib.pmcw.pam & sch->opm;
1004 /* Re-set some bits in the pmcw that were lost. */
1005 sch->schib.pmcw.csense = 1;
1006 sch->schib.pmcw.ena = 0;
1007 if ((sch->lpm & (sch->lpm - 1)) != 0)
1008 sch->schib.pmcw.mp = 1;
1009 /* We should also udate ssd info, but this has to wait. */
1010 /* Check if this is another device which appeared on the same sch. */
1011 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1012 PREPARE_WORK(&cdev->private->kick_work,
1013 ccw_device_move_to_orphanage);
1014 queue_work(slow_path_wq, &cdev->private->kick_work);
1016 ccw_device_start_id(cdev, 0);
1020 ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
1022 struct subchannel *sch;
1024 sch = to_subchannel(cdev->dev.parent);
1026 * An interrupt in state offline means a previous disable was not
1027 * successful. Try again.
1029 cio_disable_subchannel(sch);
1033 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
1035 retry_set_schib(cdev);
1036 cdev->private->state = DEV_STATE_ONLINE;
1037 dev_fsm_event(cdev, dev_event);
1040 static void ccw_device_update_cmfblock(struct ccw_device *cdev,
1041 enum dev_event dev_event)
1043 cmf_retry_copy_block(cdev);
1044 cdev->private->state = DEV_STATE_ONLINE;
1045 dev_fsm_event(cdev, dev_event);
1049 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
1051 ccw_device_set_timeout(cdev, 0);
1052 if (dev_event == DEV_EVENT_NOTOPER)
1053 cdev->private->state = DEV_STATE_NOT_OPER;
1055 cdev->private->state = DEV_STATE_OFFLINE;
1056 wake_up(&cdev->private->wait_q);
1060 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1064 ret = ccw_device_cancel_halt_clear(cdev);
1067 cdev->private->state = DEV_STATE_OFFLINE;
1068 wake_up(&cdev->private->wait_q);
1071 cdev->private->state = DEV_STATE_NOT_OPER;
1072 wake_up(&cdev->private->wait_q);
1075 ccw_device_set_timeout(cdev, HZ/10);
1080 * No operation action. This is used e.g. to ignore a timeout event in
1084 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1089 * Bug operation action.
1092 ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
1094 CIO_MSG_EVENT(0, "Internal state [%i][%i] not handled for device "
1095 "0.%x.%04x\n", cdev->private->state, dev_event,
1096 cdev->private->dev_id.ssid,
1097 cdev->private->dev_id.devno);
1102 * device statemachine
1104 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
1105 [DEV_STATE_NOT_OPER] = {
1106 [DEV_EVENT_NOTOPER] = ccw_device_nop,
1107 [DEV_EVENT_INTERRUPT] = ccw_device_bug,
1108 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1109 [DEV_EVENT_VERIFY] = ccw_device_nop,
1111 [DEV_STATE_SENSE_PGID] = {
1112 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1113 [DEV_EVENT_INTERRUPT] = ccw_device_sense_pgid_irq,
1114 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1115 [DEV_EVENT_VERIFY] = ccw_device_nop,
1117 [DEV_STATE_SENSE_ID] = {
1118 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
1119 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq,
1120 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout,
1121 [DEV_EVENT_VERIFY] = ccw_device_nop,
1123 [DEV_STATE_OFFLINE] = {
1124 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1125 [DEV_EVENT_INTERRUPT] = ccw_device_offline_irq,
1126 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1127 [DEV_EVENT_VERIFY] = ccw_device_nop,
1129 [DEV_STATE_VERIFY] = {
1130 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1131 [DEV_EVENT_INTERRUPT] = ccw_device_verify_irq,
1132 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1133 [DEV_EVENT_VERIFY] = ccw_device_delay_verify,
1135 [DEV_STATE_ONLINE] = {
1136 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1137 [DEV_EVENT_INTERRUPT] = ccw_device_irq,
1138 [DEV_EVENT_TIMEOUT] = ccw_device_online_timeout,
1139 [DEV_EVENT_VERIFY] = ccw_device_online_verify,
1141 [DEV_STATE_W4SENSE] = {
1142 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1143 [DEV_EVENT_INTERRUPT] = ccw_device_w4sense,
1144 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1145 [DEV_EVENT_VERIFY] = ccw_device_online_verify,
1147 [DEV_STATE_DISBAND_PGID] = {
1148 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1149 [DEV_EVENT_INTERRUPT] = ccw_device_disband_irq,
1150 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1151 [DEV_EVENT_VERIFY] = ccw_device_nop,
1153 [DEV_STATE_BOXED] = {
1154 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1155 [DEV_EVENT_INTERRUPT] = ccw_device_stlck_done,
1156 [DEV_EVENT_TIMEOUT] = ccw_device_stlck_done,
1157 [DEV_EVENT_VERIFY] = ccw_device_nop,
1159 /* states to wait for i/o completion before doing something */
1160 [DEV_STATE_CLEAR_VERIFY] = {
1161 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1162 [DEV_EVENT_INTERRUPT] = ccw_device_clear_verify,
1163 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1164 [DEV_EVENT_VERIFY] = ccw_device_nop,
1166 [DEV_STATE_TIMEOUT_KILL] = {
1167 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1168 [DEV_EVENT_INTERRUPT] = ccw_device_killing_irq,
1169 [DEV_EVENT_TIMEOUT] = ccw_device_killing_timeout,
1170 [DEV_EVENT_VERIFY] = ccw_device_nop, //FIXME
1172 [DEV_STATE_QUIESCE] = {
1173 [DEV_EVENT_NOTOPER] = ccw_device_quiesce_done,
1174 [DEV_EVENT_INTERRUPT] = ccw_device_quiesce_done,
1175 [DEV_EVENT_TIMEOUT] = ccw_device_quiesce_timeout,
1176 [DEV_EVENT_VERIFY] = ccw_device_nop,
1178 /* special states for devices gone not operational */
1179 [DEV_STATE_DISCONNECTED] = {
1180 [DEV_EVENT_NOTOPER] = ccw_device_nop,
1181 [DEV_EVENT_INTERRUPT] = ccw_device_start_id,
1182 [DEV_EVENT_TIMEOUT] = ccw_device_bug,
1183 [DEV_EVENT_VERIFY] = ccw_device_start_id,
1185 [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1186 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
1187 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq,
1188 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout,
1189 [DEV_EVENT_VERIFY] = ccw_device_nop,
1191 [DEV_STATE_CMFCHANGE] = {
1192 [DEV_EVENT_NOTOPER] = ccw_device_change_cmfstate,
1193 [DEV_EVENT_INTERRUPT] = ccw_device_change_cmfstate,
1194 [DEV_EVENT_TIMEOUT] = ccw_device_change_cmfstate,
1195 [DEV_EVENT_VERIFY] = ccw_device_change_cmfstate,
1197 [DEV_STATE_CMFUPDATE] = {
1198 [DEV_EVENT_NOTOPER] = ccw_device_update_cmfblock,
1199 [DEV_EVENT_INTERRUPT] = ccw_device_update_cmfblock,
1200 [DEV_EVENT_TIMEOUT] = ccw_device_update_cmfblock,
1201 [DEV_EVENT_VERIFY] = ccw_device_update_cmfblock,
1205 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);