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         ccw_device_set_timeout(cdev, 0);
 233         cio_disable_subchannel(sch);
 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                 CIO_MSG_EVENT(2, "SenseID : unknown device %04x on "
 267                               "subchannel 0.%x.%04x\n",
 268                               cdev->private->dev_id.devno,
 269                               sch->schid.ssid, sch->schid.sch_no);
 270                 break;
 271         case DEV_STATE_OFFLINE:
 272                 if (!cdev->online) {
 273                         ccw_device_update_sense_data(cdev);
 274                         /* Issue device info message. */
 275                         CIO_MSG_EVENT(4, "SenseID : device 0.%x.%04x reports: "
 276                                       "CU  Type/Mod = %04X/%02X, Dev Type/Mod "
 277                                       "= %04X/%02X\n",
 278                                       cdev->private->dev_id.ssid,
 279                                       cdev->private->dev_id.devno,
 280                                       cdev->id.cu_type, cdev->id.cu_model,
 281                                       cdev->id.dev_type, cdev->id.dev_model);
 282                         break;
 283                 }
 284                 cdev->private->state = DEV_STATE_OFFLINE;
 285                 cdev->private->flags.recog_done = 1;
 286                 if (ccw_device_test_sense_data(cdev)) {
 287                         cdev->private->flags.donotify = 1;
 288                         ccw_device_online(cdev);
 289                         wake_up(&cdev->private->wait_q);
 290                 } else {
 291                         ccw_device_update_sense_data(cdev);
 292                         ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
 293                 }
 294                 return;
 295         case DEV_STATE_BOXED:
 296                 CIO_MSG_EVENT(0, "SenseID : boxed device %04x on "
 297                               " subchannel 0.%x.%04x\n",
 298                               cdev->private->dev_id.devno,
 299                               sch->schid.ssid, sch->schid.sch_no);
 300                 if (cdev->id.cu_type != 0) { /* device was recognized before */
 301                         cdev->private->flags.recog_done = 1;
 302                         cdev->private->state = DEV_STATE_BOXED;
 303                         wake_up(&cdev->private->wait_q);
 304                         return;
 305                 }
 306                 break;
 307         }
 308         cdev->private->state = state;
 309         io_subchannel_recog_done(cdev);
 310         wake_up(&cdev->private->wait_q);
 311 }
 312
 313 /*
 314  * Function called from device_id.c after sense id has completed.
 315  */
 316 void
 317 ccw_device_sense_id_done(struct ccw_device *cdev, int err)
 318 {
 319         switch (err) {
 320         case 0:
 321                 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
 322                 break;
 323         case -ETIME:            /* Sense id stopped by timeout. */
 324                 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
 325                 break;
 326         default:
 327                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
 328                 break;
 329         }
 330 }
 331
 332 int ccw_device_notify(struct ccw_device *cdev, int event)
 333 {
 334         if (!cdev->drv)
 335                 return 0;
 336         if (!cdev->online)
 337                 return 0;
 338         CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
 339                       cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
 340                       event);
 341         return cdev->drv->notify ? cdev->drv->notify(cdev, event) : 0;
 342 }
 343
 344 static void ccw_device_oper_notify(struct ccw_device *cdev)
 345 {
 346         if (ccw_device_notify(cdev, CIO_OPER)) {
 347                 /* Reenable channel measurements, if needed. */
 348                 ccw_device_sched_todo(cdev, CDEV_TODO_ENABLE_CMF);
 349                 return;
 350         }
 351         /* Driver doesn't want device back. */
 352         ccw_device_set_notoper(cdev);
 353         ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
 354 }
 355
 356 /*
 357  * Finished with online/offline processing.
 358  */
 359 static void
 360 ccw_device_done(struct ccw_device *cdev, int state)
 361 {
 362         struct subchannel *sch;
 363
 364         sch = to_subchannel(cdev->dev.parent);
 365
 366         ccw_device_set_timeout(cdev, 0);
 367
 368         if (state != DEV_STATE_ONLINE)
 369                 cio_disable_subchannel(sch);
 370
 371         /* Reset device status. */
 372         memset(&cdev->private->irb, 0, sizeof(struct irb));
 373
 374         cdev->private->state = state;
 375
 376         switch (state) {
 377         case DEV_STATE_BOXED:
 378                 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
 379                               cdev->private->dev_id.devno, sch->schid.sch_no);
 380                 if (cdev->online && !ccw_device_notify(cdev, CIO_BOXED))
 381                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 382                 cdev->private->flags.donotify = 0;
 383                 break;
 384         case DEV_STATE_NOT_OPER:
 385                 CIO_MSG_EVENT(0, "Device %04x gone on subchannel %04x\n",
 386                               cdev->private->dev_id.devno, sch->schid.sch_no);
 387                 if (!ccw_device_notify(cdev, CIO_GONE))
 388                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 389                 else
 390                         ccw_device_set_disconnected(cdev);
 391                 cdev->private->flags.donotify = 0;
 392                 break;
 393         case DEV_STATE_DISCONNECTED:
 394                 CIO_MSG_EVENT(0, "Disconnected device %04x on subchannel "
 395                               "%04x\n", cdev->private->dev_id.devno,
 396                               sch->schid.sch_no);
 397                 if (!ccw_device_notify(cdev, CIO_NO_PATH))
 398                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 399                 else
 400                         ccw_device_set_disconnected(cdev);
 401                 cdev->private->flags.donotify = 0;
 402                 break;
 403         default:
 404                 break;
 405         }
 406
 407         if (cdev->private->flags.donotify) {
 408                 cdev->private->flags.donotify = 0;
 409                 ccw_device_oper_notify(cdev);
 410         }
 411         wake_up(&cdev->private->wait_q);
 412 }
 413
 414 static int cmp_pgid(struct pgid *p1, struct pgid *p2)
 415 {
 416         char *c1;
 417         char *c2;
 418
 419         c1 = (char *)p1;
 420         c2 = (char *)p2;
 421
 422         return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
 423 }
 424
 425 static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
 426 {
 427         int i;
 428         int last;
 429
 430         last = 0;
 431         for (i = 0; i < 8; i++) {
 432                 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
 433                         /* No PGID yet */
 434                         continue;
 435                 if (cdev->private->pgid[last].inf.ps.state1 ==
 436                     SNID_STATE1_RESET) {
 437                         /* First non-zero PGID */
 438                         last = i;
 439                         continue;
 440                 }
 441                 if (cmp_pgid(&cdev->private->pgid[i],
 442                              &cdev->private->pgid[last]) == 0)
 443                         /* Non-conflicting PGIDs */
 444                         continue;
 445
 446                 /* PGID mismatch, can't pathgroup. */
 447                 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
 448                               "0.%x.%04x, can't pathgroup\n",
 449                               cdev->private->dev_id.ssid,
 450                               cdev->private->dev_id.devno);
 451                 cdev->private->options.pgroup = 0;
 452                 return;
 453         }
 454         if (cdev->private->pgid[last].inf.ps.state1 ==
 455             SNID_STATE1_RESET)
 456                 /* No previous pgid found */
 457                 memcpy(&cdev->private->pgid[0],
 458                        &channel_subsystems[0]->global_pgid,
 459                        sizeof(struct pgid));
 460         else
 461                 /* Use existing pgid */
 462                 memcpy(&cdev->private->pgid[0], &cdev->private->pgid[last],
 463                        sizeof(struct pgid));
 464 }
 465
 466 /*
 467  * Function called from device_pgid.c after sense path ground has completed.
 468  */
 469 void
 470 ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
 471 {
 472         struct subchannel *sch;
 473
 474         sch = to_subchannel(cdev->dev.parent);
 475         switch (err) {
 476         case -EOPNOTSUPP: /* path grouping not supported, use nop instead. */
 477                 cdev->private->options.pgroup = 0;
 478                 break;
 479         case 0: /* success */
 480         case -EACCES: /* partial success, some paths not operational */
 481                 /* Check if all pgids are equal or 0. */
 482                 __ccw_device_get_common_pgid(cdev);
 483                 break;
 484         case -ETIME:            /* Sense path group id stopped by timeout. */
 485         case -EUSERS:           /* device is reserved for someone else. */
 486                 ccw_device_done(cdev, DEV_STATE_BOXED);
 487                 return;
 488         default:
 489                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 490                 return;
 491         }
 492         /* Start Path Group verification. */
 493         cdev->private->state = DEV_STATE_VERIFY;
 494         cdev->private->flags.doverify = 0;
 495         ccw_device_verify_start(cdev);
 496 }
 497
 498 /*
 499  * Start device recognition.
 500  */
 501 void ccw_device_recognition(struct ccw_device *cdev)
 502 {
 503         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 504
 505         /*
 506          * We used to start here with a sense pgid to find out whether a device
 507          * is locked by someone else. Unfortunately, the sense pgid command
 508          * code has other meanings on devices predating the path grouping
 509          * algorithm, so we start with sense id and box the device after an
 510          * timeout (or if sense pgid during path verification detects the device
 511          * is locked, as may happen on newer devices).
 512          */
 513         cdev->private->flags.recog_done = 0;
 514         cdev->private->state = DEV_STATE_SENSE_ID;
 515         if (cio_enable_subchannel(sch, (u32) (addr_t) sch)) {
 516                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
 517                 return;
 518         }
 519         ccw_device_sense_id_start(cdev);
 520 }
 521
 522 /*
 523  * Handle timeout in device recognition.
 524  */
 525 static void
 526 ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 527 {
 528         int ret;
 529
 530         ret = ccw_device_cancel_halt_clear(cdev);
 531         switch (ret) {
 532         case 0:
 533                 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
 534                 break;
 535         case -ENODEV:
 536                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
 537                 break;
 538         default:
 539                 ccw_device_set_timeout(cdev, 3*HZ);
 540         }
 541 }
 542
 543
 544 void
 545 ccw_device_verify_done(struct ccw_device *cdev, int err)
 546 {
 547         struct subchannel *sch;
 548
 549         sch = to_subchannel(cdev->dev.parent);
 550         /* Update schib - pom may have changed. */
 551         if (cio_update_schib(sch)) {
 552                 err = -ENODEV;
 553                 goto callback;
 554         }
 555         /* Update lpm with verified path mask. */
 556         sch->lpm = sch->vpm;
 557         /* Repeat path verification? */
 558         if (cdev->private->flags.doverify) {
 559                 cdev->private->flags.doverify = 0;
 560                 ccw_device_verify_start(cdev);
 561                 return;
 562         }
 563 callback:
 564         switch (err) {
 565         case 0:
 566                 ccw_device_done(cdev, DEV_STATE_ONLINE);
 567                 /* Deliver fake irb to device driver, if needed. */
 568                 if (cdev->private->flags.fake_irb) {
 569                         memset(&cdev->private->irb, 0, sizeof(struct irb));
 570                         cdev->private->irb.scsw.cmd.cc = 1;
 571                         cdev->private->irb.scsw.cmd.fctl = SCSW_FCTL_START_FUNC;
 572                         cdev->private->irb.scsw.cmd.actl = SCSW_ACTL_START_PEND;
 573                         cdev->private->irb.scsw.cmd.stctl =
 574                                 SCSW_STCTL_STATUS_PEND;
 575                         cdev->private->flags.fake_irb = 0;
 576                         if (cdev->handler)
 577                                 cdev->handler(cdev, cdev->private->intparm,
 578                                               &cdev->private->irb);
 579                         memset(&cdev->private->irb, 0, sizeof(struct irb));
 580                 }
 581                 break;
 582         case -ETIME:
 583                 /* Reset oper notify indication after verify error. */
 584                 cdev->private->flags.donotify = 0;
 585                 ccw_device_done(cdev, DEV_STATE_BOXED);
 586                 break;
 587         case -EACCES:
 588                 /* Reset oper notify indication after verify error. */
 589                 cdev->private->flags.donotify = 0;
 590                 ccw_device_done(cdev, DEV_STATE_DISCONNECTED);
 591                 break;
 592         default:
 593                 /* Reset oper notify indication after verify error. */
 594                 cdev->private->flags.donotify = 0;
 595                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 596                 break;
 597         }
 598 }
 599
 600 /*
 601  * Get device online.
 602  */
 603 int
 604 ccw_device_online(struct ccw_device *cdev)
 605 {
 606         struct subchannel *sch;
 607         int ret;
 608
 609         if ((cdev->private->state != DEV_STATE_OFFLINE) &&
 610             (cdev->private->state != DEV_STATE_BOXED))
 611                 return -EINVAL;
 612         sch = to_subchannel(cdev->dev.parent);
 613         ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
 614         if (ret != 0) {
 615                 /* Couldn't enable the subchannel for i/o. Sick device. */
 616                 if (ret == -ENODEV)
 617                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
 618                 return ret;
 619         }
 620         /* Do we want to do path grouping? */
 621         if (!cdev->private->options.pgroup) {
 622                 /* Start initial path verification. */
 623                 cdev->private->state = DEV_STATE_VERIFY;
 624                 cdev->private->flags.doverify = 0;
 625                 ccw_device_verify_start(cdev);
 626                 return 0;
 627         }
 628         /* Do a SensePGID first. */
 629         cdev->private->state = DEV_STATE_SENSE_PGID;
 630         ccw_device_sense_pgid_start(cdev);
 631         return 0;
 632 }
 633
 634 void
 635 ccw_device_disband_done(struct ccw_device *cdev, int err)
 636 {
 637         switch (err) {
 638         case 0:
 639                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
 640                 break;
 641         case -ETIME:
 642                 ccw_device_done(cdev, DEV_STATE_BOXED);
 643                 break;
 644         default:
 645                 cdev->private->flags.donotify = 0;
 646                 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
 647                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 648                 break;
 649         }
 650 }
 651
 652 /*
 653  * Shutdown device.
 654  */
 655 int
 656 ccw_device_offline(struct ccw_device *cdev)
 657 {
 658         struct subchannel *sch;
 659
 660         /* Allow ccw_device_offline while disconnected. */
 661         if (cdev->private->state == DEV_STATE_DISCONNECTED ||
 662             cdev->private->state == DEV_STATE_NOT_OPER) {
 663                 cdev->private->flags.donotify = 0;
 664                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 665                 return 0;
 666         }
 667         if (cdev->private->state == DEV_STATE_BOXED) {
 668                 ccw_device_done(cdev, DEV_STATE_BOXED);
 669                 return 0;
 670         }
 671         if (ccw_device_is_orphan(cdev)) {
 672                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
 673                 return 0;
 674         }
 675         sch = to_subchannel(cdev->dev.parent);
 676         if (cio_update_schib(sch))
 677                 return -ENODEV;
 678         if (scsw_actl(&sch->schib.scsw) != 0)
 679                 return -EBUSY;
 680         if (cdev->private->state != DEV_STATE_ONLINE)
 681                 return -EINVAL;
 682         /* Are we doing path grouping? */
 683         if (!cdev->private->options.pgroup) {
 684                 /* No, set state offline immediately. */
 685                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
 686                 return 0;
 687         }
 688         /* Start Set Path Group commands. */
 689         cdev->private->state = DEV_STATE_DISBAND_PGID;
 690         ccw_device_disband_start(cdev);
 691         return 0;
 692 }
 693
 694 /*
 695  * Handle timeout in device online/offline process.
 696  */
 697 static void
 698 ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 699 {
 700         int ret;
 701
 702         ret = ccw_device_cancel_halt_clear(cdev);
 703         switch (ret) {
 704         case 0:
 705                 ccw_device_done(cdev, DEV_STATE_BOXED);
 706                 break;
 707         case -ENODEV:
 708                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 709                 break;
 710         default:
 711                 ccw_device_set_timeout(cdev, 3*HZ);
 712         }
 713 }
 714
 715 /*
 716  * Handle not oper event in device recognition.
 717  */
 718 static void
 719 ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
 720 {
 721         ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
 722 }
 723
 724 /*
 725  * Handle not operational event in non-special state.
 726  */
 727 static void ccw_device_generic_notoper(struct ccw_device *cdev,
 728                                        enum dev_event dev_event)
 729 {
 730         if (!ccw_device_notify(cdev, CIO_GONE))
 731                 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 732         else
 733                 ccw_device_set_disconnected(cdev);
 734 }
 735
 736 /*
 737  * Handle path verification event in offline state.
 738  */
 739 static void ccw_device_offline_verify(struct ccw_device *cdev,
 740                                       enum dev_event dev_event)
 741 {
 742         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 743
 744         css_schedule_eval(sch->schid);
 745 }
 746
 747 /*
 748  * Handle path verification event.
 749  */
 750 static void
 751 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
 752 {
 753         struct subchannel *sch;
 754
 755         if (cdev->private->state == DEV_STATE_W4SENSE) {
 756                 cdev->private->flags.doverify = 1;
 757                 return;
 758         }
 759         sch = to_subchannel(cdev->dev.parent);
 760         /*
 761          * Since we might not just be coming from an interrupt from the
 762          * subchannel we have to update the schib.
 763          */
 764         if (cio_update_schib(sch)) {
 765                 ccw_device_verify_done(cdev, -ENODEV);
 766                 return;
 767         }
 768
 769         if (scsw_actl(&sch->schib.scsw) != 0 ||
 770             (scsw_stctl(&sch->schib.scsw) & SCSW_STCTL_STATUS_PEND) ||
 771             (scsw_stctl(&cdev->private->irb.scsw) & SCSW_STCTL_STATUS_PEND)) {
 772                 /*
 773                  * No final status yet or final status not yet delivered
 774                  * to the device driver. Can't do path verfication now,
 775                  * delay until final status was delivered.
 776                  */
 777                 cdev->private->flags.doverify = 1;
 778                 return;
 779         }
 780         /* Device is idle, we can do the path verification. */
 781         cdev->private->state = DEV_STATE_VERIFY;
 782         cdev->private->flags.doverify = 0;
 783         ccw_device_verify_start(cdev);
 784 }
 785
 786 /*
 787  * Got an interrupt for a normal io (state online).
 788  */
 789 static void
 790 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
 791 {
 792         struct irb *irb;
 793         int is_cmd;
 794
 795         irb = (struct irb *) __LC_IRB;
 796         is_cmd = !scsw_is_tm(&irb->scsw);
 797         /* Check for unsolicited interrupt. */
 798         if (!scsw_is_solicited(&irb->scsw)) {
 799                 if (is_cmd && (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
 800                     !irb->esw.esw0.erw.cons) {
 801                         /* Unit check but no sense data. Need basic sense. */
 802                         if (ccw_device_do_sense(cdev, irb) != 0)
 803                                 goto call_handler_unsol;
 804                         memcpy(&cdev->private->irb, irb, sizeof(struct irb));
 805                         cdev->private->state = DEV_STATE_W4SENSE;
 806                         cdev->private->intparm = 0;
 807                         return;
 808                 }
 809 call_handler_unsol:
 810                 if (cdev->handler)
 811                         cdev->handler (cdev, 0, irb);
 812                 if (cdev->private->flags.doverify)
 813                         ccw_device_online_verify(cdev, 0);
 814                 return;
 815         }
 816         /* Accumulate status and find out if a basic sense is needed. */
 817         ccw_device_accumulate_irb(cdev, irb);
 818         if (is_cmd && cdev->private->flags.dosense) {
 819                 if (ccw_device_do_sense(cdev, irb) == 0) {
 820                         cdev->private->state = DEV_STATE_W4SENSE;
 821                 }
 822                 return;
 823         }
 824         /* Call the handler. */
 825         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
 826                 /* Start delayed path verification. */
 827                 ccw_device_online_verify(cdev, 0);
 828 }
 829
 830 /*
 831  * Got an timeout in online state.
 832  */
 833 static void
 834 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 835 {
 836         int ret;
 837
 838         ccw_device_set_timeout(cdev, 0);
 839         ret = ccw_device_cancel_halt_clear(cdev);
 840         if (ret == -EBUSY) {
 841                 ccw_device_set_timeout(cdev, 3*HZ);
 842                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
 843                 return;
 844         }
 845         if (ret == -ENODEV)
 846                 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
 847         else if (cdev->handler)
 848                 cdev->handler(cdev, cdev->private->intparm,
 849                               ERR_PTR(-ETIMEDOUT));
 850 }
 851
 852 /*
 853  * Got an interrupt for a basic sense.
 854  */
 855 static void
 856 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
 857 {
 858         struct irb *irb;
 859
 860         irb = (struct irb *) __LC_IRB;
 861         /* Check for unsolicited interrupt. */
 862         if (scsw_stctl(&irb->scsw) ==
 863             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
 864                 if (scsw_cc(&irb->scsw) == 1)
 865                         /* Basic sense hasn't started. Try again. */
 866                         ccw_device_do_sense(cdev, irb);
 867                 else {
 868                         CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
 869                                       "interrupt during w4sense...\n",
 870                                       cdev->private->dev_id.ssid,
 871                                       cdev->private->dev_id.devno);
 872                         if (cdev->handler)
 873                                 cdev->handler (cdev, 0, irb);
 874                 }
 875                 return;
 876         }
 877         /*
 878          * Check if a halt or clear has been issued in the meanwhile. If yes,
 879          * only deliver the halt/clear interrupt to the device driver as if it
 880          * had killed the original request.
 881          */
 882         if (scsw_fctl(&irb->scsw) &
 883             (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
 884                 /* Retry Basic Sense if requested. */
 885                 if (cdev->private->flags.intretry) {
 886                         cdev->private->flags.intretry = 0;
 887                         ccw_device_do_sense(cdev, irb);
 888                         return;
 889                 }
 890                 cdev->private->flags.dosense = 0;
 891                 memset(&cdev->private->irb, 0, sizeof(struct irb));
 892                 ccw_device_accumulate_irb(cdev, irb);
 893                 goto call_handler;
 894         }
 895         /* Add basic sense info to irb. */
 896         ccw_device_accumulate_basic_sense(cdev, irb);
 897         if (cdev->private->flags.dosense) {
 898                 /* Another basic sense is needed. */
 899                 ccw_device_do_sense(cdev, irb);
 900                 return;
 901         }
 902 call_handler:
 903         cdev->private->state = DEV_STATE_ONLINE;
 904         /* In case sensing interfered with setting the device online */
 905         wake_up(&cdev->private->wait_q);
 906         /* Call the handler. */
 907         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
 908                 /* Start delayed path verification. */
 909                 ccw_device_online_verify(cdev, 0);
 910 }
 911
 912 static void
 913 ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
 914 {
 915         struct irb *irb;
 916
 917         irb = (struct irb *) __LC_IRB;
 918         /* Accumulate status. We don't do basic sense. */
 919         ccw_device_accumulate_irb(cdev, irb);
 920         /* Remember to clear irb to avoid residuals. */
 921         memset(&cdev->private->irb, 0, sizeof(struct irb));
 922         /* Try to start delayed device verification. */
 923         ccw_device_online_verify(cdev, 0);
 924         /* Note: Don't call handler for cio initiated clear! */
 925 }
 926
 927 static void
 928 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
 929 {
 930         struct subchannel *sch;
 931
 932         sch = to_subchannel(cdev->dev.parent);
 933         ccw_device_set_timeout(cdev, 0);
 934         /* Start delayed path verification. */
 935         ccw_device_online_verify(cdev, 0);
 936         /* OK, i/o is dead now. Call interrupt handler. */
 937         if (cdev->handler)
 938                 cdev->handler(cdev, cdev->private->intparm,
 939                               ERR_PTR(-EIO));
 940 }
 941
 942 static void
 943 ccw_device_killing_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, 3*HZ);
 950                 return;
 951         }
 952         /* Start delayed path verification. */
 953         ccw_device_online_verify(cdev, 0);
 954         if (cdev->handler)
 955                 cdev->handler(cdev, cdev->private->intparm,
 956                               ERR_PTR(-EIO));
 957 }
 958
 959 void ccw_device_kill_io(struct ccw_device *cdev)
 960 {
 961         int ret;
 962
 963         ret = ccw_device_cancel_halt_clear(cdev);
 964         if (ret == -EBUSY) {
 965                 ccw_device_set_timeout(cdev, 3*HZ);
 966                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
 967                 return;
 968         }
 969         /* Start delayed path verification. */
 970         ccw_device_online_verify(cdev, 0);
 971         if (cdev->handler)
 972                 cdev->handler(cdev, cdev->private->intparm,
 973                               ERR_PTR(-EIO));
 974 }
 975
 976 static void
 977 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
 978 {
 979         /* Start verification after current task finished. */
 980         cdev->private->flags.doverify = 1;
 981 }
 982
 983 static void
 984 ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
 985 {
 986         struct irb *irb;
 987
 988         switch (dev_event) {
 989         case DEV_EVENT_INTERRUPT:
 990                 irb = (struct irb *) __LC_IRB;
 991                 /* Check for unsolicited interrupt. */
 992                 if ((scsw_stctl(&irb->scsw) ==
 993                      (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
 994                     (!scsw_cc(&irb->scsw)))
 995                         /* FIXME: we should restart stlck here, but this
 996                          * is extremely unlikely ... */
 997                         goto out_wakeup;
 998
 999                 ccw_device_accumulate_irb(cdev, irb);
1000                 /* We don't care about basic sense etc. */
1001                 break;
1002         default: /* timeout */
1003                 break;
1004         }
1005 out_wakeup:
1006         wake_up(&cdev->private->wait_q);
1007 }
1008
1009 static void
1010 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
1011 {
1012         struct subchannel *sch;
1013
1014         sch = to_subchannel(cdev->dev.parent);
1015         if (cio_enable_subchannel(sch, (u32)(addr_t)sch) != 0)
1016                 /* Couldn't enable the subchannel for i/o. Sick device. */
1017                 return;
1018
1019         /* After 60s the device recognition is considered to have failed. */
1020         ccw_device_set_timeout(cdev, 60*HZ);
1021
1022         cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
1023         ccw_device_sense_id_start(cdev);
1024 }
1025
1026 void ccw_device_trigger_reprobe(struct ccw_device *cdev)
1027 {
1028         struct subchannel *sch;
1029
1030         if (cdev->private->state != DEV_STATE_DISCONNECTED)
1031                 return;
1032
1033         sch = to_subchannel(cdev->dev.parent);
1034         /* Update some values. */
1035         if (cio_update_schib(sch))
1036                 return;
1037         /*
1038          * The pim, pam, pom values may not be accurate, but they are the best
1039          * we have before performing device selection :/
1040          */
1041         sch->lpm = sch->schib.pmcw.pam & sch->opm;
1042         /*
1043          * Use the initial configuration since we can't be shure that the old
1044          * paths are valid.
1045          */
1046         io_subchannel_init_config(sch);
1047         if (cio_commit_config(sch))
1048                 return;
1049
1050         /* We should also udate ssd info, but this has to wait. */
1051         /* Check if this is another device which appeared on the same sch. */
1052         if (sch->schib.pmcw.dev != cdev->private->dev_id.devno)
1053                 css_schedule_eval(sch->schid);
1054         else
1055                 ccw_device_start_id(cdev, 0);
1056 }
1057
1058 static void
1059 ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
1060 {
1061         struct subchannel *sch;
1062
1063         sch = to_subchannel(cdev->dev.parent);
1064         /*
1065          * An interrupt in state offline means a previous disable was not
1066          * successful - should not happen, but we try to disable again.
1067          */
1068         cio_disable_subchannel(sch);
1069 }
1070
1071 static void
1072 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
1073 {
1074         retry_set_schib(cdev);
1075         cdev->private->state = DEV_STATE_ONLINE;
1076         dev_fsm_event(cdev, dev_event);
1077 }
1078
1079 static void ccw_device_update_cmfblock(struct ccw_device *cdev,
1080                                        enum dev_event dev_event)
1081 {
1082         cmf_retry_copy_block(cdev);
1083         cdev->private->state = DEV_STATE_ONLINE;
1084         dev_fsm_event(cdev, dev_event);
1085 }
1086
1087 static void
1088 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
1089 {
1090         ccw_device_set_timeout(cdev, 0);
1091         if (dev_event == DEV_EVENT_NOTOPER)
1092                 cdev->private->state = DEV_STATE_NOT_OPER;
1093         else
1094                 cdev->private->state = DEV_STATE_OFFLINE;
1095         wake_up(&cdev->private->wait_q);
1096 }
1097
1098 static void
1099 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1100 {
1101         int ret;
1102
1103         ret = ccw_device_cancel_halt_clear(cdev);
1104         switch (ret) {
1105         case 0:
1106                 cdev->private->state = DEV_STATE_OFFLINE;
1107                 wake_up(&cdev->private->wait_q);
1108                 break;
1109         case -ENODEV:
1110                 cdev->private->state = DEV_STATE_NOT_OPER;
1111                 wake_up(&cdev->private->wait_q);
1112                 break;
1113         default:
1114                 ccw_device_set_timeout(cdev, HZ/10);
1115         }
1116 }
1117
1118 /*
1119  * No operation action. This is used e.g. to ignore a timeout event in
1120  * state offline.
1121  */
1122 static void
1123 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1124 {
1125 }
1126
1127 /*
1128  * Bug operation action.
1129  */
1130 static void
1131 ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
1132 {
1133         CIO_MSG_EVENT(0, "Internal state [%i][%i] not handled for device "
1134                       "0.%x.%04x\n", cdev->private->state, dev_event,
1135                       cdev->private->dev_id.ssid,
1136                       cdev->private->dev_id.devno);
1137         BUG();
1138 }
1139
1140 /*
1141  * device statemachine
1142  */
1143 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
1144         [DEV_STATE_NOT_OPER] = {
1145                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1146                 [DEV_EVENT_INTERRUPT]   = ccw_device_bug,
1147                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1148                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1149         },
1150         [DEV_STATE_SENSE_PGID] = {
1151                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1152                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_pgid_irq,
1153                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
1154                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1155         },
1156         [DEV_STATE_SENSE_ID] = {
1157                 [DEV_EVENT_NOTOPER]     = ccw_device_recog_notoper,
1158                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_id_irq,
1159                 [DEV_EVENT_TIMEOUT]     = ccw_device_recog_timeout,
1160                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1161         },
1162         [DEV_STATE_OFFLINE] = {
1163                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1164                 [DEV_EVENT_INTERRUPT]   = ccw_device_offline_irq,
1165                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1166                 [DEV_EVENT_VERIFY]      = ccw_device_offline_verify,
1167         },
1168         [DEV_STATE_VERIFY] = {
1169                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1170                 [DEV_EVENT_INTERRUPT]   = ccw_device_verify_irq,
1171                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
1172                 [DEV_EVENT_VERIFY]      = ccw_device_delay_verify,
1173         },
1174         [DEV_STATE_ONLINE] = {
1175                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1176                 [DEV_EVENT_INTERRUPT]   = ccw_device_irq,
1177                 [DEV_EVENT_TIMEOUT]     = ccw_device_online_timeout,
1178                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1179         },
1180         [DEV_STATE_W4SENSE] = {
1181                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1182                 [DEV_EVENT_INTERRUPT]   = ccw_device_w4sense,
1183                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1184                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1185         },
1186         [DEV_STATE_DISBAND_PGID] = {
1187                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1188                 [DEV_EVENT_INTERRUPT]   = ccw_device_disband_irq,
1189                 [DEV_EVENT_TIMEOUT]     = ccw_device_onoff_timeout,
1190                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1191         },
1192         [DEV_STATE_BOXED] = {
1193                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1194                 [DEV_EVENT_INTERRUPT]   = ccw_device_stlck_done,
1195                 [DEV_EVENT_TIMEOUT]     = ccw_device_stlck_done,
1196                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1197         },
1198         /* states to wait for i/o completion before doing something */
1199         [DEV_STATE_CLEAR_VERIFY] = {
1200                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1201                 [DEV_EVENT_INTERRUPT]   = ccw_device_clear_verify,
1202                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1203                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1204         },
1205         [DEV_STATE_TIMEOUT_KILL] = {
1206                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1207                 [DEV_EVENT_INTERRUPT]   = ccw_device_killing_irq,
1208                 [DEV_EVENT_TIMEOUT]     = ccw_device_killing_timeout,
1209                 [DEV_EVENT_VERIFY]      = ccw_device_nop, //FIXME
1210         },
1211         [DEV_STATE_QUIESCE] = {
1212                 [DEV_EVENT_NOTOPER]     = ccw_device_quiesce_done,
1213                 [DEV_EVENT_INTERRUPT]   = ccw_device_quiesce_done,
1214                 [DEV_EVENT_TIMEOUT]     = ccw_device_quiesce_timeout,
1215                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1216         },
1217         /* special states for devices gone not operational */
1218         [DEV_STATE_DISCONNECTED] = {
1219                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1220                 [DEV_EVENT_INTERRUPT]   = ccw_device_start_id,
1221                 [DEV_EVENT_TIMEOUT]     = ccw_device_bug,
1222                 [DEV_EVENT_VERIFY]      = ccw_device_start_id,
1223         },
1224         [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1225                 [DEV_EVENT_NOTOPER]     = ccw_device_recog_notoper,
1226                 [DEV_EVENT_INTERRUPT]   = ccw_device_sense_id_irq,
1227                 [DEV_EVENT_TIMEOUT]     = ccw_device_recog_timeout,
1228                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1229         },
1230         [DEV_STATE_CMFCHANGE] = {
1231                 [DEV_EVENT_NOTOPER]     = ccw_device_change_cmfstate,
1232                 [DEV_EVENT_INTERRUPT]   = ccw_device_change_cmfstate,
1233                 [DEV_EVENT_TIMEOUT]     = ccw_device_change_cmfstate,
1234                 [DEV_EVENT_VERIFY]      = ccw_device_change_cmfstate,
1235         },
1236         [DEV_STATE_CMFUPDATE] = {
1237                 [DEV_EVENT_NOTOPER]     = ccw_device_update_cmfblock,
1238                 [DEV_EVENT_INTERRUPT]   = ccw_device_update_cmfblock,
1239                 [DEV_EVENT_TIMEOUT]     = ccw_device_update_cmfblock,
1240                 [DEV_EVENT_VERIFY]      = ccw_device_update_cmfblock,
1241         },
1242 };
1243
1244 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);