Merge branch 'HEAD' of master.kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux-2.6] / drivers / s390 / cio / device_fsm.c
1 /*
2  * drivers/s390/cio/device_fsm.c
3  * finite state machine for device handling
4  *
5  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
6  *                       IBM Corporation
7  *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
8  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
9  */
10
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/jiffies.h>
14 #include <linux/string.h>
15
16 #include <asm/ccwdev.h>
17 #include <asm/cio.h>
18
19 #include "cio.h"
20 #include "cio_debug.h"
21 #include "css.h"
22 #include "device.h"
23 #include "chsc.h"
24 #include "ioasm.h"
25
26 int
27 device_is_online(struct subchannel *sch)
28 {
29         struct ccw_device *cdev;
30
31         if (!sch->dev.driver_data)
32                 return 0;
33         cdev = sch->dev.driver_data;
34         return (cdev->private->state == DEV_STATE_ONLINE);
35 }
36
37 int
38 device_is_disconnected(struct subchannel *sch)
39 {
40         struct ccw_device *cdev;
41
42         if (!sch->dev.driver_data)
43                 return 0;
44         cdev = sch->dev.driver_data;
45         return (cdev->private->state == DEV_STATE_DISCONNECTED ||
46                 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
47 }
48
49 void
50 device_set_disconnected(struct subchannel *sch)
51 {
52         struct ccw_device *cdev;
53
54         if (!sch->dev.driver_data)
55                 return;
56         cdev = sch->dev.driver_data;
57         ccw_device_set_timeout(cdev, 0);
58         cdev->private->flags.fake_irb = 0;
59         cdev->private->state = DEV_STATE_DISCONNECTED;
60 }
61
62 void device_set_intretry(struct subchannel *sch)
63 {
64         struct ccw_device *cdev;
65
66         cdev = sch->dev.driver_data;
67         if (!cdev)
68                 return;
69         cdev->private->flags.intretry = 1;
70 }
71
72 int device_trigger_verify(struct subchannel *sch)
73 {
74         struct ccw_device *cdev;
75
76         cdev = sch->dev.driver_data;
77         if (!cdev || !cdev->online)
78                 return -EINVAL;
79         dev_fsm_event(cdev, DEV_EVENT_VERIFY);
80         return 0;
81 }
82
83 /*
84  * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
85  */
86 static void
87 ccw_device_timeout(unsigned long data)
88 {
89         struct ccw_device *cdev;
90
91         cdev = (struct ccw_device *) data;
92         spin_lock_irq(cdev->ccwlock);
93         dev_fsm_event(cdev, DEV_EVENT_TIMEOUT);
94         spin_unlock_irq(cdev->ccwlock);
95 }
96
97 /*
98  * Set timeout
99  */
100 void
101 ccw_device_set_timeout(struct ccw_device *cdev, int expires)
102 {
103         if (expires == 0) {
104                 del_timer(&cdev->private->timer);
105                 return;
106         }
107         if (timer_pending(&cdev->private->timer)) {
108                 if (mod_timer(&cdev->private->timer, jiffies + expires))
109                         return;
110         }
111         cdev->private->timer.function = ccw_device_timeout;
112         cdev->private->timer.data = (unsigned long) cdev;
113         cdev->private->timer.expires = jiffies + expires;
114         add_timer(&cdev->private->timer);
115 }
116
117 /* Kill any pending timers after machine check. */
118 void
119 device_kill_pending_timer(struct subchannel *sch)
120 {
121         struct ccw_device *cdev;
122
123         if (!sch->dev.driver_data)
124                 return;
125         cdev = sch->dev.driver_data;
126         ccw_device_set_timeout(cdev, 0);
127 }
128
129 /*
130  * Cancel running i/o. This is called repeatedly since halt/clear are
131  * asynchronous operations. We do one try with cio_cancel, two tries
132  * with cio_halt, 255 tries with cio_clear. If everythings fails panic.
133  * Returns 0 if device now idle, -ENODEV for device not operational and
134  * -EBUSY if an interrupt is expected (either from halt/clear or from a
135  * status pending).
136  */
137 int
138 ccw_device_cancel_halt_clear(struct ccw_device *cdev)
139 {
140         struct subchannel *sch;
141         int ret;
142
143         sch = to_subchannel(cdev->dev.parent);
144         ret = stsch(sch->schid, &sch->schib);
145         if (ret || !sch->schib.pmcw.dnv)
146                 return -ENODEV; 
147         if (!sch->schib.pmcw.ena || sch->schib.scsw.actl == 0)
148                 /* Not operational or no activity -> done. */
149                 return 0;
150         /* Stage 1: cancel io. */
151         if (!(sch->schib.scsw.actl & SCSW_ACTL_HALT_PEND) &&
152             !(sch->schib.scsw.actl & SCSW_ACTL_CLEAR_PEND)) {
153                 ret = cio_cancel(sch);
154                 if (ret != -EINVAL)
155                         return ret;
156                 /* cancel io unsuccessful. From now on it is asynchronous. */
157                 cdev->private->iretry = 3;      /* 3 halt retries. */
158         }
159         if (!(sch->schib.scsw.actl & SCSW_ACTL_CLEAR_PEND)) {
160                 /* Stage 2: halt io. */
161                 if (cdev->private->iretry) {
162                         cdev->private->iretry--;
163                         ret = cio_halt(sch);
164                         if (ret != -EBUSY)
165                                 return (ret == 0) ? -EBUSY : ret;
166                 }
167                 /* halt io unsuccessful. */
168                 cdev->private->iretry = 255;    /* 255 clear retries. */
169         }
170         /* Stage 3: clear io. */
171         if (cdev->private->iretry) {
172                 cdev->private->iretry--;
173                 ret = cio_clear (sch);
174                 return (ret == 0) ? -EBUSY : ret;
175         }
176         panic("Can't stop i/o on subchannel.\n");
177 }
178
179 static int
180 ccw_device_handle_oper(struct ccw_device *cdev)
181 {
182         struct subchannel *sch;
183
184         sch = to_subchannel(cdev->dev.parent);
185         cdev->private->flags.recog_done = 1;
186         /*
187          * Check if cu type and device type still match. If
188          * not, it is certainly another device and we have to
189          * de- and re-register.
190          */
191         if (cdev->id.cu_type != cdev->private->senseid.cu_type ||
192             cdev->id.cu_model != cdev->private->senseid.cu_model ||
193             cdev->id.dev_type != cdev->private->senseid.dev_type ||
194             cdev->id.dev_model != cdev->private->senseid.dev_model) {
195                 PREPARE_WORK(&cdev->private->kick_work,
196                              ccw_device_do_unreg_rereg);
197                 queue_work(ccw_device_work, &cdev->private->kick_work);
198                 return 0;
199         }
200         cdev->private->flags.donotify = 1;
201         return 1;
202 }
203
204 /*
205  * The machine won't give us any notification by machine check if a chpid has
206  * been varied online on the SE so we have to find out by magic (i. e. driving
207  * the channel subsystem to device selection and updating our path masks).
208  */
209 static void
210 __recover_lost_chpids(struct subchannel *sch, int old_lpm)
211 {
212         int mask, i;
213
214         for (i = 0; i<8; i++) {
215                 mask = 0x80 >> i;
216                 if (!(sch->lpm & mask))
217                         continue;
218                 if (old_lpm & mask)
219                         continue;
220                 chpid_is_actually_online(sch->schib.pmcw.chpid[i]);
221         }
222 }
223
224 /*
225  * Stop device recognition.
226  */
227 static void
228 ccw_device_recog_done(struct ccw_device *cdev, int state)
229 {
230         struct subchannel *sch;
231         int notify, old_lpm, same_dev;
232
233         sch = to_subchannel(cdev->dev.parent);
234
235         ccw_device_set_timeout(cdev, 0);
236         cio_disable_subchannel(sch);
237         /*
238          * Now that we tried recognition, we have performed device selection
239          * through ssch() and the path information is up to date.
240          */
241         old_lpm = sch->lpm;
242         stsch(sch->schid, &sch->schib);
243         sch->lpm = sch->schib.pmcw.pam & sch->opm;
244         /* Check since device may again have become not operational. */
245         if (!sch->schib.pmcw.dnv)
246                 state = DEV_STATE_NOT_OPER;
247         if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
248                 /* Force reprobe on all chpids. */
249                 old_lpm = 0;
250         if (sch->lpm != old_lpm)
251                 __recover_lost_chpids(sch, old_lpm);
252         if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
253                 if (state == DEV_STATE_NOT_OPER) {
254                         cdev->private->flags.recog_done = 1;
255                         cdev->private->state = DEV_STATE_DISCONNECTED;
256                         return;
257                 }
258                 /* Boxed devices don't need extra treatment. */
259         }
260         notify = 0;
261         same_dev = 0; /* Keep the compiler quiet... */
262         switch (state) {
263         case DEV_STATE_NOT_OPER:
264                 CIO_DEBUG(KERN_WARNING, 2,
265                           "SenseID : unknown device %04x on subchannel "
266                           "0.%x.%04x\n", cdev->private->dev_id.devno,
267                           sch->schid.ssid, sch->schid.sch_no);
268                 break;
269         case DEV_STATE_OFFLINE:
270                 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
271                         same_dev = ccw_device_handle_oper(cdev);
272                         notify = 1;
273                 }
274                 /* fill out sense information */
275                 memset(&cdev->id, 0, sizeof(cdev->id));
276                 cdev->id.cu_type   = cdev->private->senseid.cu_type;
277                 cdev->id.cu_model  = cdev->private->senseid.cu_model;
278                 cdev->id.dev_type  = cdev->private->senseid.dev_type;
279                 cdev->id.dev_model = cdev->private->senseid.dev_model;
280                 if (notify) {
281                         cdev->private->state = DEV_STATE_OFFLINE;
282                         if (same_dev) {
283                                 /* Get device online again. */
284                                 ccw_device_online(cdev);
285                                 wake_up(&cdev->private->wait_q);
286                         }
287                         return;
288                 }
289                 /* Issue device info message. */
290                 CIO_DEBUG(KERN_INFO, 2, "SenseID : device 0.%x.%04x reports: "
291                           "CU  Type/Mod = %04X/%02X, Dev Type/Mod = "
292                           "%04X/%02X\n",
293                           cdev->private->dev_id.ssid,
294                           cdev->private->dev_id.devno,
295                           cdev->id.cu_type, cdev->id.cu_model,
296                           cdev->id.dev_type, cdev->id.dev_model);
297                 break;
298         case DEV_STATE_BOXED:
299                 CIO_DEBUG(KERN_WARNING, 2,
300                           "SenseID : boxed device %04x on subchannel "
301                           "0.%x.%04x\n", cdev->private->dev_id.devno,
302                           sch->schid.ssid, sch->schid.sch_no);
303                 break;
304         }
305         cdev->private->state = state;
306         io_subchannel_recog_done(cdev);
307         if (state != DEV_STATE_NOT_OPER)
308                 wake_up(&cdev->private->wait_q);
309 }
310
311 /*
312  * Function called from device_id.c after sense id has completed.
313  */
314 void
315 ccw_device_sense_id_done(struct ccw_device *cdev, int err)
316 {
317         switch (err) {
318         case 0:
319                 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
320                 break;
321         case -ETIME:            /* Sense id stopped by timeout. */
322                 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
323                 break;
324         default:
325                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
326                 break;
327         }
328 }
329
330 static void
331 ccw_device_oper_notify(struct work_struct *work)
332 {
333         struct ccw_device_private *priv;
334         struct ccw_device *cdev;
335         struct subchannel *sch;
336         int ret;
337
338         priv = container_of(work, struct ccw_device_private, kick_work);
339         cdev = priv->cdev;
340         sch = to_subchannel(cdev->dev.parent);
341         ret = (sch->driver && sch->driver->notify) ?
342                 sch->driver->notify(&sch->dev, CIO_OPER) : 0;
343         if (!ret)
344                 /* Driver doesn't want device back. */
345                 ccw_device_do_unreg_rereg(work);
346         else {
347                 /* Reenable channel measurements, if needed. */
348                 cmf_reenable(cdev);
349                 wake_up(&cdev->private->wait_q);
350         }
351 }
352
353 /*
354  * Finished with online/offline processing.
355  */
356 static void
357 ccw_device_done(struct ccw_device *cdev, int state)
358 {
359         struct subchannel *sch;
360
361         sch = to_subchannel(cdev->dev.parent);
362
363         ccw_device_set_timeout(cdev, 0);
364
365         if (state != DEV_STATE_ONLINE)
366                 cio_disable_subchannel(sch);
367
368         /* Reset device status. */
369         memset(&cdev->private->irb, 0, sizeof(struct irb));
370
371         cdev->private->state = state;
372
373
374         if (state == DEV_STATE_BOXED)
375                 CIO_DEBUG(KERN_WARNING, 2,
376                           "Boxed device %04x on subchannel %04x\n",
377                           cdev->private->dev_id.devno, sch->schid.sch_no);
378
379         if (cdev->private->flags.donotify) {
380                 cdev->private->flags.donotify = 0;
381                 PREPARE_WORK(&cdev->private->kick_work, ccw_device_oper_notify);
382                 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
383         }
384         wake_up(&cdev->private->wait_q);
385
386         if (css_init_done && state != DEV_STATE_ONLINE)
387                 put_device (&cdev->dev);
388 }
389
390 static int cmp_pgid(struct pgid *p1, struct pgid *p2)
391 {
392         char *c1;
393         char *c2;
394
395         c1 = (char *)p1;
396         c2 = (char *)p2;
397
398         return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
399 }
400
401 static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
402 {
403         int i;
404         int last;
405
406         last = 0;
407         for (i = 0; i < 8; i++) {
408                 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
409                         /* No PGID yet */
410                         continue;
411                 if (cdev->private->pgid[last].inf.ps.state1 ==
412                     SNID_STATE1_RESET) {
413                         /* First non-zero PGID */
414                         last = i;
415                         continue;
416                 }
417                 if (cmp_pgid(&cdev->private->pgid[i],
418                              &cdev->private->pgid[last]) == 0)
419                         /* Non-conflicting PGIDs */
420                         continue;
421
422                 /* PGID mismatch, can't pathgroup. */
423                 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
424                               "0.%x.%04x, can't pathgroup\n",
425                               cdev->private->dev_id.ssid,
426                               cdev->private->dev_id.devno);
427                 cdev->private->options.pgroup = 0;
428                 return;
429         }
430         if (cdev->private->pgid[last].inf.ps.state1 ==
431             SNID_STATE1_RESET)
432                 /* No previous pgid found */
433                 memcpy(&cdev->private->pgid[0], &css[0]->global_pgid,
434                        sizeof(struct pgid));
435         else
436                 /* Use existing pgid */
437                 memcpy(&cdev->private->pgid[0], &cdev->private->pgid[last],
438                        sizeof(struct pgid));
439 }
440
441 /*
442  * Function called from device_pgid.c after sense path ground has completed.
443  */
444 void
445 ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
446 {
447         struct subchannel *sch;
448
449         sch = to_subchannel(cdev->dev.parent);
450         switch (err) {
451         case -EOPNOTSUPP: /* path grouping not supported, use nop instead. */
452                 cdev->private->options.pgroup = 0;
453                 break;
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);
458                 break;
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);
462                 return;
463         default:
464                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
465                 return;
466         }
467         /* Start Path Group verification. */
468         cdev->private->state = DEV_STATE_VERIFY;
469         cdev->private->flags.doverify = 0;
470         ccw_device_verify_start(cdev);
471 }
472
473 /*
474  * Start device recognition.
475  */
476 int
477 ccw_device_recognition(struct ccw_device *cdev)
478 {
479         struct subchannel *sch;
480         int ret;
481
482         if ((cdev->private->state != DEV_STATE_NOT_OPER) &&
483             (cdev->private->state != DEV_STATE_BOXED))
484                 return -EINVAL;
485         sch = to_subchannel(cdev->dev.parent);
486         ret = cio_enable_subchannel(sch, sch->schib.pmcw.isc);
487         if (ret != 0)
488                 /* Couldn't enable the subchannel for i/o. Sick device. */
489                 return ret;
490
491         /* After 60s the device recognition is considered to have failed. */
492         ccw_device_set_timeout(cdev, 60*HZ);
493
494         /*
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).
501          */
502         cdev->private->flags.recog_done = 0;
503         cdev->private->state = DEV_STATE_SENSE_ID;
504         ccw_device_sense_id_start(cdev);
505         return 0;
506 }
507
508 /*
509  * Handle timeout in device recognition.
510  */
511 static void
512 ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
513 {
514         int ret;
515
516         ret = ccw_device_cancel_halt_clear(cdev);
517         switch (ret) {
518         case 0:
519                 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
520                 break;
521         case -ENODEV:
522                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
523                 break;
524         default:
525                 ccw_device_set_timeout(cdev, 3*HZ);
526         }
527 }
528
529
530 static void
531 ccw_device_nopath_notify(struct work_struct *work)
532 {
533         struct ccw_device_private *priv;
534         struct ccw_device *cdev;
535         struct subchannel *sch;
536         int ret;
537
538         priv = container_of(work, struct ccw_device_private, kick_work);
539         cdev = priv->cdev;
540         sch = to_subchannel(cdev->dev.parent);
541         /* Extra sanity. */
542         if (sch->lpm)
543                 return;
544         ret = (sch->driver && sch->driver->notify) ?
545                 sch->driver->notify(&sch->dev, CIO_NO_PATH) : 0;
546         if (!ret) {
547                 if (get_device(&sch->dev)) {
548                         /* Driver doesn't want to keep device. */
549                         cio_disable_subchannel(sch);
550                         if (get_device(&cdev->dev)) {
551                                 PREPARE_WORK(&cdev->private->kick_work,
552                                              ccw_device_call_sch_unregister);
553                                 queue_work(ccw_device_work,
554                                            &cdev->private->kick_work);
555                         } else
556                                 put_device(&sch->dev);
557                 }
558         } else {
559                 cio_disable_subchannel(sch);
560                 ccw_device_set_timeout(cdev, 0);
561                 cdev->private->flags.fake_irb = 0;
562                 cdev->private->state = DEV_STATE_DISCONNECTED;
563                 wake_up(&cdev->private->wait_q);
564         }
565 }
566
567 void
568 ccw_device_verify_done(struct ccw_device *cdev, int err)
569 {
570         struct subchannel *sch;
571
572         sch = to_subchannel(cdev->dev.parent);
573         /* Update schib - pom may have changed. */
574         stsch(sch->schid, &sch->schib);
575         /* Update lpm with verified path mask. */
576         sch->lpm = sch->vpm;
577         /* Repeat path verification? */
578         if (cdev->private->flags.doverify) {
579                 cdev->private->flags.doverify = 0;
580                 ccw_device_verify_start(cdev);
581                 return;
582         }
583         switch (err) {
584         case -EOPNOTSUPP: /* path grouping not supported, just set online. */
585                 cdev->private->options.pgroup = 0;
586         case 0:
587                 ccw_device_done(cdev, DEV_STATE_ONLINE);
588                 /* Deliver fake irb to device driver, if needed. */
589                 if (cdev->private->flags.fake_irb) {
590                         memset(&cdev->private->irb, 0, sizeof(struct irb));
591                         cdev->private->irb.scsw.cc = 1;
592                         cdev->private->irb.scsw.fctl = SCSW_FCTL_START_FUNC;
593                         cdev->private->irb.scsw.actl = SCSW_ACTL_START_PEND;
594                         cdev->private->irb.scsw.stctl = SCSW_STCTL_STATUS_PEND;
595                         cdev->private->flags.fake_irb = 0;
596                         if (cdev->handler)
597                                 cdev->handler(cdev, cdev->private->intparm,
598                                               &cdev->private->irb);
599                         memset(&cdev->private->irb, 0, sizeof(struct irb));
600                 }
601                 break;
602         case -ETIME:
603                 /* Reset oper notify indication after verify error. */
604                 cdev->private->flags.donotify = 0;
605                 ccw_device_done(cdev, DEV_STATE_BOXED);
606                 break;
607         default:
608                 /* Reset oper notify indication after verify error. */
609                 cdev->private->flags.donotify = 0;
610                 PREPARE_WORK(&cdev->private->kick_work,
611                              ccw_device_nopath_notify);
612                 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
613                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
614                 break;
615         }
616 }
617
618 /*
619  * Get device online.
620  */
621 int
622 ccw_device_online(struct ccw_device *cdev)
623 {
624         struct subchannel *sch;
625         int ret;
626
627         if ((cdev->private->state != DEV_STATE_OFFLINE) &&
628             (cdev->private->state != DEV_STATE_BOXED))
629                 return -EINVAL;
630         sch = to_subchannel(cdev->dev.parent);
631         if (css_init_done && !get_device(&cdev->dev))
632                 return -ENODEV;
633         ret = cio_enable_subchannel(sch, sch->schib.pmcw.isc);
634         if (ret != 0) {
635                 /* Couldn't enable the subchannel for i/o. Sick device. */
636                 if (ret == -ENODEV)
637                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
638                 return ret;
639         }
640         /* Do we want to do path grouping? */
641         if (!cdev->private->options.pgroup) {
642                 /* Start initial path verification. */
643                 cdev->private->state = DEV_STATE_VERIFY;
644                 cdev->private->flags.doverify = 0;
645                 ccw_device_verify_start(cdev);
646                 return 0;
647         }
648         /* Do a SensePGID first. */
649         cdev->private->state = DEV_STATE_SENSE_PGID;
650         ccw_device_sense_pgid_start(cdev);
651         return 0;
652 }
653
654 void
655 ccw_device_disband_done(struct ccw_device *cdev, int err)
656 {
657         switch (err) {
658         case 0:
659                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
660                 break;
661         case -ETIME:
662                 ccw_device_done(cdev, DEV_STATE_BOXED);
663                 break;
664         default:
665                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
666                 break;
667         }
668 }
669
670 /*
671  * Shutdown device.
672  */
673 int
674 ccw_device_offline(struct ccw_device *cdev)
675 {
676         struct subchannel *sch;
677
678         if (ccw_device_is_orphan(cdev)) {
679                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
680                 return 0;
681         }
682         sch = to_subchannel(cdev->dev.parent);
683         if (stsch(sch->schid, &sch->schib) || !sch->schib.pmcw.dnv)
684                 return -ENODEV;
685         if (cdev->private->state != DEV_STATE_ONLINE) {
686                 if (sch->schib.scsw.actl != 0)
687                         return -EBUSY;
688                 return -EINVAL;
689         }
690         if (sch->schib.scsw.actl != 0)
691                 return -EBUSY;
692         /* Are we doing path grouping? */
693         if (!cdev->private->options.pgroup) {
694                 /* No, set state offline immediately. */
695                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
696                 return 0;
697         }
698         /* Start Set Path Group commands. */
699         cdev->private->state = DEV_STATE_DISBAND_PGID;
700         ccw_device_disband_start(cdev);
701         return 0;
702 }
703
704 /*
705  * Handle timeout in device online/offline process.
706  */
707 static void
708 ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
709 {
710         int ret;
711
712         ret = ccw_device_cancel_halt_clear(cdev);
713         switch (ret) {
714         case 0:
715                 ccw_device_done(cdev, DEV_STATE_BOXED);
716                 break;
717         case -ENODEV:
718                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
719                 break;
720         default:
721                 ccw_device_set_timeout(cdev, 3*HZ);
722         }
723 }
724
725 /*
726  * Handle not oper event in device recognition.
727  */
728 static void
729 ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
730 {
731         ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
732 }
733
734 /*
735  * Handle not operational event while offline.
736  */
737 static void
738 ccw_device_offline_notoper(struct ccw_device *cdev, enum dev_event dev_event)
739 {
740         struct subchannel *sch;
741
742         cdev->private->state = DEV_STATE_NOT_OPER;
743         sch = to_subchannel(cdev->dev.parent);
744         if (get_device(&cdev->dev)) {
745                 PREPARE_WORK(&cdev->private->kick_work,
746                              ccw_device_call_sch_unregister);
747                 queue_work(ccw_device_work, &cdev->private->kick_work);
748         }
749         wake_up(&cdev->private->wait_q);
750 }
751
752 /*
753  * Handle not operational event while online.
754  */
755 static void
756 ccw_device_online_notoper(struct ccw_device *cdev, enum dev_event dev_event)
757 {
758         struct subchannel *sch;
759
760         sch = to_subchannel(cdev->dev.parent);
761         if (sch->driver->notify &&
762             sch->driver->notify(&sch->dev, sch->lpm ? CIO_GONE : CIO_NO_PATH)) {
763                         ccw_device_set_timeout(cdev, 0);
764                         cdev->private->flags.fake_irb = 0;
765                         cdev->private->state = DEV_STATE_DISCONNECTED;
766                         wake_up(&cdev->private->wait_q);
767                         return;
768         }
769         cdev->private->state = DEV_STATE_NOT_OPER;
770         cio_disable_subchannel(sch);
771         if (sch->schib.scsw.actl != 0) {
772                 // FIXME: not-oper indication to device driver ?
773                 ccw_device_call_handler(cdev);
774         }
775         if (get_device(&cdev->dev)) {
776                 PREPARE_WORK(&cdev->private->kick_work,
777                              ccw_device_call_sch_unregister);
778                 queue_work(ccw_device_work, &cdev->private->kick_work);
779         }
780         wake_up(&cdev->private->wait_q);
781 }
782
783 /*
784  * Handle path verification event.
785  */
786 static void
787 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
788 {
789         struct subchannel *sch;
790
791         if (cdev->private->state == DEV_STATE_W4SENSE) {
792                 cdev->private->flags.doverify = 1;
793                 return;
794         }
795         sch = to_subchannel(cdev->dev.parent);
796         /*
797          * Since we might not just be coming from an interrupt from the
798          * subchannel we have to update the schib.
799          */
800         stsch(sch->schid, &sch->schib);
801
802         if (sch->schib.scsw.actl != 0 ||
803             (sch->schib.scsw.stctl & SCSW_STCTL_STATUS_PEND) ||
804             (cdev->private->irb.scsw.stctl & SCSW_STCTL_STATUS_PEND)) {
805                 /*
806                  * No final status yet or final status not yet delivered
807                  * to the device driver. Can't do path verfication now,
808                  * delay until final status was delivered.
809                  */
810                 cdev->private->flags.doverify = 1;
811                 return;
812         }
813         /* Device is idle, we can do the path verification. */
814         cdev->private->state = DEV_STATE_VERIFY;
815         cdev->private->flags.doverify = 0;
816         ccw_device_verify_start(cdev);
817 }
818
819 /*
820  * Got an interrupt for a normal io (state online).
821  */
822 static void
823 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
824 {
825         struct irb *irb;
826
827         irb = (struct irb *) __LC_IRB;
828         /* Check for unsolicited interrupt. */
829         if ((irb->scsw.stctl ==
830                         (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS))
831             && (!irb->scsw.cc)) {
832                 if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
833                     !irb->esw.esw0.erw.cons) {
834                         /* Unit check but no sense data. Need basic sense. */
835                         if (ccw_device_do_sense(cdev, irb) != 0)
836                                 goto call_handler_unsol;
837                         memcpy(&cdev->private->irb, irb, sizeof(struct irb));
838                         cdev->private->state = DEV_STATE_W4SENSE;
839                         cdev->private->intparm = 0;
840                         return;
841                 }
842 call_handler_unsol:
843                 if (cdev->handler)
844                         cdev->handler (cdev, 0, irb);
845                 if (cdev->private->flags.doverify)
846                         ccw_device_online_verify(cdev, 0);
847                 return;
848         }
849         /* Accumulate status and find out if a basic sense is needed. */
850         ccw_device_accumulate_irb(cdev, irb);
851         if (cdev->private->flags.dosense) {
852                 if (ccw_device_do_sense(cdev, irb) == 0) {
853                         cdev->private->state = DEV_STATE_W4SENSE;
854                 }
855                 return;
856         }
857         /* Call the handler. */
858         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
859                 /* Start delayed path verification. */
860                 ccw_device_online_verify(cdev, 0);
861 }
862
863 /*
864  * Got an timeout in online state.
865  */
866 static void
867 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
868 {
869         int ret;
870
871         ccw_device_set_timeout(cdev, 0);
872         ret = ccw_device_cancel_halt_clear(cdev);
873         if (ret == -EBUSY) {
874                 ccw_device_set_timeout(cdev, 3*HZ);
875                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
876                 return;
877         }
878         if (ret == -ENODEV) {
879                 struct subchannel *sch;
880
881                 sch = to_subchannel(cdev->dev.parent);
882                 if (!sch->lpm) {
883                         PREPARE_WORK(&cdev->private->kick_work,
884                                      ccw_device_nopath_notify);
885                         queue_work(ccw_device_notify_work,
886                                    &cdev->private->kick_work);
887                 } else
888                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
889         } else if (cdev->handler)
890                 cdev->handler(cdev, cdev->private->intparm,
891                               ERR_PTR(-ETIMEDOUT));
892 }
893
894 /*
895  * Got an interrupt for a basic sense.
896  */
897 static void
898 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
899 {
900         struct irb *irb;
901
902         irb = (struct irb *) __LC_IRB;
903         /* Check for unsolicited interrupt. */
904         if (irb->scsw.stctl ==
905                         (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
906                 if (irb->scsw.cc == 1)
907                         /* Basic sense hasn't started. Try again. */
908                         ccw_device_do_sense(cdev, irb);
909                 else {
910                         printk(KERN_INFO "Huh? %s(%s): unsolicited "
911                                "interrupt...\n",
912                                __FUNCTION__, cdev->dev.bus_id);
913                         if (cdev->handler)
914                                 cdev->handler (cdev, 0, irb);
915                 }
916                 return;
917         }
918         /*
919          * Check if a halt or clear has been issued in the meanwhile. If yes,
920          * only deliver the halt/clear interrupt to the device driver as if it
921          * had killed the original request.
922          */
923         if (irb->scsw.fctl & (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
924                 /* Retry Basic Sense if requested. */
925                 if (cdev->private->flags.intretry) {
926                         cdev->private->flags.intretry = 0;
927                         ccw_device_do_sense(cdev, irb);
928                         return;
929                 }
930                 cdev->private->flags.dosense = 0;
931                 memset(&cdev->private->irb, 0, sizeof(struct irb));
932                 ccw_device_accumulate_irb(cdev, irb);
933                 goto call_handler;
934         }
935         /* Add basic sense info to irb. */
936         ccw_device_accumulate_basic_sense(cdev, irb);
937         if (cdev->private->flags.dosense) {
938                 /* Another basic sense is needed. */
939                 ccw_device_do_sense(cdev, irb);
940                 return;
941         }
942 call_handler:
943         cdev->private->state = DEV_STATE_ONLINE;
944         /* Call the handler. */
945         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
946                 /* Start delayed path verification. */
947                 ccw_device_online_verify(cdev, 0);
948 }
949
950 static void
951 ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
952 {
953         struct irb *irb;
954
955         irb = (struct irb *) __LC_IRB;
956         /* Accumulate status. We don't do basic sense. */
957         ccw_device_accumulate_irb(cdev, irb);
958         /* Remember to clear irb to avoid residuals. */
959         memset(&cdev->private->irb, 0, sizeof(struct irb));
960         /* Try to start delayed device verification. */
961         ccw_device_online_verify(cdev, 0);
962         /* Note: Don't call handler for cio initiated clear! */
963 }
964
965 static void
966 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
967 {
968         struct subchannel *sch;
969
970         sch = to_subchannel(cdev->dev.parent);
971         ccw_device_set_timeout(cdev, 0);
972         /* OK, i/o is dead now. Call interrupt handler. */
973         cdev->private->state = DEV_STATE_ONLINE;
974         if (cdev->handler)
975                 cdev->handler(cdev, cdev->private->intparm,
976                               ERR_PTR(-EIO));
977         if (!sch->lpm) {
978                 PREPARE_WORK(&cdev->private->kick_work,
979                              ccw_device_nopath_notify);
980                 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
981         } else if (cdev->private->flags.doverify)
982                 /* Start delayed path verification. */
983                 ccw_device_online_verify(cdev, 0);
984 }
985
986 static void
987 ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
988 {
989         int ret;
990
991         ret = ccw_device_cancel_halt_clear(cdev);
992         if (ret == -EBUSY) {
993                 ccw_device_set_timeout(cdev, 3*HZ);
994                 return;
995         }
996         if (ret == -ENODEV) {
997                 struct subchannel *sch;
998
999                 sch = to_subchannel(cdev->dev.parent);
1000                 if (!sch->lpm) {
1001                         PREPARE_WORK(&cdev->private->kick_work,
1002                                      ccw_device_nopath_notify);
1003                         queue_work(ccw_device_notify_work,
1004                                    &cdev->private->kick_work);
1005                 } else
1006                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1007                 return;
1008         }
1009         //FIXME: Can we get here?
1010         cdev->private->state = DEV_STATE_ONLINE;
1011         if (cdev->handler)
1012                 cdev->handler(cdev, cdev->private->intparm,
1013                               ERR_PTR(-EIO));
1014 }
1015
1016 void device_kill_io(struct subchannel *sch)
1017 {
1018         int ret;
1019         struct ccw_device *cdev;
1020
1021         cdev = sch->dev.driver_data;
1022         ret = ccw_device_cancel_halt_clear(cdev);
1023         if (ret == -EBUSY) {
1024                 ccw_device_set_timeout(cdev, 3*HZ);
1025                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
1026                 return;
1027         }
1028         if (ret == -ENODEV) {
1029                 if (!sch->lpm) {
1030                         PREPARE_WORK(&cdev->private->kick_work,
1031                                      ccw_device_nopath_notify);
1032                         queue_work(ccw_device_notify_work,
1033                                    &cdev->private->kick_work);
1034                 } else
1035                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1036                 return;
1037         }
1038         if (cdev->handler)
1039                 cdev->handler(cdev, cdev->private->intparm,
1040                               ERR_PTR(-EIO));
1041         if (!sch->lpm) {
1042                 PREPARE_WORK(&cdev->private->kick_work,
1043                              ccw_device_nopath_notify);
1044                 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
1045         } else
1046                 /* Start delayed path verification. */
1047                 ccw_device_online_verify(cdev, 0);
1048 }
1049
1050 static void
1051 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
1052 {
1053         /* Start verification after current task finished. */
1054         cdev->private->flags.doverify = 1;
1055 }
1056
1057 static void
1058 ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
1059 {
1060         struct irb *irb;
1061
1062         switch (dev_event) {
1063         case DEV_EVENT_INTERRUPT:
1064                 irb = (struct irb *) __LC_IRB;
1065                 /* Check for unsolicited interrupt. */
1066                 if ((irb->scsw.stctl ==
1067                      (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
1068                     (!irb->scsw.cc))
1069                         /* FIXME: we should restart stlck here, but this
1070                          * is extremely unlikely ... */
1071                         goto out_wakeup;
1072
1073                 ccw_device_accumulate_irb(cdev, irb);
1074                 /* We don't care about basic sense etc. */
1075                 break;
1076         default: /* timeout */
1077                 break;
1078         }
1079 out_wakeup:
1080         wake_up(&cdev->private->wait_q);
1081 }
1082
1083 static void
1084 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
1085 {
1086         struct subchannel *sch;
1087
1088         sch = to_subchannel(cdev->dev.parent);
1089         if (cio_enable_subchannel(sch, sch->schib.pmcw.isc) != 0)
1090                 /* Couldn't enable the subchannel for i/o. Sick device. */
1091                 return;
1092
1093         /* After 60s the device recognition is considered to have failed. */
1094         ccw_device_set_timeout(cdev, 60*HZ);
1095
1096         cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
1097         ccw_device_sense_id_start(cdev);
1098 }
1099
1100 void
1101 device_trigger_reprobe(struct subchannel *sch)
1102 {
1103         struct ccw_device *cdev;
1104
1105         if (!sch->dev.driver_data)
1106                 return;
1107         cdev = sch->dev.driver_data;
1108         if (cdev->private->state != DEV_STATE_DISCONNECTED)
1109                 return;
1110
1111         /* Update some values. */
1112         if (stsch(sch->schid, &sch->schib))
1113                 return;
1114         if (!sch->schib.pmcw.dnv)
1115                 return;
1116         /*
1117          * The pim, pam, pom values may not be accurate, but they are the best
1118          * we have before performing device selection :/
1119          */
1120         sch->lpm = sch->schib.pmcw.pam & sch->opm;
1121         /* Re-set some bits in the pmcw that were lost. */
1122         sch->schib.pmcw.isc = 3;
1123         sch->schib.pmcw.csense = 1;
1124         sch->schib.pmcw.ena = 0;
1125         if ((sch->lpm & (sch->lpm - 1)) != 0)
1126                 sch->schib.pmcw.mp = 1;
1127         sch->schib.pmcw.intparm = (__u32)(unsigned long)sch;
1128         /* We should also udate ssd info, but this has to wait. */
1129         /* Check if this is another device which appeared on the same sch. */
1130         if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1131                 PREPARE_WORK(&cdev->private->kick_work,
1132                              ccw_device_move_to_orphanage);
1133                 queue_work(ccw_device_work, &cdev->private->kick_work);
1134         } else
1135                 ccw_device_start_id(cdev, 0);
1136 }
1137
1138 static void
1139 ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
1140 {
1141         struct subchannel *sch;
1142
1143         sch = to_subchannel(cdev->dev.parent);
1144         /*
1145          * An interrupt in state offline means a previous disable was not
1146          * successful. Try again.
1147          */
1148         cio_disable_subchannel(sch);
1149 }
1150
1151 static void
1152 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
1153 {
1154         retry_set_schib(cdev);
1155         cdev->private->state = DEV_STATE_ONLINE;
1156         dev_fsm_event(cdev, dev_event);
1157 }
1158
1159 static void ccw_device_update_cmfblock(struct ccw_device *cdev,
1160                                        enum dev_event dev_event)
1161 {
1162         cmf_retry_copy_block(cdev);
1163         cdev->private->state = DEV_STATE_ONLINE;
1164         dev_fsm_event(cdev, dev_event);
1165 }
1166
1167 static void
1168 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
1169 {
1170         ccw_device_set_timeout(cdev, 0);
1171         if (dev_event == DEV_EVENT_NOTOPER)
1172                 cdev->private->state = DEV_STATE_NOT_OPER;
1173         else
1174                 cdev->private->state = DEV_STATE_OFFLINE;
1175         wake_up(&cdev->private->wait_q);
1176 }
1177
1178 static void
1179 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1180 {
1181         int ret;
1182
1183         ret = ccw_device_cancel_halt_clear(cdev);
1184         switch (ret) {
1185         case 0:
1186                 cdev->private->state = DEV_STATE_OFFLINE;
1187                 wake_up(&cdev->private->wait_q);
1188                 break;
1189         case -ENODEV:
1190                 cdev->private->state = DEV_STATE_NOT_OPER;
1191                 wake_up(&cdev->private->wait_q);
1192                 break;
1193         default:
1194                 ccw_device_set_timeout(cdev, HZ/10);
1195         }
1196 }
1197
1198 /*
1199  * No operation action. This is used e.g. to ignore a timeout event in
1200  * state offline.
1201  */
1202 static void
1203 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1204 {
1205 }
1206
1207 /*
1208  * Bug operation action. 
1209  */
1210 static void
1211 ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
1212 {
1213         printk(KERN_EMERG "dev_jumptable[%i][%i] == NULL\n",
1214                cdev->private->state, dev_event);
1215         BUG();
1216 }
1217
1218 /*
1219  * device statemachine
1220  */
1221 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
1222         [DEV_STATE_NOT_OPER] = {
1223                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1224                 [DEV_EVENT_INTERRUPT]   = ccw_device_bug,
1225                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1226                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1227         },
1228         [DEV_STATE_SENSE_PGID] = {
1229                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1230                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_pgid_irq,
1231                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
1232                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1233         },
1234         [DEV_STATE_SENSE_ID] = {
1235                 [DEV_EVENT_NOTOPER]     = ccw_device_recog_notoper,
1236                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_id_irq,
1237                 [DEV_EVENT_TIMEOUT]     = ccw_device_recog_timeout,
1238                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1239         },
1240         [DEV_STATE_OFFLINE] = {
1241                 [DEV_EVENT_NOTOPER]     = ccw_device_offline_notoper,
1242                 [DEV_EVENT_INTERRUPT]   = ccw_device_offline_irq,
1243                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1244                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1245         },
1246         [DEV_STATE_VERIFY] = {
1247                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1248                 [DEV_EVENT_INTERRUPT]   = ccw_device_verify_irq,
1249                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
1250                 [DEV_EVENT_VERIFY]      = ccw_device_delay_verify,
1251         },
1252         [DEV_STATE_ONLINE] = {
1253                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1254                 [DEV_EVENT_INTERRUPT]   = ccw_device_irq,
1255                 [DEV_EVENT_TIMEOUT]     = ccw_device_online_timeout,
1256                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1257         },
1258         [DEV_STATE_W4SENSE] = {
1259                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1260                 [DEV_EVENT_INTERRUPT]   = ccw_device_w4sense,
1261                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1262                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1263         },
1264         [DEV_STATE_DISBAND_PGID] = {
1265                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1266                 [DEV_EVENT_INTERRUPT]   = ccw_device_disband_irq,
1267                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
1268                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1269         },
1270         [DEV_STATE_BOXED] = {
1271                 [DEV_EVENT_NOTOPER]     = ccw_device_offline_notoper,
1272                 [DEV_EVENT_INTERRUPT]   = ccw_device_stlck_done,
1273                 [DEV_EVENT_TIMEOUT]     = ccw_device_stlck_done,
1274                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1275         },
1276         /* states to wait for i/o completion before doing something */
1277         [DEV_STATE_CLEAR_VERIFY] = {
1278                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1279                 [DEV_EVENT_INTERRUPT]   = ccw_device_clear_verify,
1280                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1281                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1282         },
1283         [DEV_STATE_TIMEOUT_KILL] = {
1284                 [DEV_EVENT_NOTOPER]     = ccw_device_online_notoper,
1285                 [DEV_EVENT_INTERRUPT]   = ccw_device_killing_irq,
1286                 [DEV_EVENT_TIMEOUT]     = ccw_device_killing_timeout,
1287                 [DEV_EVENT_VERIFY]      = ccw_device_nop, //FIXME
1288         },
1289         [DEV_STATE_QUIESCE] = {
1290                 [DEV_EVENT_NOTOPER]     = ccw_device_quiesce_done,
1291                 [DEV_EVENT_INTERRUPT]   = ccw_device_quiesce_done,
1292                 [DEV_EVENT_TIMEOUT]     = ccw_device_quiesce_timeout,
1293                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1294         },
1295         /* special states for devices gone not operational */
1296         [DEV_STATE_DISCONNECTED] = {
1297                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1298                 [DEV_EVENT_INTERRUPT]   = ccw_device_start_id,
1299                 [DEV_EVENT_TIMEOUT]     = ccw_device_bug,
1300                 [DEV_EVENT_VERIFY]      = ccw_device_start_id,
1301         },
1302         [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1303                 [DEV_EVENT_NOTOPER]     = ccw_device_recog_notoper,
1304                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_id_irq,
1305                 [DEV_EVENT_TIMEOUT]     = ccw_device_recog_timeout,
1306                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1307         },
1308         [DEV_STATE_CMFCHANGE] = {
1309                 [DEV_EVENT_NOTOPER]     = ccw_device_change_cmfstate,
1310                 [DEV_EVENT_INTERRUPT]   = ccw_device_change_cmfstate,
1311                 [DEV_EVENT_TIMEOUT]     = ccw_device_change_cmfstate,
1312                 [DEV_EVENT_VERIFY]      = ccw_device_change_cmfstate,
1313         },
1314         [DEV_STATE_CMFUPDATE] = {
1315                 [DEV_EVENT_NOTOPER]     = ccw_device_update_cmfblock,
1316                 [DEV_EVENT_INTERRUPT]   = ccw_device_update_cmfblock,
1317                 [DEV_EVENT_TIMEOUT]     = ccw_device_update_cmfblock,
1318                 [DEV_EVENT_VERIFY]      = ccw_device_update_cmfblock,
1319         },
1320 };
1321
1322 /*
1323  * io_subchannel_irq is called for "real" interrupts or for status
1324  * pending conditions on msch.
1325  */
1326 void
1327 io_subchannel_irq (struct device *pdev)
1328 {
1329         struct ccw_device *cdev;
1330
1331         cdev = to_subchannel(pdev)->dev.driver_data;
1332
1333         CIO_TRACE_EVENT (3, "IRQ");
1334         CIO_TRACE_EVENT (3, pdev->bus_id);
1335         if (cdev)
1336                 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
1337 }
1338
1339 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);