drivers/s390/cio/device_fsm.c

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