1 /*
2 * drivers/s390/cio/device_fsm.c
3 * finite state machine for device handling
4 *
5 * Copyright IBM Corp. 2002,2008
6 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
7 * Martin Schwidefsky (schwidefsky@de.ibm.com)
8 */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/jiffies.h>
13 #include <linux/string.h>
14
15 #include <asm/ccwdev.h>
16 #include <asm/cio.h>
17 #include <asm/chpid.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 #include "chp.h"
26
27 static int timeout_log_enabled;
28
ccw_timeout_log_setup(char * unused)29 static int __init ccw_timeout_log_setup(char *unused)
30 {
31 timeout_log_enabled = 1;
32 return 1;
33 }
34
35 __setup("ccw_timeout_log", ccw_timeout_log_setup);
36
ccw_timeout_log(struct ccw_device * cdev)37 static void ccw_timeout_log(struct ccw_device *cdev)
38 {
39 struct schib schib;
40 struct subchannel *sch;
41 struct io_subchannel_private *private;
42 union orb *orb;
43 int cc;
44
45 sch = to_subchannel(cdev->dev.parent);
46 private = to_io_private(sch);
47 orb = &private->orb;
48 cc = stsch(sch->schid, &schib);
49
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",
58 dev_name(&sch->dev));
59 printk(KERN_WARNING "cio: subchannel lpm: %02x, opm: %02x, "
60 "vpm: %02x\n", sch->lpm, sch->opm, sch->vpm);
61
62 if (orb->tm.b) {
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);
68 } else {
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 "
73 "(intern):\n");
74 else
75 printk(KERN_WARNING "cio: last channel program:\n");
76
77 print_hex_dump(KERN_WARNING, "cio: ", DUMP_PREFIX_NONE, 16, 1,
78 (void *)(addr_t)orb->cmd.cpa,
79 sizeof(struct ccw1), 0);
80 }
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);
90 }
91
92 /*
93 * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
94 */
95 static void
ccw_device_timeout(unsigned long data)96 ccw_device_timeout(unsigned long data)
97 {
98 struct ccw_device *cdev;
99
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);
106 }
107
108 /*
109 * Set timeout
110 */
111 void
ccw_device_set_timeout(struct ccw_device * cdev,int expires)112 ccw_device_set_timeout(struct ccw_device *cdev, int expires)
113 {
114 if (expires == 0) {
115 del_timer(&cdev->private->timer);
116 return;
117 }
118 if (timer_pending(&cdev->private->timer)) {
119 if (mod_timer(&cdev->private->timer, jiffies + expires))
120 return;
121 }
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);
126 }
127
128 /*
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
134 * status pending).
135 */
136 int
ccw_device_cancel_halt_clear(struct ccw_device * cdev)137 ccw_device_cancel_halt_clear(struct ccw_device *cdev)
138 {
139 struct subchannel *sch;
140 int ret;
141
142 sch = to_subchannel(cdev->dev.parent);
143 if (cio_update_schib(sch))
144 return -ENODEV;
145 if (!sch->schib.pmcw.ena)
146 /* Not operational -> done. */
147 return 0;
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);
153 if (ret != -EINVAL)
154 return ret;
155 }
156 /* cancel io unsuccessful or not applicable (transport mode).
157 * Continue with asynchronous instructions. */
158 cdev->private->iretry = 3; /* 3 halt retries. */
159 }
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--;
164 ret = cio_halt(sch);
165 if (ret != -EBUSY)
166 return (ret == 0) ? -EBUSY : ret;
167 }
168 /* halt io unsuccessful. */
169 cdev->private->iretry = 255; /* 255 clear retries. */
170 }
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;
176 }
177 panic("Can't stop i/o on subchannel.\n");
178 }
179
180 static int
ccw_device_handle_oper(struct ccw_device * cdev)181 ccw_device_handle_oper(struct ccw_device *cdev)
182 {
183 struct subchannel *sch;
184
185 sch = to_subchannel(cdev->dev.parent);
186 cdev->private->flags.recog_done = 1;
187 /*
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.
191 */
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);
199 return 0;
200 }
201 cdev->private->flags.donotify = 1;
202 return 1;
203 }
204
205 /*
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).
209 */
210 static void
__recover_lost_chpids(struct subchannel * sch,int old_lpm)211 __recover_lost_chpids(struct subchannel *sch, int old_lpm)
212 {
213 int mask, i;
214 struct chp_id chpid;
215
216 chp_id_init(&chpid);
217 for (i = 0; i<8; i++) {
218 mask = 0x80 >> i;
219 if (!(sch->lpm & mask))
220 continue;
221 if (old_lpm & mask)
222 continue;
223 chpid.id = sch->schib.pmcw.chpid[i];
224 if (!chp_is_registered(chpid))
225 css_schedule_eval_all();
226 }
227 }
228
229 /*
230 * Stop device recognition.
231 */
232 static void
ccw_device_recog_done(struct ccw_device * cdev,int state)233 ccw_device_recog_done(struct ccw_device *cdev, int state)
234 {
235 struct subchannel *sch;
236 int notify, old_lpm, same_dev;
237
238 sch = to_subchannel(cdev->dev.parent);
239
240 ccw_device_set_timeout(cdev, 0);
241 cio_disable_subchannel(sch);
242 /*
243 * Now that we tried recognition, we have performed device selection
244 * through ssch() and the path information is up to date.
245 */
246 old_lpm = sch->lpm;
247
248 /* Check since device may again have become not operational. */
249 if (cio_update_schib(sch))
250 state = DEV_STATE_NOT_OPER;
251 else
252 sch->lpm = sch->schib.pmcw.pam & sch->opm;
253
254 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
255 /* Force reprobe on all chpids. */
256 old_lpm = 0;
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;
263 return;
264 }
265 /* Boxed devices don't need extra treatment. */
266 }
267 notify = 0;
268 same_dev = 0; /* Keep the compiler quiet... */
269 switch (state) {
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);
275 break;
276 case DEV_STATE_OFFLINE:
277 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
278 same_dev = ccw_device_handle_oper(cdev);
279 notify = 1;
280 }
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;
287 if (notify) {
288 cdev->private->state = DEV_STATE_OFFLINE;
289 if (same_dev) {
290 /* Get device online again. */
291 ccw_device_online(cdev);
292 wake_up(&cdev->private->wait_q);
293 }
294 return;
295 }
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 = "
299 "%04X/%02X\n",
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);
304 break;
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);
310 break;
311 }
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);
316 }
317
318 /*
319 * Function called from device_id.c after sense id has completed.
320 */
321 void
ccw_device_sense_id_done(struct ccw_device * cdev,int err)322 ccw_device_sense_id_done(struct ccw_device *cdev, int err)
323 {
324 switch (err) {
325 case 0:
326 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
327 break;
328 case -ETIME: /* Sense id stopped by timeout. */
329 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
330 break;
331 default:
332 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
333 break;
334 }
335 }
336
ccw_device_notify(struct ccw_device * cdev,int event)337 int ccw_device_notify(struct ccw_device *cdev, int event)
338 {
339 if (!cdev->drv)
340 return 0;
341 if (!cdev->online)
342 return 0;
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,
345 event);
346 return cdev->drv->notify ? cdev->drv->notify(cdev, event) : 0;
347 }
348
cmf_reenable_delayed(struct work_struct * work)349 static void cmf_reenable_delayed(struct work_struct *work)
350 {
351 struct ccw_device_private *priv;
352 struct ccw_device *cdev;
353
354 priv = container_of(work, struct ccw_device_private, kick_work);
355 cdev = priv->cdev;
356 cmf_reenable(cdev);
357 }
358
ccw_device_oper_notify(struct ccw_device * cdev)359 static void ccw_device_oper_notify(struct ccw_device *cdev)
360 {
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);
365 return;
366 }
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);
371 }
372
373 /*
374 * Finished with online/offline processing.
375 */
376 static void
ccw_device_done(struct ccw_device * cdev,int state)377 ccw_device_done(struct ccw_device *cdev, int state)
378 {
379 struct subchannel *sch;
380
381 sch = to_subchannel(cdev->dev.parent);
382
383 ccw_device_set_timeout(cdev, 0);
384
385 if (state != DEV_STATE_ONLINE)
386 cio_disable_subchannel(sch);
387
388 /* Reset device status. */
389 memset(&cdev->private->irb, 0, sizeof(struct irb));
390
391 cdev->private->state = state;
392
393
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);
397
398 if (cdev->private->flags.donotify) {
399 cdev->private->flags.donotify = 0;
400 ccw_device_oper_notify(cdev);
401 }
402 wake_up(&cdev->private->wait_q);
403 }
404
cmp_pgid(struct pgid * p1,struct pgid * p2)405 static int cmp_pgid(struct pgid *p1, struct pgid *p2)
406 {
407 char *c1;
408 char *c2;
409
410 c1 = (char *)p1;
411 c2 = (char *)p2;
412
413 return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
414 }
415
__ccw_device_get_common_pgid(struct ccw_device * cdev)416 static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
417 {
418 int i;
419 int last;
420
421 last = 0;
422 for (i = 0; i < 8; i++) {
423 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
424 /* No PGID yet */
425 continue;
426 if (cdev->private->pgid[last].inf.ps.state1 ==
427 SNID_STATE1_RESET) {
428 /* First non-zero PGID */
429 last = i;
430 continue;
431 }
432 if (cmp_pgid(&cdev->private->pgid[i],
433 &cdev->private->pgid[last]) == 0)
434 /* Non-conflicting PGIDs */
435 continue;
436
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;
443 return;
444 }
445 if (cdev->private->pgid[last].inf.ps.state1 ==
446 SNID_STATE1_RESET)
447 /* No previous pgid found */
448 memcpy(&cdev->private->pgid[0],
449 &channel_subsystems[0]->global_pgid,
450 sizeof(struct pgid));
451 else
452 /* Use existing pgid */
453 memcpy(&cdev->private->pgid[0], &cdev->private->pgid[last],
454 sizeof(struct pgid));
455 }
456
457 /*
458 * Function called from device_pgid.c after sense path ground has completed.
459 */
460 void
ccw_device_sense_pgid_done(struct ccw_device * cdev,int err)461 ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
462 {
463 struct subchannel *sch;
464
465 sch = to_subchannel(cdev->dev.parent);
466 switch (err) {
467 case -EOPNOTSUPP: /* path grouping not supported, use nop instead. */
468 cdev->private->options.pgroup = 0;
469 break;
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);
474 break;
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);
478 return;
479 default:
480 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
481 return;
482 }
483 /* Start Path Group verification. */
484 cdev->private->state = DEV_STATE_VERIFY;
485 cdev->private->flags.doverify = 0;
486 ccw_device_verify_start(cdev);
487 }
488
489 /*
490 * Start device recognition.
491 */
492 int
ccw_device_recognition(struct ccw_device * cdev)493 ccw_device_recognition(struct ccw_device *cdev)
494 {
495 struct subchannel *sch;
496 int ret;
497
498 if ((cdev->private->state != DEV_STATE_NOT_OPER) &&
499 (cdev->private->state != DEV_STATE_BOXED))
500 return -EINVAL;
501 sch = to_subchannel(cdev->dev.parent);
502 ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
503 if (ret != 0)
504 /* Couldn't enable the subchannel for i/o. Sick device. */
505 return ret;
506
507 /* After 60s the device recognition is considered to have failed. */
508 ccw_device_set_timeout(cdev, 60*HZ);
509
510 /*
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).
517 */
518 cdev->private->flags.recog_done = 0;
519 cdev->private->state = DEV_STATE_SENSE_ID;
520 ccw_device_sense_id_start(cdev);
521 return 0;
522 }
523
524 /*
525 * Handle timeout in device recognition.
526 */
527 static void
ccw_device_recog_timeout(struct ccw_device * cdev,enum dev_event dev_event)528 ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
529 {
530 int ret;
531
532 ret = ccw_device_cancel_halt_clear(cdev);
533 switch (ret) {
534 case 0:
535 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
536 break;
537 case -ENODEV:
538 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
539 break;
540 default:
541 ccw_device_set_timeout(cdev, 3*HZ);
542 }
543 }
544
545
546 void
ccw_device_verify_done(struct ccw_device * cdev,int err)547 ccw_device_verify_done(struct ccw_device *cdev, int err)
548 {
549 struct subchannel *sch;
550
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);
556 return;
557 }
558 /* Update lpm with verified path mask. */
559 sch->lpm = sch->vpm;
560 /* Repeat path verification? */
561 if (cdev->private->flags.doverify) {
562 cdev->private->flags.doverify = 0;
563 ccw_device_verify_start(cdev);
564 return;
565 }
566 switch (err) {
567 case -EOPNOTSUPP: /* path grouping not supported, just set online. */
568 cdev->private->options.pgroup = 0;
569 case 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;
580 if (cdev->handler)
581 cdev->handler(cdev, cdev->private->intparm,
582 &cdev->private->irb);
583 memset(&cdev->private->irb, 0, sizeof(struct irb));
584 }
585 break;
586 case -ETIME:
587 /* Reset oper notify indication after verify error. */
588 cdev->private->flags.donotify = 0;
589 ccw_device_done(cdev, DEV_STATE_BOXED);
590 break;
591 default:
592 /* Reset oper notify indication after verify error. */
593 cdev->private->flags.donotify = 0;
594 if (cdev->online) {
595 ccw_device_set_timeout(cdev, 0);
596 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
597 } else
598 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
599 break;
600 }
601 }
602
603 /*
604 * Get device online.
605 */
606 int
ccw_device_online(struct ccw_device * cdev)607 ccw_device_online(struct ccw_device *cdev)
608 {
609 struct subchannel *sch;
610 int ret;
611
612 if ((cdev->private->state != DEV_STATE_OFFLINE) &&
613 (cdev->private->state != DEV_STATE_BOXED))
614 return -EINVAL;
615 sch = to_subchannel(cdev->dev.parent);
616 ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
617 if (ret != 0) {
618 /* Couldn't enable the subchannel for i/o. Sick device. */
619 if (ret == -ENODEV)
620 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
621 return ret;
622 }
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);
629 return 0;
630 }
631 /* Do a SensePGID first. */
632 cdev->private->state = DEV_STATE_SENSE_PGID;
633 ccw_device_sense_pgid_start(cdev);
634 return 0;
635 }
636
637 void
ccw_device_disband_done(struct ccw_device * cdev,int err)638 ccw_device_disband_done(struct ccw_device *cdev, int err)
639 {
640 switch (err) {
641 case 0:
642 ccw_device_done(cdev, DEV_STATE_OFFLINE);
643 break;
644 case -ETIME:
645 ccw_device_done(cdev, DEV_STATE_BOXED);
646 break;
647 default:
648 cdev->private->flags.donotify = 0;
649 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
650 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
651 break;
652 }
653 }
654
655 /*
656 * Shutdown device.
657 */
658 int
ccw_device_offline(struct ccw_device * cdev)659 ccw_device_offline(struct ccw_device *cdev)
660 {
661 struct subchannel *sch;
662
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);
668 return 0;
669 }
670 if (ccw_device_is_orphan(cdev)) {
671 ccw_device_done(cdev, DEV_STATE_OFFLINE);
672 return 0;
673 }
674 sch = to_subchannel(cdev->dev.parent);
675 if (cio_update_schib(sch))
676 return -ENODEV;
677 if (scsw_actl(&sch->schib.scsw) != 0)
678 return -EBUSY;
679 if (cdev->private->state != DEV_STATE_ONLINE)
680 return -EINVAL;
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);
685 return 0;
686 }
687 /* Start Set Path Group commands. */
688 cdev->private->state = DEV_STATE_DISBAND_PGID;
689 ccw_device_disband_start(cdev);
690 return 0;
691 }
692
693 /*
694 * Handle timeout in device online/offline process.
695 */
696 static void
ccw_device_onoff_timeout(struct ccw_device * cdev,enum dev_event dev_event)697 ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
698 {
699 int ret;
700
701 ret = ccw_device_cancel_halt_clear(cdev);
702 switch (ret) {
703 case 0:
704 ccw_device_done(cdev, DEV_STATE_BOXED);
705 break;
706 case -ENODEV:
707 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
708 break;
709 default:
710 ccw_device_set_timeout(cdev, 3*HZ);
711 }
712 }
713
714 /*
715 * Handle not oper event in device recognition.
716 */
717 static void
ccw_device_recog_notoper(struct ccw_device * cdev,enum dev_event dev_event)718 ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
719 {
720 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
721 }
722
723 /*
724 * Handle not operational event in non-special state.
725 */
ccw_device_generic_notoper(struct ccw_device * cdev,enum dev_event dev_event)726 static void ccw_device_generic_notoper(struct ccw_device *cdev,
727 enum dev_event dev_event)
728 {
729 struct subchannel *sch;
730
731 cdev->private->state = DEV_STATE_NOT_OPER;
732 sch = to_subchannel(cdev->dev.parent);
733 css_schedule_eval(sch->schid);
734 }
735
736 /*
737 * Handle path verification event.
738 */
739 static void
ccw_device_online_verify(struct ccw_device * cdev,enum dev_event dev_event)740 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
741 {
742 struct subchannel *sch;
743
744 if (cdev->private->state == DEV_STATE_W4SENSE) {
745 cdev->private->flags.doverify = 1;
746 return;
747 }
748 sch = to_subchannel(cdev->dev.parent);
749 /*
750 * Since we might not just be coming from an interrupt from the
751 * subchannel we have to update the schib.
752 */
753 if (cio_update_schib(sch)) {
754 ccw_device_verify_done(cdev, -ENODEV);
755 return;
756 }
757
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)) {
761 /*
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.
765 */
766 cdev->private->flags.doverify = 1;
767 return;
768 }
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);
773 }
774
775 /*
776 * Got an interrupt for a normal io (state online).
777 */
778 static void
ccw_device_irq(struct ccw_device * cdev,enum dev_event dev_event)779 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
780 {
781 struct irb *irb;
782 int is_cmd;
783
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;
796 return;
797 }
798 call_handler_unsol:
799 if (cdev->handler)
800 cdev->handler (cdev, 0, irb);
801 if (cdev->private->flags.doverify)
802 ccw_device_online_verify(cdev, 0);
803 return;
804 }
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;
810 }
811 return;
812 }
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);
817 }
818
819 /*
820 * Got an timeout in online state.
821 */
822 static void
ccw_device_online_timeout(struct ccw_device * cdev,enum dev_event dev_event)823 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
824 {
825 int ret;
826
827 ccw_device_set_timeout(cdev, 0);
828 ret = ccw_device_cancel_halt_clear(cdev);
829 if (ret == -EBUSY) {
830 ccw_device_set_timeout(cdev, 3*HZ);
831 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
832 return;
833 }
834 if (ret == -ENODEV)
835 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
836 else if (cdev->handler)
837 cdev->handler(cdev, cdev->private->intparm,
838 ERR_PTR(-ETIMEDOUT));
839 }
840
841 /*
842 * Got an interrupt for a basic sense.
843 */
844 static void
ccw_device_w4sense(struct ccw_device * cdev,enum dev_event dev_event)845 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
846 {
847 struct irb *irb;
848
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);
856 else {
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);
861 if (cdev->handler)
862 cdev->handler (cdev, 0, irb);
863 }
864 return;
865 }
866 /*
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.
870 */
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);
877 return;
878 }
879 cdev->private->flags.dosense = 0;
880 memset(&cdev->private->irb, 0, sizeof(struct irb));
881 ccw_device_accumulate_irb(cdev, irb);
882 goto call_handler;
883 }
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);
889 return;
890 }
891 call_handler:
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);
897 }
898
899 static void
ccw_device_clear_verify(struct ccw_device * cdev,enum dev_event dev_event)900 ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
901 {
902 struct irb *irb;
903
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! */
912 }
913
914 static void
ccw_device_killing_irq(struct ccw_device * cdev,enum dev_event dev_event)915 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
916 {
917 struct subchannel *sch;
918
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. */
924 if (cdev->handler)
925 cdev->handler(cdev, cdev->private->intparm,
926 ERR_PTR(-EIO));
927 }
928
929 static void
ccw_device_killing_timeout(struct ccw_device * cdev,enum dev_event dev_event)930 ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
931 {
932 int ret;
933
934 ret = ccw_device_cancel_halt_clear(cdev);
935 if (ret == -EBUSY) {
936 ccw_device_set_timeout(cdev, 3*HZ);
937 return;
938 }
939 /* Start delayed path verification. */
940 ccw_device_online_verify(cdev, 0);
941 if (cdev->handler)
942 cdev->handler(cdev, cdev->private->intparm,
943 ERR_PTR(-EIO));
944 }
945
ccw_device_kill_io(struct ccw_device * cdev)946 void ccw_device_kill_io(struct ccw_device *cdev)
947 {
948 int ret;
949
950 ret = ccw_device_cancel_halt_clear(cdev);
951 if (ret == -EBUSY) {
952 ccw_device_set_timeout(cdev, 3*HZ);
953 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
954 return;
955 }
956 /* Start delayed path verification. */
957 ccw_device_online_verify(cdev, 0);
958 if (cdev->handler)
959 cdev->handler(cdev, cdev->private->intparm,
960 ERR_PTR(-EIO));
961 }
962
963 static void
ccw_device_delay_verify(struct ccw_device * cdev,enum dev_event dev_event)964 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
965 {
966 /* Start verification after current task finished. */
967 cdev->private->flags.doverify = 1;
968 }
969
970 static void
ccw_device_stlck_done(struct ccw_device * cdev,enum dev_event dev_event)971 ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
972 {
973 struct irb *irb;
974
975 switch (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 ... */
984 goto out_wakeup;
985
986 ccw_device_accumulate_irb(cdev, irb);
987 /* We don't care about basic sense etc. */
988 break;
989 default: /* timeout */
990 break;
991 }
992 out_wakeup:
993 wake_up(&cdev->private->wait_q);
994 }
995
996 static void
ccw_device_start_id(struct ccw_device * cdev,enum dev_event dev_event)997 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
998 {
999 struct subchannel *sch;
1000
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. */
1004 return;
1005
1006 /* After 60s the device recognition is considered to have failed. */
1007 ccw_device_set_timeout(cdev, 60*HZ);
1008
1009 cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
1010 ccw_device_sense_id_start(cdev);
1011 }
1012
ccw_device_trigger_reprobe(struct ccw_device * cdev)1013 void ccw_device_trigger_reprobe(struct ccw_device *cdev)
1014 {
1015 struct subchannel *sch;
1016
1017 if (cdev->private->state != DEV_STATE_DISCONNECTED)
1018 return;
1019
1020 sch = to_subchannel(cdev->dev.parent);
1021 /* Update some values. */
1022 if (cio_update_schib(sch))
1023 return;
1024 /*
1025 * The pim, pam, pom values may not be accurate, but they are the best
1026 * we have before performing device selection :/
1027 */
1028 sch->lpm = sch->schib.pmcw.pam & sch->opm;
1029 /*
1030 * Use the initial configuration since we can't be shure that the old
1031 * paths are valid.
1032 */
1033 io_subchannel_init_config(sch);
1034 if (cio_commit_config(sch))
1035 return;
1036
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);
1043 } else
1044 ccw_device_start_id(cdev, 0);
1045 }
1046
1047 static void
ccw_device_offline_irq(struct ccw_device * cdev,enum dev_event dev_event)1048 ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
1049 {
1050 struct subchannel *sch;
1051
1052 sch = to_subchannel(cdev->dev.parent);
1053 /*
1054 * An interrupt in state offline means a previous disable was not
1055 * successful. Try again.
1056 */
1057 cio_disable_subchannel(sch);
1058 }
1059
1060 static void
ccw_device_change_cmfstate(struct ccw_device * cdev,enum dev_event dev_event)1061 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
1062 {
1063 retry_set_schib(cdev);
1064 cdev->private->state = DEV_STATE_ONLINE;
1065 dev_fsm_event(cdev, dev_event);
1066 }
1067
ccw_device_update_cmfblock(struct ccw_device * cdev,enum dev_event dev_event)1068 static void ccw_device_update_cmfblock(struct ccw_device *cdev,
1069 enum dev_event dev_event)
1070 {
1071 cmf_retry_copy_block(cdev);
1072 cdev->private->state = DEV_STATE_ONLINE;
1073 dev_fsm_event(cdev, dev_event);
1074 }
1075
1076 static void
ccw_device_quiesce_done(struct ccw_device * cdev,enum dev_event dev_event)1077 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
1078 {
1079 ccw_device_set_timeout(cdev, 0);
1080 if (dev_event == DEV_EVENT_NOTOPER)
1081 cdev->private->state = DEV_STATE_NOT_OPER;
1082 else
1083 cdev->private->state = DEV_STATE_OFFLINE;
1084 wake_up(&cdev->private->wait_q);
1085 }
1086
1087 static void
ccw_device_quiesce_timeout(struct ccw_device * cdev,enum dev_event dev_event)1088 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1089 {
1090 int ret;
1091
1092 ret = ccw_device_cancel_halt_clear(cdev);
1093 switch (ret) {
1094 case 0:
1095 cdev->private->state = DEV_STATE_OFFLINE;
1096 wake_up(&cdev->private->wait_q);
1097 break;
1098 case -ENODEV:
1099 cdev->private->state = DEV_STATE_NOT_OPER;
1100 wake_up(&cdev->private->wait_q);
1101 break;
1102 default:
1103 ccw_device_set_timeout(cdev, HZ/10);
1104 }
1105 }
1106
1107 /*
1108 * No operation action. This is used e.g. to ignore a timeout event in
1109 * state offline.
1110 */
1111 static void
ccw_device_nop(struct ccw_device * cdev,enum dev_event dev_event)1112 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1113 {
1114 }
1115
1116 /*
1117 * Bug operation action.
1118 */
1119 static void
ccw_device_bug(struct ccw_device * cdev,enum dev_event dev_event)1120 ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
1121 {
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);
1126 BUG();
1127 }
1128
1129 /*
1130 * device statemachine
1131 */
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,
1138 },
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,
1144 },
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,
1150 },
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,
1156 },
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,
1162 },
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,
1168 },
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,
1174 },
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,
1180 },
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,
1186 },
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,
1193 },
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
1199 },
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,
1205 },
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,
1212 },
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,
1218 },
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,
1224 },
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,
1230 },
1231 };
1232
1233 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);
1234