2cb01861ce34062c4264be40befecf8558868785
[linux-2.6.git] / drivers / s390 / cio / device_fsm.c
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
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
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
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
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
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 void ccw_device_update_sense_data(struct ccw_device *cdev)
181 {
182         memset(&cdev->id, 0, sizeof(cdev->id));
183         cdev->id.cu_type   = cdev->private->senseid.cu_type;
184         cdev->id.cu_model  = cdev->private->senseid.cu_model;
185         cdev->id.dev_type  = cdev->private->senseid.dev_type;
186         cdev->id.dev_model = cdev->private->senseid.dev_model;
187 }
188
189 int ccw_device_test_sense_data(struct ccw_device *cdev)
190 {
191         return 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 }
196
197 /*
198  * The machine won't give us any notification by machine check if a chpid has
199  * been varied online on the SE so we have to find out by magic (i. e. driving
200  * the channel subsystem to device selection and updating our path masks).
201  */
202 static void
203 __recover_lost_chpids(struct subchannel *sch, int old_lpm)
204 {
205         int mask, i;
206         struct chp_id chpid;
207
208         chp_id_init(&chpid);
209         for (i = 0; i<8; i++) {
210                 mask = 0x80 >> i;
211                 if (!(sch->lpm & mask))
212                         continue;
213                 if (old_lpm & mask)
214                         continue;
215                 chpid.id = sch->schib.pmcw.chpid[i];
216                 if (!chp_is_registered(chpid))
217                         css_schedule_eval_all();
218         }
219 }
220
221 /*
222  * Stop device recognition.
223  */
224 static void
225 ccw_device_recog_done(struct ccw_device *cdev, int state)
226 {
227         struct subchannel *sch;
228         int old_lpm;
229
230         sch = to_subchannel(cdev->dev.parent);
231
232         if (cio_disable_subchannel(sch))
233                 state = DEV_STATE_NOT_OPER;
234         /*
235          * Now that we tried recognition, we have performed device selection
236          * through ssch() and the path information is up to date.
237          */
238         old_lpm = sch->lpm;
239
240         /* Check since device may again have become not operational. */
241         if (cio_update_schib(sch))
242                 state = DEV_STATE_NOT_OPER;
243         else
244                 sch->lpm = sch->schib.pmcw.pam & sch->opm;
245
246         if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
247                 /* Force reprobe on all chpids. */
248                 old_lpm = 0;
249         if (sch->lpm != old_lpm)
250                 __recover_lost_chpids(sch, old_lpm);
251         if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID &&
252             (state == DEV_STATE_NOT_OPER || state == DEV_STATE_BOXED)) {
253                 cdev->private->flags.recog_done = 1;
254                 cdev->private->state = DEV_STATE_DISCONNECTED;
255                 wake_up(&cdev->private->wait_q);
256                 return;
257         }
258         if (cdev->private->flags.resuming) {
259                 cdev->private->state = state;
260                 cdev->private->flags.recog_done = 1;
261                 wake_up(&cdev->private->wait_q);
262                 return;
263         }
264         switch (state) {
265         case DEV_STATE_NOT_OPER:
266                 break;
267         case DEV_STATE_OFFLINE:
268                 if (!cdev->online) {
269                         ccw_device_update_sense_data(cdev);
270                         break;
271                 }
272                 cdev->private->state = DEV_STATE_OFFLINE;
273                 cdev->private->flags.recog_done = 1;
274                 if (ccw_device_test_sense_data(cdev)) {
275                         cdev->private->flags.donotify = 1;
276                         ccw_device_online(cdev);
277                         wake_up(&cdev->private->wait_q);
278                 } else {
279                         ccw_device_update_sense_data(cdev);
280                         ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
281                 }
282                 return;
283         case DEV_STATE_BOXED:
284                 if (cdev->id.cu_type != 0) { /* device was recognized before */
285                         cdev->private->flags.recog_done = 1;
286                         cdev->private->state = DEV_STATE_BOXED;
287                         wake_up(&cdev->private->wait_q);
288                         return;
289                 }
290                 break;
291         }
292         cdev->private->state = state;
293         io_subchannel_recog_done(cdev);
294         wake_up(&cdev->private->wait_q);
295 }
296
297 /*
298  * Function called from device_id.c after sense id has completed.
299  */
300 void
301 ccw_device_sense_id_done(struct ccw_device *cdev, int err)
302 {
303         switch (err) {
304         case 0:
305                 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
306                 break;
307         case -ETIME:            /* Sense id stopped by timeout. */
308                 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
309                 break;
310         default:
311                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
312                 break;
313         }
314 }
315
316 /**
317   * ccw_device_notify() - inform the device's driver about an event
318   * @cdev: device for which an event occured
319   * @event: event that occurred
320   *
321   * Returns:
322   *   -%EINVAL if the device is offline or has no driver.
323   *   -%EOPNOTSUPP if the device's driver has no notifier registered.
324   *   %NOTIFY_OK if the driver wants to keep the device.
325   *   %NOTIFY_BAD if the driver doesn't want to keep the device.
326   */
327 int ccw_device_notify(struct ccw_device *cdev, int event)
328 {
329         int ret = -EINVAL;
330
331         if (!cdev->drv)
332                 goto out;
333         if (!cdev->online)
334                 goto out;
335         CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
336                       cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
337                       event);
338         if (!cdev->drv->notify) {
339                 ret = -EOPNOTSUPP;
340                 goto out;
341         }
342         if (cdev->drv->notify(cdev, event))
343                 ret = NOTIFY_OK;
344         else
345                 ret = NOTIFY_BAD;
346 out:
347         return ret;
348 }
349
350 static void ccw_device_oper_notify(struct ccw_device *cdev)
351 {
352         if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_OK) {
353                 /* Reenable channel measurements, if needed. */
354                 ccw_device_sched_todo(cdev, CDEV_TODO_ENABLE_CMF);
355                 return;
356         }
357         /* Driver doesn't want device back. */
358         ccw_device_set_notoper(cdev);
359         ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
360 }
361
362 /*
363  * Finished with online/offline processing.
364  */
365 static void
366 ccw_device_done(struct ccw_device *cdev, int state)
367 {
368         struct subchannel *sch;
369
370         sch = to_subchannel(cdev->dev.parent);
371
372         ccw_device_set_timeout(cdev, 0);
373
374         if (state != DEV_STATE_ONLINE)
375                 cio_disable_subchannel(sch);
376
377         /* Reset device status. */
378         memset(&cdev->private->irb, 0, sizeof(struct irb));
379
380         cdev->private->state = state;
381
382         switch (state) {
383         case DEV_STATE_BOXED:
384                 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
385                               cdev->private->dev_id.devno, sch->schid.sch_no);
386                 if (cdev->online &&
387                     ccw_device_notify(cdev, CIO_BOXED) != NOTIFY_OK)
388                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
389                 cdev->private->flags.donotify = 0;
390                 break;
391         case DEV_STATE_NOT_OPER:
392                 CIO_MSG_EVENT(0, "Device %04x gone on subchannel %04x\n",
393                               cdev->private->dev_id.devno, sch->schid.sch_no);
394                 if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
395                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
396                 else
397                         ccw_device_set_disconnected(cdev);
398                 cdev->private->flags.donotify = 0;
399                 break;
400         case DEV_STATE_DISCONNECTED:
401                 CIO_MSG_EVENT(0, "Disconnected device %04x on subchannel "
402                               "%04x\n", cdev->private->dev_id.devno,
403                               sch->schid.sch_no);
404                 if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK)
405                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
406                 else
407                         ccw_device_set_disconnected(cdev);
408                 cdev->private->flags.donotify = 0;
409                 break;
410         default:
411                 break;
412         }
413
414         if (cdev->private->flags.donotify) {
415                 cdev->private->flags.donotify = 0;
416                 ccw_device_oper_notify(cdev);
417         }
418         wake_up(&cdev->private->wait_q);
419 }
420
421 /*
422  * Start device recognition.
423  */
424 void ccw_device_recognition(struct ccw_device *cdev)
425 {
426         struct subchannel *sch = to_subchannel(cdev->dev.parent);
427
428         /*
429          * We used to start here with a sense pgid to find out whether a device
430          * is locked by someone else. Unfortunately, the sense pgid command
431          * code has other meanings on devices predating the path grouping
432          * algorithm, so we start with sense id and box the device after an
433          * timeout (or if sense pgid during path verification detects the device
434          * is locked, as may happen on newer devices).
435          */
436         cdev->private->flags.recog_done = 0;
437         cdev->private->state = DEV_STATE_SENSE_ID;
438         if (cio_enable_subchannel(sch, (u32) (addr_t) sch)) {
439                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
440                 return;
441         }
442         ccw_device_sense_id_start(cdev);
443 }
444
445 /*
446  * Handle events for states that use the ccw request infrastructure.
447  */
448 static void ccw_device_request_event(struct ccw_device *cdev, enum dev_event e)
449 {
450         switch (e) {
451         case DEV_EVENT_NOTOPER:
452                 ccw_request_notoper(cdev);
453                 break;
454         case DEV_EVENT_INTERRUPT:
455                 ccw_request_handler(cdev);
456                 break;
457         case DEV_EVENT_TIMEOUT:
458                 ccw_request_timeout(cdev);
459                 break;
460         default:
461                 break;
462         }
463 }
464
465 void
466 ccw_device_verify_done(struct ccw_device *cdev, int err)
467 {
468         struct subchannel *sch;
469
470         sch = to_subchannel(cdev->dev.parent);
471         /* Update schib - pom may have changed. */
472         if (cio_update_schib(sch)) {
473                 err = -ENODEV;
474                 goto callback;
475         }
476         /* Update lpm with verified path mask. */
477         sch->lpm = sch->vpm;
478         /* Repeat path verification? */
479         if (cdev->private->flags.doverify) {
480                 ccw_device_verify_start(cdev);
481                 return;
482         }
483 callback:
484         switch (err) {
485         case 0:
486                 ccw_device_done(cdev, DEV_STATE_ONLINE);
487                 /* Deliver fake irb to device driver, if needed. */
488                 if (cdev->private->flags.fake_irb) {
489                         memset(&cdev->private->irb, 0, sizeof(struct irb));
490                         cdev->private->irb.scsw.cmd.cc = 1;
491                         cdev->private->irb.scsw.cmd.fctl = SCSW_FCTL_START_FUNC;
492                         cdev->private->irb.scsw.cmd.actl = SCSW_ACTL_START_PEND;
493                         cdev->private->irb.scsw.cmd.stctl =
494                                 SCSW_STCTL_STATUS_PEND;
495                         cdev->private->flags.fake_irb = 0;
496                         if (cdev->handler)
497                                 cdev->handler(cdev, cdev->private->intparm,
498                                               &cdev->private->irb);
499                         memset(&cdev->private->irb, 0, sizeof(struct irb));
500                 }
501                 break;
502         case -ETIME:
503         case -EUSERS:
504                 /* Reset oper notify indication after verify error. */
505                 cdev->private->flags.donotify = 0;
506                 ccw_device_done(cdev, DEV_STATE_BOXED);
507                 break;
508         case -EACCES:
509                 /* Reset oper notify indication after verify error. */
510                 cdev->private->flags.donotify = 0;
511                 ccw_device_done(cdev, DEV_STATE_DISCONNECTED);
512                 break;
513         default:
514                 /* Reset oper notify indication after verify error. */
515                 cdev->private->flags.donotify = 0;
516                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
517                 break;
518         }
519 }
520
521 /*
522  * Get device online.
523  */
524 int
525 ccw_device_online(struct ccw_device *cdev)
526 {
527         struct subchannel *sch;
528         int ret;
529
530         if ((cdev->private->state != DEV_STATE_OFFLINE) &&
531             (cdev->private->state != DEV_STATE_BOXED))
532                 return -EINVAL;
533         sch = to_subchannel(cdev->dev.parent);
534         ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
535         if (ret != 0) {
536                 /* Couldn't enable the subchannel for i/o. Sick device. */
537                 if (ret == -ENODEV)
538                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
539                 return ret;
540         }
541         /* Start initial path verification. */
542         cdev->private->state = DEV_STATE_VERIFY;
543         ccw_device_verify_start(cdev);
544         return 0;
545 }
546
547 void
548 ccw_device_disband_done(struct ccw_device *cdev, int err)
549 {
550         switch (err) {
551         case 0:
552                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
553                 break;
554         case -ETIME:
555                 ccw_device_done(cdev, DEV_STATE_BOXED);
556                 break;
557         default:
558                 cdev->private->flags.donotify = 0;
559                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
560                 break;
561         }
562 }
563
564 /*
565  * Shutdown device.
566  */
567 int
568 ccw_device_offline(struct ccw_device *cdev)
569 {
570         struct subchannel *sch;
571
572         /* Allow ccw_device_offline while disconnected. */
573         if (cdev->private->state == DEV_STATE_DISCONNECTED ||
574             cdev->private->state == DEV_STATE_NOT_OPER) {
575                 cdev->private->flags.donotify = 0;
576                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
577                 return 0;
578         }
579         if (cdev->private->state == DEV_STATE_BOXED) {
580                 ccw_device_done(cdev, DEV_STATE_BOXED);
581                 return 0;
582         }
583         if (ccw_device_is_orphan(cdev)) {
584                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
585                 return 0;
586         }
587         sch = to_subchannel(cdev->dev.parent);
588         if (cio_update_schib(sch))
589                 return -ENODEV;
590         if (scsw_actl(&sch->schib.scsw) != 0)
591                 return -EBUSY;
592         if (cdev->private->state != DEV_STATE_ONLINE)
593                 return -EINVAL;
594         /* Are we doing path grouping? */
595         if (!cdev->private->flags.pgroup) {
596                 /* No, set state offline immediately. */
597                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
598                 return 0;
599         }
600         /* Start Set Path Group commands. */
601         cdev->private->state = DEV_STATE_DISBAND_PGID;
602         ccw_device_disband_start(cdev);
603         return 0;
604 }
605
606 /*
607  * Handle not operational event in non-special state.
608  */
609 static void ccw_device_generic_notoper(struct ccw_device *cdev,
610                                        enum dev_event dev_event)
611 {
612         if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
613                 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
614         else
615                 ccw_device_set_disconnected(cdev);
616 }
617
618 /*
619  * Handle path verification event in offline state.
620  */
621 static void ccw_device_offline_verify(struct ccw_device *cdev,
622                                       enum dev_event dev_event)
623 {
624         struct subchannel *sch = to_subchannel(cdev->dev.parent);
625
626         css_schedule_eval(sch->schid);
627 }
628
629 /*
630  * Handle path verification event.
631  */
632 static void
633 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
634 {
635         struct subchannel *sch;
636
637         if (cdev->private->state == DEV_STATE_W4SENSE) {
638                 cdev->private->flags.doverify = 1;
639                 return;
640         }
641         sch = to_subchannel(cdev->dev.parent);
642         /*
643          * Since we might not just be coming from an interrupt from the
644          * subchannel we have to update the schib.
645          */
646         if (cio_update_schib(sch)) {
647                 ccw_device_verify_done(cdev, -ENODEV);
648                 return;
649         }
650
651         if (scsw_actl(&sch->schib.scsw) != 0 ||
652             (scsw_stctl(&sch->schib.scsw) & SCSW_STCTL_STATUS_PEND) ||
653             (scsw_stctl(&cdev->private->irb.scsw) & SCSW_STCTL_STATUS_PEND)) {
654                 /*
655                  * No final status yet or final status not yet delivered
656                  * to the device driver. Can't do path verfication now,
657                  * delay until final status was delivered.
658                  */
659                 cdev->private->flags.doverify = 1;
660                 return;
661         }
662         /* Device is idle, we can do the path verification. */
663         cdev->private->state = DEV_STATE_VERIFY;
664         ccw_device_verify_start(cdev);
665 }
666
667 /*
668  * Handle path verification event in boxed state.
669  */
670 static void ccw_device_boxed_verify(struct ccw_device *cdev,
671                                     enum dev_event dev_event)
672 {
673         struct subchannel *sch = to_subchannel(cdev->dev.parent);
674
675         if (cdev->online) {
676                 if (cio_enable_subchannel(sch, (u32) (addr_t) sch))
677                         ccw_device_done(cdev, DEV_STATE_NOT_OPER);
678                 else
679                         ccw_device_online_verify(cdev, dev_event);
680         } else
681                 css_schedule_eval(sch->schid);
682 }
683
684 /*
685  * Got an interrupt for a normal io (state online).
686  */
687 static void
688 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
689 {
690         struct irb *irb;
691         int is_cmd;
692
693         irb = (struct irb *) __LC_IRB;
694         is_cmd = !scsw_is_tm(&irb->scsw);
695         /* Check for unsolicited interrupt. */
696         if (!scsw_is_solicited(&irb->scsw)) {
697                 if (is_cmd && (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
698                     !irb->esw.esw0.erw.cons) {
699                         /* Unit check but no sense data. Need basic sense. */
700                         if (ccw_device_do_sense(cdev, irb) != 0)
701                                 goto call_handler_unsol;
702                         memcpy(&cdev->private->irb, irb, sizeof(struct irb));
703                         cdev->private->state = DEV_STATE_W4SENSE;
704                         cdev->private->intparm = 0;
705                         return;
706                 }
707 call_handler_unsol:
708                 if (cdev->handler)
709                         cdev->handler (cdev, 0, irb);
710                 if (cdev->private->flags.doverify)
711                         ccw_device_online_verify(cdev, 0);
712                 return;
713         }
714         /* Accumulate status and find out if a basic sense is needed. */
715         ccw_device_accumulate_irb(cdev, irb);
716         if (is_cmd && cdev->private->flags.dosense) {
717                 if (ccw_device_do_sense(cdev, irb) == 0) {
718                         cdev->private->state = DEV_STATE_W4SENSE;
719                 }
720                 return;
721         }
722         /* Call the handler. */
723         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
724                 /* Start delayed path verification. */
725                 ccw_device_online_verify(cdev, 0);
726 }
727
728 /*
729  * Got an timeout in online state.
730  */
731 static void
732 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
733 {
734         int ret;
735
736         ccw_device_set_timeout(cdev, 0);
737         ret = ccw_device_cancel_halt_clear(cdev);
738         if (ret == -EBUSY) {
739                 ccw_device_set_timeout(cdev, 3*HZ);
740                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
741                 return;
742         }
743         if (ret == -ENODEV)
744                 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
745         else if (cdev->handler)
746                 cdev->handler(cdev, cdev->private->intparm,
747                               ERR_PTR(-ETIMEDOUT));
748 }
749
750 /*
751  * Got an interrupt for a basic sense.
752  */
753 static void
754 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
755 {
756         struct irb *irb;
757
758         irb = (struct irb *) __LC_IRB;
759         /* Check for unsolicited interrupt. */
760         if (scsw_stctl(&irb->scsw) ==
761             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
762                 if (scsw_cc(&irb->scsw) == 1)
763                         /* Basic sense hasn't started. Try again. */
764                         ccw_device_do_sense(cdev, irb);
765                 else {
766                         CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
767                                       "interrupt during w4sense...\n",
768                                       cdev->private->dev_id.ssid,
769                                       cdev->private->dev_id.devno);
770                         if (cdev->handler)
771                                 cdev->handler (cdev, 0, irb);
772                 }
773                 return;
774         }
775         /*
776          * Check if a halt or clear has been issued in the meanwhile. If yes,
777          * only deliver the halt/clear interrupt to the device driver as if it
778          * had killed the original request.
779          */
780         if (scsw_fctl(&irb->scsw) &
781             (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
782                 cdev->private->flags.dosense = 0;
783                 memset(&cdev->private->irb, 0, sizeof(struct irb));
784                 ccw_device_accumulate_irb(cdev, irb);
785                 goto call_handler;
786         }
787         /* Add basic sense info to irb. */
788         ccw_device_accumulate_basic_sense(cdev, irb);
789         if (cdev->private->flags.dosense) {
790                 /* Another basic sense is needed. */
791                 ccw_device_do_sense(cdev, irb);
792                 return;
793         }
794 call_handler:
795         cdev->private->state = DEV_STATE_ONLINE;
796         /* In case sensing interfered with setting the device online */
797         wake_up(&cdev->private->wait_q);
798         /* Call the handler. */
799         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
800                 /* Start delayed path verification. */
801                 ccw_device_online_verify(cdev, 0);
802 }
803
804 static void
805 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
806 {
807         struct subchannel *sch;
808
809         sch = to_subchannel(cdev->dev.parent);
810         ccw_device_set_timeout(cdev, 0);
811         /* Start delayed path verification. */
812         ccw_device_online_verify(cdev, 0);
813         /* OK, i/o is dead now. Call interrupt handler. */
814         if (cdev->handler)
815                 cdev->handler(cdev, cdev->private->intparm,
816                               ERR_PTR(-EIO));
817 }
818
819 static void
820 ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
821 {
822         int ret;
823
824         ret = ccw_device_cancel_halt_clear(cdev);
825         if (ret == -EBUSY) {
826                 ccw_device_set_timeout(cdev, 3*HZ);
827                 return;
828         }
829         /* Start delayed path verification. */
830         ccw_device_online_verify(cdev, 0);
831         if (cdev->handler)
832                 cdev->handler(cdev, cdev->private->intparm,
833                               ERR_PTR(-EIO));
834 }
835
836 void ccw_device_kill_io(struct ccw_device *cdev)
837 {
838         int ret;
839
840         ret = ccw_device_cancel_halt_clear(cdev);
841         if (ret == -EBUSY) {
842                 ccw_device_set_timeout(cdev, 3*HZ);
843                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
844                 return;
845         }
846         /* Start delayed path verification. */
847         ccw_device_online_verify(cdev, 0);
848         if (cdev->handler)
849                 cdev->handler(cdev, cdev->private->intparm,
850                               ERR_PTR(-EIO));
851 }
852
853 static void
854 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
855 {
856         /* Start verification after current task finished. */
857         cdev->private->flags.doverify = 1;
858 }
859
860 static void
861 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
862 {
863         struct subchannel *sch;
864
865         sch = to_subchannel(cdev->dev.parent);
866         if (cio_enable_subchannel(sch, (u32)(addr_t)sch) != 0)
867                 /* Couldn't enable the subchannel for i/o. Sick device. */
868                 return;
869         cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
870         ccw_device_sense_id_start(cdev);
871 }
872
873 void ccw_device_trigger_reprobe(struct ccw_device *cdev)
874 {
875         struct subchannel *sch;
876
877         if (cdev->private->state != DEV_STATE_DISCONNECTED)
878                 return;
879
880         sch = to_subchannel(cdev->dev.parent);
881         /* Update some values. */
882         if (cio_update_schib(sch))
883                 return;
884         /*
885          * The pim, pam, pom values may not be accurate, but they are the best
886          * we have before performing device selection :/
887          */
888         sch->lpm = sch->schib.pmcw.pam & sch->opm;
889         /*
890          * Use the initial configuration since we can't be shure that the old
891          * paths are valid.
892          */
893         io_subchannel_init_config(sch);
894         if (cio_commit_config(sch))
895                 return;
896
897         /* We should also udate ssd info, but this has to wait. */
898         /* Check if this is another device which appeared on the same sch. */
899         if (sch->schib.pmcw.dev != cdev->private->dev_id.devno)
900                 css_schedule_eval(sch->schid);
901         else
902                 ccw_device_start_id(cdev, 0);
903 }
904
905 static void ccw_device_disabled_irq(struct ccw_device *cdev,
906                                     enum dev_event dev_event)
907 {
908         struct subchannel *sch;
909
910         sch = to_subchannel(cdev->dev.parent);
911         /*
912          * An interrupt in a disabled state means a previous disable was not
913          * successful - should not happen, but we try to disable again.
914          */
915         cio_disable_subchannel(sch);
916 }
917
918 static void
919 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
920 {
921         retry_set_schib(cdev);
922         cdev->private->state = DEV_STATE_ONLINE;
923         dev_fsm_event(cdev, dev_event);
924 }
925
926 static void ccw_device_update_cmfblock(struct ccw_device *cdev,
927                                        enum dev_event dev_event)
928 {
929         cmf_retry_copy_block(cdev);
930         cdev->private->state = DEV_STATE_ONLINE;
931         dev_fsm_event(cdev, dev_event);
932 }
933
934 static void
935 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
936 {
937         ccw_device_set_timeout(cdev, 0);
938         cdev->private->state = DEV_STATE_NOT_OPER;
939         wake_up(&cdev->private->wait_q);
940 }
941
942 static void
943 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
944 {
945         int ret;
946
947         ret = ccw_device_cancel_halt_clear(cdev);
948         if (ret == -EBUSY) {
949                 ccw_device_set_timeout(cdev, HZ/10);
950         } else {
951                 cdev->private->state = DEV_STATE_NOT_OPER;
952                 wake_up(&cdev->private->wait_q);
953         }
954 }
955
956 /*
957  * No operation action. This is used e.g. to ignore a timeout event in
958  * state offline.
959  */
960 static void
961 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
962 {
963 }
964
965 /*
966  * device statemachine
967  */
968 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
969         [DEV_STATE_NOT_OPER] = {
970                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
971                 [DEV_EVENT_INTERRUPT]   = ccw_device_disabled_irq,
972                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
973                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
974         },
975         [DEV_STATE_SENSE_PGID] = {
976                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
977                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
978                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
979                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
980         },
981         [DEV_STATE_SENSE_ID] = {
982                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
983                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
984                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
985                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
986         },
987         [DEV_STATE_OFFLINE] = {
988                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
989                 [DEV_EVENT_INTERRUPT]   = ccw_device_disabled_irq,
990                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
991                 [DEV_EVENT_VERIFY]      = ccw_device_offline_verify,
992         },
993         [DEV_STATE_VERIFY] = {
994                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
995                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
996                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
997                 [DEV_EVENT_VERIFY]      = ccw_device_delay_verify,
998         },
999         [DEV_STATE_ONLINE] = {
1000                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1001                 [DEV_EVENT_INTERRUPT]   = ccw_device_irq,
1002                 [DEV_EVENT_TIMEOUT]     = ccw_device_online_timeout,
1003                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1004         },
1005         [DEV_STATE_W4SENSE] = {
1006                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1007                 [DEV_EVENT_INTERRUPT]   = ccw_device_w4sense,
1008                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1009                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1010         },
1011         [DEV_STATE_DISBAND_PGID] = {
1012                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1013                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1014                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1015                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1016         },
1017         [DEV_STATE_BOXED] = {
1018                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1019                 [DEV_EVENT_INTERRUPT]   = ccw_device_nop,
1020                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1021                 [DEV_EVENT_VERIFY]      = ccw_device_boxed_verify,
1022         },
1023         /* states to wait for i/o completion before doing something */
1024         [DEV_STATE_TIMEOUT_KILL] = {
1025                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1026                 [DEV_EVENT_INTERRUPT]   = ccw_device_killing_irq,
1027                 [DEV_EVENT_TIMEOUT]     = ccw_device_killing_timeout,
1028                 [DEV_EVENT_VERIFY]      = ccw_device_nop, //FIXME
1029         },
1030         [DEV_STATE_QUIESCE] = {
1031                 [DEV_EVENT_NOTOPER]     = ccw_device_quiesce_done,
1032                 [DEV_EVENT_INTERRUPT]   = ccw_device_quiesce_done,
1033                 [DEV_EVENT_TIMEOUT]     = ccw_device_quiesce_timeout,
1034                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1035         },
1036         /* special states for devices gone not operational */
1037         [DEV_STATE_DISCONNECTED] = {
1038                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1039                 [DEV_EVENT_INTERRUPT]   = ccw_device_start_id,
1040                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1041                 [DEV_EVENT_VERIFY]      = ccw_device_start_id,
1042         },
1043         [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1044                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1045                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1046                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1047                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1048         },
1049         [DEV_STATE_CMFCHANGE] = {
1050                 [DEV_EVENT_NOTOPER]     = ccw_device_change_cmfstate,
1051                 [DEV_EVENT_INTERRUPT]   = ccw_device_change_cmfstate,
1052                 [DEV_EVENT_TIMEOUT]     = ccw_device_change_cmfstate,
1053                 [DEV_EVENT_VERIFY]      = ccw_device_change_cmfstate,
1054         },
1055         [DEV_STATE_CMFUPDATE] = {
1056                 [DEV_EVENT_NOTOPER]     = ccw_device_update_cmfblock,
1057                 [DEV_EVENT_INTERRUPT]   = ccw_device_update_cmfblock,
1058                 [DEV_EVENT_TIMEOUT]     = ccw_device_update_cmfblock,
1059                 [DEV_EVENT_VERIFY]      = ccw_device_update_cmfblock,
1060         },
1061         [DEV_STATE_STEAL_LOCK] = {
1062                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1063                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1064                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1065                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1066         },
1067 };
1068
1069 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);