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