kernel/drivers/s390/cio/device_fsm.c

   1 /*
   2  * finite state machine for device handling
   3  *
   4  *    Copyright IBM Corp. 2002, 2008
   5  *    Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
   6  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/jiffies.h>
  12 #include <linux/string.h>
  13
  14 #include <asm/ccwdev.h>
  15 #include <asm/cio.h>
  16 #include <asm/chpid.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 #include "chp.h"
  25
  26 static int timeout_log_enabled;
  27
  28 static int __init ccw_timeout_log_setup(char *unused)
  29 {
  30         timeout_log_enabled = 1;
  31         return 1;
  32 }
  33
  34 __setup("ccw_timeout_log", ccw_timeout_log_setup);
  35
  36 static void ccw_timeout_log(struct ccw_device *cdev)
  37 {
  38         struct schib schib;
  39         struct subchannel *sch;
  40         struct io_subchannel_private *private;
  41         union orb *orb;
  42         int cc;
  43
  44         sch = to_subchannel(cdev->dev.parent);
  45         private = to_io_private(sch);
  46         orb = &private->orb;
  47         cc = stsch_err(sch->schid, &schib);
  48
  49         printk(KERN_WARNING "cio: ccw device timeout occurred at %llx, "
  50                "device information:\n", get_tod_clock());
  51         printk(KERN_WARNING "cio: orb:\n");
  52         print_hex_dump(KERN_WARNING, "cio:  ", DUMP_PREFIX_NONE, 16, 1,
  53                        orb, sizeof(*orb), 0);
  54         printk(KERN_WARNING "cio: ccw device bus id: %s\n",
  55                dev_name(&cdev->dev));
  56         printk(KERN_WARNING "cio: subchannel bus id: %s\n",
  57                dev_name(&sch->dev));
  58         printk(KERN_WARNING "cio: subchannel lpm: %02x, opm: %02x, "
  59                "vpm: %02x\n", sch->lpm, sch->opm, sch->vpm);
  60
  61         if (orb->tm.b) {
  62                 printk(KERN_WARNING "cio: orb indicates transport mode\n");
  63                 printk(KERN_WARNING "cio: last tcw:\n");
  64                 print_hex_dump(KERN_WARNING, "cio:  ", DUMP_PREFIX_NONE, 16, 1,
  65                                (void *)(addr_t)orb->tm.tcw,
  66                                sizeof(struct tcw), 0);
  67         } else {
  68                 printk(KERN_WARNING "cio: orb indicates command mode\n");
  69                 if ((void *)(addr_t)orb->cmd.cpa == &private->sense_ccw ||
  70                     (void *)(addr_t)orb->cmd.cpa == cdev->private->iccws)
  71                         printk(KERN_WARNING "cio: last channel program "
  72                                "(intern):\n");
  73                 else
  74                         printk(KERN_WARNING "cio: last channel program:\n");
  75
  76                 print_hex_dump(KERN_WARNING, "cio:  ", DUMP_PREFIX_NONE, 16, 1,
  77                                (void *)(addr_t)orb->cmd.cpa,
  78                                sizeof(struct ccw1), 0);
  79         }
  80         printk(KERN_WARNING "cio: ccw device state: %d\n",
  81                cdev->private->state);
  82         printk(KERN_WARNING "cio: store subchannel returned: cc=%d\n", cc);
  83         printk(KERN_WARNING "cio: schib:\n");
  84         print_hex_dump(KERN_WARNING, "cio:  ", DUMP_PREFIX_NONE, 16, 1,
  85                        &schib, sizeof(schib), 0);
  86         printk(KERN_WARNING "cio: ccw device flags:\n");
  87         print_hex_dump(KERN_WARNING, "cio:  ", DUMP_PREFIX_NONE, 16, 1,
  88                        &cdev->private->flags, sizeof(cdev->private->flags), 0);
  89 }
  90
  91 /*
  92  * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
  93  */
  94 static void
  95 ccw_device_timeout(unsigned long data)
  96 {
  97         struct ccw_device *cdev;
  98
  99         cdev = (struct ccw_device *) data;
 100         spin_lock_irq(cdev->ccwlock);
 101         if (timeout_log_enabled)
 102                 ccw_timeout_log(cdev);
 103         dev_fsm_event(cdev, DEV_EVENT_TIMEOUT);
 104         spin_unlock_irq(cdev->ccwlock);
 105 }
 106
 107 /*
 108  * Set timeout
 109  */
 110 void
 111 ccw_device_set_timeout(struct ccw_device *cdev, int expires)
 112 {
 113         if (expires == 0) {
 114                 del_timer(&cdev->private->timer);
 115                 return;
 116         }
 117         if (timer_pending(&cdev->private->timer)) {
 118                 if (mod_timer(&cdev->private->timer, jiffies + expires))
 119                         return;
 120         }
 121         cdev->private->timer.function = ccw_device_timeout;
 122         cdev->private->timer.data = (unsigned long) cdev;
 123         cdev->private->timer.expires = jiffies + expires;
 124         add_timer(&cdev->private->timer);
 125 }
 126
 127 /*
 128  * Cancel running i/o. This is called repeatedly since halt/clear are
 129  * asynchronous operations. We do one try with cio_cancel, two tries
 130  * with cio_halt, 255 tries with cio_clear. If everythings fails panic.
 131  * Returns 0 if device now idle, -ENODEV for device not operational and
 132  * -EBUSY if an interrupt is expected (either from halt/clear or from a
 133  * status pending).
 134  */
 135 int
 136 ccw_device_cancel_halt_clear(struct ccw_device *cdev)
 137 {
 138         struct subchannel *sch;
 139         int ret;
 140
 141         sch = to_subchannel(cdev->dev.parent);
 142         if (cio_update_schib(sch))
 143                 return -ENODEV;
 144         if (!sch->schib.pmcw.ena)
 145                 /* Not operational -> done. */
 146                 return 0;
 147         /* Stage 1: cancel io. */
 148         if (!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_HALT_PEND) &&
 149             !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_CLEAR_PEND)) {
 150                 if (!scsw_is_tm(&sch->schib.scsw)) {
 151                         ret = cio_cancel(sch);
 152                         if (ret != -EINVAL)
 153                                 return ret;
 154                 }
 155                 /* cancel io unsuccessful or not applicable (transport mode).
 156                  * Continue with asynchronous instructions. */
 157                 cdev->private->iretry = 3;      /* 3 halt retries. */
 158         }
 159         if (!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_CLEAR_PEND)) {
 160                 /* Stage 2: halt io. */
 161                 if (cdev->private->iretry) {
 162                         cdev->private->iretry--;
 163                         ret = cio_halt(sch);
 164                         if (ret != -EBUSY)
 165                                 return (ret == 0) ? -EBUSY : ret;
 166                 }
 167                 /* halt io unsuccessful. */
 168                 cdev->private->iretry = 255;    /* 255 clear retries. */
 169         }
 170         /* Stage 3: clear io. */
 171         if (cdev->private->iretry) {
 172                 cdev->private->iretry--;
 173                 ret = cio_clear (sch);
 174                 return (ret == 0) ? -EBUSY : ret;
 175         }
 176         /* Function was unsuccessful */
 177         CIO_MSG_EVENT(0, "0.%x.%04x: could not stop I/O\n",
 178                       cdev->private->dev_id.ssid, cdev->private->dev_id.devno);
 179         return -EIO;
 180 }
 181
 182 void ccw_device_update_sense_data(struct ccw_device *cdev)
 183 {
 184         memset(&cdev->id, 0, sizeof(cdev->id));
 185         cdev->id.cu_type   = cdev->private->senseid.cu_type;
 186         cdev->id.cu_model  = cdev->private->senseid.cu_model;
 187         cdev->id.dev_type  = cdev->private->senseid.dev_type;
 188         cdev->id.dev_model = cdev->private->senseid.dev_model;
 189 }
 190
 191 int ccw_device_test_sense_data(struct ccw_device *cdev)
 192 {
 193         return cdev->id.cu_type == cdev->private->senseid.cu_type &&
 194                 cdev->id.cu_model == cdev->private->senseid.cu_model &&
 195                 cdev->id.dev_type == cdev->private->senseid.dev_type &&
 196                 cdev->id.dev_model == cdev->private->senseid.dev_model;
 197 }
 198
 199 /*
 200  * The machine won't give us any notification by machine check if a chpid has
 201  * been varied online on the SE so we have to find out by magic (i. e. driving
 202  * the channel subsystem to device selection and updating our path masks).
 203  */
 204 static void
 205 __recover_lost_chpids(struct subchannel *sch, int old_lpm)
 206 {
 207         int mask, i;
 208         struct chp_id chpid;
 209
 210         chp_id_init(&chpid);
 211         for (i = 0; i<8; i++) {
 212                 mask = 0x80 >> i;
 213                 if (!(sch->lpm & mask))
 214                         continue;
 215                 if (old_lpm & mask)
 216                         continue;
 217                 chpid.id = sch->schib.pmcw.chpid[i];
 218                 if (!chp_is_registered(chpid))
 219                         css_schedule_eval_all();
 220         }
 221 }
 222
 223 /*
 224  * Stop device recognition.
 225  */
 226 static void
 227 ccw_device_recog_done(struct ccw_device *cdev, int state)
 228 {
 229         struct subchannel *sch;
 230         int old_lpm;
 231
 232         sch = to_subchannel(cdev->dev.parent);
 233
 234         if (cio_disable_subchannel(sch))
 235                 state = DEV_STATE_NOT_OPER;
 236         /*
 237          * Now that we tried recognition, we have performed device selection
 238          * through ssch() and the path information is up to date.
 239          */
 240         old_lpm = sch->lpm;
 241
 242         /* Check since device may again have become not operational. */
 243         if (cio_update_schib(sch))
 244                 state = DEV_STATE_NOT_OPER;
 245         else
 246                 sch->lpm = sch->schib.pmcw.pam & sch->opm;
 247
 248         if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
 249                 /* Force reprobe on all chpids. */
 250                 old_lpm = 0;
 251         if (sch->lpm != old_lpm)
 252                 __recover_lost_chpids(sch, old_lpm);
 253         if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID &&
 254             (state == DEV_STATE_NOT_OPER || state == DEV_STATE_BOXED)) {
 255                 cdev->private->flags.recog_done = 1;
 256                 cdev->private->state = DEV_STATE_DISCONNECTED;
 257                 wake_up(&cdev->private->wait_q);
 258                 return;
 259         }
 260         if (cdev->private->flags.resuming) {
 261                 cdev->private->state = state;
 262                 cdev->private->flags.recog_done = 1;
 263                 wake_up(&cdev->private->wait_q);
 264                 return;
 265         }
 266         switch (state) {
 267         case DEV_STATE_NOT_OPER:
 268                 break;
 269         case DEV_STATE_OFFLINE:
 270                 if (!cdev->online) {
 271                         ccw_device_update_sense_data(cdev);
 272                         break;
 273                 }
 274                 cdev->private->state = DEV_STATE_OFFLINE;
 275                 cdev->private->flags.recog_done = 1;
 276                 if (ccw_device_test_sense_data(cdev)) {
 277                         cdev->private->flags.donotify = 1;
 278                         ccw_device_online(cdev);
 279                         wake_up(&cdev->private->wait_q);
 280                 } else {
 281                         ccw_device_update_sense_data(cdev);
 282                         ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
 283                 }
 284                 return;
 285         case DEV_STATE_BOXED:
 286                 if (cdev->id.cu_type != 0) { /* device was recognized before */
 287                         cdev->private->flags.recog_done = 1;
 288                         cdev->private->state = DEV_STATE_BOXED;
 289                         wake_up(&cdev->private->wait_q);
 290                         return;
 291                 }
 292                 break;
 293         }
 294         cdev->private->state = state;
 295         io_subchannel_recog_done(cdev);
 296         wake_up(&cdev->private->wait_q);
 297 }
 298
 299 /*
 300  * Function called from device_id.c after sense id has completed.
 301  */
 302 void
 303 ccw_device_sense_id_done(struct ccw_device *cdev, int err)
 304 {
 305         switch (err) {
 306         case 0:
 307                 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
 308                 break;
 309         case -ETIME:            /* Sense id stopped by timeout. */
 310                 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
 311                 break;
 312         default:
 313                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
 314                 break;
 315         }
 316 }
 317
 318 /**
 319   * ccw_device_notify() - inform the device's driver about an event
 320   * @cdev: device for which an event occurred
 321   * @event: event that occurred
 322   *
 323   * Returns:
 324   *   -%EINVAL if the device is offline or has no driver.
 325   *   -%EOPNOTSUPP if the device's driver has no notifier registered.
 326   *   %NOTIFY_OK if the driver wants to keep the device.
 327   *   %NOTIFY_BAD if the driver doesn't want to keep the device.
 328   */
 329 int ccw_device_notify(struct ccw_device *cdev, int event)
 330 {
 331         int ret = -EINVAL;
 332
 333         if (!cdev->drv)
 334                 goto out;
 335         if (!cdev->online)
 336                 goto out;
 337         CIO_MSG_EVENT(2, "notify called for 0.%x.%04x, event=%d\n",
 338                       cdev->private->dev_id.ssid, cdev->private->dev_id.devno,
 339                       event);
 340         if (!cdev->drv->notify) {
 341                 ret = -EOPNOTSUPP;
 342                 goto out;
 343         }
 344         if (cdev->drv->notify(cdev, event))
 345                 ret = NOTIFY_OK;
 346         else
 347                 ret = NOTIFY_BAD;
 348 out:
 349         return ret;
 350 }
 351
 352 static void ccw_device_oper_notify(struct ccw_device *cdev)
 353 {
 354         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 355
 356         if (ccw_device_notify(cdev, CIO_OPER) == NOTIFY_OK) {
 357                 /* Reenable channel measurements, if needed. */
 358                 ccw_device_sched_todo(cdev, CDEV_TODO_ENABLE_CMF);
 359                 /* Save indication for new paths. */
 360                 cdev->private->path_new_mask = sch->vpm;
 361                 return;
 362         }
 363         /* Driver doesn't want device back. */
 364         ccw_device_set_notoper(cdev);
 365         ccw_device_sched_todo(cdev, CDEV_TODO_REBIND);
 366 }
 367
 368 /*
 369  * Finished with online/offline processing.
 370  */
 371 static void
 372 ccw_device_done(struct ccw_device *cdev, int state)
 373 {
 374         struct subchannel *sch;
 375
 376         sch = to_subchannel(cdev->dev.parent);
 377
 378         ccw_device_set_timeout(cdev, 0);
 379
 380         if (state != DEV_STATE_ONLINE)
 381                 cio_disable_subchannel(sch);
 382
 383         /* Reset device status. */
 384         memset(&cdev->private->irb, 0, sizeof(struct irb));
 385
 386         cdev->private->state = state;
 387
 388         switch (state) {
 389         case DEV_STATE_BOXED:
 390                 CIO_MSG_EVENT(0, "Boxed device %04x on subchannel %04x\n",
 391                               cdev->private->dev_id.devno, sch->schid.sch_no);
 392                 if (cdev->online &&
 393                     ccw_device_notify(cdev, CIO_BOXED) != NOTIFY_OK)
 394                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 395                 cdev->private->flags.donotify = 0;
 396                 break;
 397         case 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) != NOTIFY_OK)
 401                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 402                 else
 403                         ccw_device_set_disconnected(cdev);
 404                 cdev->private->flags.donotify = 0;
 405                 break;
 406         case DEV_STATE_DISCONNECTED:
 407                 CIO_MSG_EVENT(0, "Disconnected device %04x on subchannel "
 408                               "%04x\n", cdev->private->dev_id.devno,
 409                               sch->schid.sch_no);
 410                 if (ccw_device_notify(cdev, CIO_NO_PATH) != NOTIFY_OK) {
 411                         cdev->private->state = DEV_STATE_NOT_OPER;
 412                         ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 413                 } else
 414                         ccw_device_set_disconnected(cdev);
 415                 cdev->private->flags.donotify = 0;
 416                 break;
 417         default:
 418                 break;
 419         }
 420
 421         if (cdev->private->flags.donotify) {
 422                 cdev->private->flags.donotify = 0;
 423                 ccw_device_oper_notify(cdev);
 424         }
 425         wake_up(&cdev->private->wait_q);
 426 }
 427
 428 /*
 429  * Start device recognition.
 430  */
 431 void ccw_device_recognition(struct ccw_device *cdev)
 432 {
 433         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 434
 435         /*
 436          * We used to start here with a sense pgid to find out whether a device
 437          * is locked by someone else. Unfortunately, the sense pgid command
 438          * code has other meanings on devices predating the path grouping
 439          * algorithm, so we start with sense id and box the device after an
 440          * timeout (or if sense pgid during path verification detects the device
 441          * is locked, as may happen on newer devices).
 442          */
 443         cdev->private->flags.recog_done = 0;
 444         cdev->private->state = DEV_STATE_SENSE_ID;
 445         if (cio_enable_subchannel(sch, (u32) (addr_t) sch)) {
 446                 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
 447                 return;
 448         }
 449         ccw_device_sense_id_start(cdev);
 450 }
 451
 452 /*
 453  * Handle events for states that use the ccw request infrastructure.
 454  */
 455 static void ccw_device_request_event(struct ccw_device *cdev, enum dev_event e)
 456 {
 457         switch (e) {
 458         case DEV_EVENT_NOTOPER:
 459                 ccw_request_notoper(cdev);
 460                 break;
 461         case DEV_EVENT_INTERRUPT:
 462                 ccw_request_handler(cdev);
 463                 break;
 464         case DEV_EVENT_TIMEOUT:
 465                 ccw_request_timeout(cdev);
 466                 break;
 467         default:
 468                 break;
 469         }
 470 }
 471
 472 static void ccw_device_report_path_events(struct ccw_device *cdev)
 473 {
 474         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 475         int path_event[8];
 476         int chp, mask;
 477
 478         for (chp = 0, mask = 0x80; chp < 8; chp++, mask >>= 1) {
 479                 path_event[chp] = PE_NONE;
 480                 if (mask & cdev->private->path_gone_mask & ~(sch->vpm))
 481                         path_event[chp] |= PE_PATH_GONE;
 482                 if (mask & cdev->private->path_new_mask & sch->vpm)
 483                         path_event[chp] |= PE_PATH_AVAILABLE;
 484                 if (mask & cdev->private->pgid_reset_mask & sch->vpm)
 485                         path_event[chp] |= PE_PATHGROUP_ESTABLISHED;
 486         }
 487         if (cdev->online && cdev->drv->path_event)
 488                 cdev->drv->path_event(cdev, path_event);
 489 }
 490
 491 static void ccw_device_reset_path_events(struct ccw_device *cdev)
 492 {
 493         cdev->private->path_gone_mask = 0;
 494         cdev->private->path_new_mask = 0;
 495         cdev->private->pgid_reset_mask = 0;
 496 }
 497
 498 static void create_fake_irb(struct irb *irb, int type)
 499 {
 500         memset(irb, 0, sizeof(*irb));
 501         if (type == FAKE_CMD_IRB) {
 502                 struct cmd_scsw *scsw = &irb->scsw.cmd;
 503                 scsw->cc = 1;
 504                 scsw->fctl = SCSW_FCTL_START_FUNC;
 505                 scsw->actl = SCSW_ACTL_START_PEND;
 506                 scsw->stctl = SCSW_STCTL_STATUS_PEND;
 507         } else if (type == FAKE_TM_IRB) {
 508                 struct tm_scsw *scsw = &irb->scsw.tm;
 509                 scsw->x = 1;
 510                 scsw->cc = 1;
 511                 scsw->fctl = SCSW_FCTL_START_FUNC;
 512                 scsw->actl = SCSW_ACTL_START_PEND;
 513                 scsw->stctl = SCSW_STCTL_STATUS_PEND;
 514         }
 515 }
 516
 517 void ccw_device_verify_done(struct ccw_device *cdev, int err)
 518 {
 519         struct subchannel *sch;
 520
 521         sch = to_subchannel(cdev->dev.parent);
 522         /* Update schib - pom may have changed. */
 523         if (cio_update_schib(sch)) {
 524                 err = -ENODEV;
 525                 goto callback;
 526         }
 527         /* Update lpm with verified path mask. */
 528         sch->lpm = sch->vpm;
 529         /* Repeat path verification? */
 530         if (cdev->private->flags.doverify) {
 531                 ccw_device_verify_start(cdev);
 532                 return;
 533         }
 534 callback:
 535         switch (err) {
 536         case 0:
 537                 ccw_device_done(cdev, DEV_STATE_ONLINE);
 538                 /* Deliver fake irb to device driver, if needed. */
 539                 if (cdev->private->flags.fake_irb) {
 540                         create_fake_irb(&cdev->private->irb,
 541                                         cdev->private->flags.fake_irb);
 542                         cdev->private->flags.fake_irb = 0;
 543                         if (cdev->handler)
 544                                 cdev->handler(cdev, cdev->private->intparm,
 545                                               &cdev->private->irb);
 546                         memset(&cdev->private->irb, 0, sizeof(struct irb));
 547                 }
 548                 ccw_device_report_path_events(cdev);
 549                 break;
 550         case -ETIME:
 551         case -EUSERS:
 552                 /* Reset oper notify indication after verify error. */
 553                 cdev->private->flags.donotify = 0;
 554                 ccw_device_done(cdev, DEV_STATE_BOXED);
 555                 break;
 556         case -EACCES:
 557                 /* Reset oper notify indication after verify error. */
 558                 cdev->private->flags.donotify = 0;
 559                 ccw_device_done(cdev, DEV_STATE_DISCONNECTED);
 560                 break;
 561         default:
 562                 /* Reset oper notify indication after verify error. */
 563                 cdev->private->flags.donotify = 0;
 564                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 565                 break;
 566         }
 567         ccw_device_reset_path_events(cdev);
 568 }
 569
 570 /*
 571  * Get device online.
 572  */
 573 int
 574 ccw_device_online(struct ccw_device *cdev)
 575 {
 576         struct subchannel *sch;
 577         int ret;
 578
 579         if ((cdev->private->state != DEV_STATE_OFFLINE) &&
 580             (cdev->private->state != DEV_STATE_BOXED))
 581                 return -EINVAL;
 582         sch = to_subchannel(cdev->dev.parent);
 583         ret = cio_enable_subchannel(sch, (u32)(addr_t)sch);
 584         if (ret != 0) {
 585                 /* Couldn't enable the subchannel for i/o. Sick device. */
 586                 if (ret == -ENODEV)
 587                         dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
 588                 return ret;
 589         }
 590         /* Start initial path verification. */
 591         cdev->private->state = DEV_STATE_VERIFY;
 592         ccw_device_verify_start(cdev);
 593         return 0;
 594 }
 595
 596 void
 597 ccw_device_disband_done(struct ccw_device *cdev, int err)
 598 {
 599         switch (err) {
 600         case 0:
 601                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
 602                 break;
 603         case -ETIME:
 604                 ccw_device_done(cdev, DEV_STATE_BOXED);
 605                 break;
 606         default:
 607                 cdev->private->flags.donotify = 0;
 608                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 609                 break;
 610         }
 611 }
 612
 613 /*
 614  * Shutdown device.
 615  */
 616 int
 617 ccw_device_offline(struct ccw_device *cdev)
 618 {
 619         struct subchannel *sch;
 620
 621         /* Allow ccw_device_offline while disconnected. */
 622         if (cdev->private->state == DEV_STATE_DISCONNECTED ||
 623             cdev->private->state == DEV_STATE_NOT_OPER) {
 624                 cdev->private->flags.donotify = 0;
 625                 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 626                 return 0;
 627         }
 628         if (cdev->private->state == DEV_STATE_BOXED) {
 629                 ccw_device_done(cdev, DEV_STATE_BOXED);
 630                 return 0;
 631         }
 632         if (ccw_device_is_orphan(cdev)) {
 633                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
 634                 return 0;
 635         }
 636         sch = to_subchannel(cdev->dev.parent);
 637         if (cio_update_schib(sch))
 638                 return -ENODEV;
 639         if (scsw_actl(&sch->schib.scsw) != 0)
 640                 return -EBUSY;
 641         if (cdev->private->state != DEV_STATE_ONLINE)
 642                 return -EINVAL;
 643         /* Are we doing path grouping? */
 644         if (!cdev->private->flags.pgroup) {
 645                 /* No, set state offline immediately. */
 646                 ccw_device_done(cdev, DEV_STATE_OFFLINE);
 647                 return 0;
 648         }
 649         /* Start Set Path Group commands. */
 650         cdev->private->state = DEV_STATE_DISBAND_PGID;
 651         ccw_device_disband_start(cdev);
 652         return 0;
 653 }
 654
 655 /*
 656  * Handle not operational event in non-special state.
 657  */
 658 static void ccw_device_generic_notoper(struct ccw_device *cdev,
 659                                        enum dev_event dev_event)
 660 {
 661         if (ccw_device_notify(cdev, CIO_GONE) != NOTIFY_OK)
 662                 ccw_device_sched_todo(cdev, CDEV_TODO_UNREG);
 663         else
 664                 ccw_device_set_disconnected(cdev);
 665 }
 666
 667 /*
 668  * Handle path verification event in offline state.
 669  */
 670 static void ccw_device_offline_verify(struct ccw_device *cdev,
 671                                       enum dev_event dev_event)
 672 {
 673         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 674
 675         css_schedule_eval(sch->schid);
 676 }
 677
 678 /*
 679  * Handle path verification event.
 680  */
 681 static void
 682 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
 683 {
 684         struct subchannel *sch;
 685
 686         if (cdev->private->state == DEV_STATE_W4SENSE) {
 687                 cdev->private->flags.doverify = 1;
 688                 return;
 689         }
 690         sch = to_subchannel(cdev->dev.parent);
 691         /*
 692          * Since we might not just be coming from an interrupt from the
 693          * subchannel we have to update the schib.
 694          */
 695         if (cio_update_schib(sch)) {
 696                 ccw_device_verify_done(cdev, -ENODEV);
 697                 return;
 698         }
 699
 700         if (scsw_actl(&sch->schib.scsw) != 0 ||
 701             (scsw_stctl(&sch->schib.scsw) & SCSW_STCTL_STATUS_PEND) ||
 702             (scsw_stctl(&cdev->private->irb.scsw) & SCSW_STCTL_STATUS_PEND)) {
 703                 /*
 704                  * No final status yet or final status not yet delivered
 705                  * to the device driver. Can't do path verification now,
 706                  * delay until final status was delivered.
 707                  */
 708                 cdev->private->flags.doverify = 1;
 709                 return;
 710         }
 711         /* Device is idle, we can do the path verification. */
 712         cdev->private->state = DEV_STATE_VERIFY;
 713         ccw_device_verify_start(cdev);
 714 }
 715
 716 /*
 717  * Handle path verification event in boxed state.
 718  */
 719 static void ccw_device_boxed_verify(struct ccw_device *cdev,
 720                                     enum dev_event dev_event)
 721 {
 722         struct subchannel *sch = to_subchannel(cdev->dev.parent);
 723
 724         if (cdev->online) {
 725                 if (cio_enable_subchannel(sch, (u32) (addr_t) sch))
 726                         ccw_device_done(cdev, DEV_STATE_NOT_OPER);
 727                 else
 728                         ccw_device_online_verify(cdev, dev_event);
 729         } else
 730                 css_schedule_eval(sch->schid);
 731 }
 732
 733 /*
 734  * Got an interrupt for a normal io (state online).
 735  */
 736 static void
 737 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
 738 {
 739         struct irb *irb;
 740         int is_cmd;
 741
 742         irb = this_cpu_ptr(&cio_irb);
 743         is_cmd = !scsw_is_tm(&irb->scsw);
 744         /* Check for unsolicited interrupt. */
 745         if (!scsw_is_solicited(&irb->scsw)) {
 746                 if (is_cmd && (irb->scsw.cmd.dstat & DEV_STAT_UNIT_CHECK) &&
 747                     !irb->esw.esw0.erw.cons) {
 748                         /* Unit check but no sense data. Need basic sense. */
 749                         if (ccw_device_do_sense(cdev, irb) != 0)
 750                                 goto call_handler_unsol;
 751                         memcpy(&cdev->private->irb, irb, sizeof(struct irb));
 752                         cdev->private->state = DEV_STATE_W4SENSE;
 753                         cdev->private->intparm = 0;
 754                         return;
 755                 }
 756 call_handler_unsol:
 757                 if (cdev->handler)
 758                         cdev->handler (cdev, 0, irb);
 759                 if (cdev->private->flags.doverify)
 760                         ccw_device_online_verify(cdev, 0);
 761                 return;
 762         }
 763         /* Accumulate status and find out if a basic sense is needed. */
 764         ccw_device_accumulate_irb(cdev, irb);
 765         if (is_cmd && cdev->private->flags.dosense) {
 766                 if (ccw_device_do_sense(cdev, irb) == 0) {
 767                         cdev->private->state = DEV_STATE_W4SENSE;
 768                 }
 769                 return;
 770         }
 771         /* Call the handler. */
 772         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
 773                 /* Start delayed path verification. */
 774                 ccw_device_online_verify(cdev, 0);
 775 }
 776
 777 /*
 778  * Got an timeout in online state.
 779  */
 780 static void
 781 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 782 {
 783         int ret;
 784
 785         ccw_device_set_timeout(cdev, 0);
 786         cdev->private->iretry = 255;
 787         ret = ccw_device_cancel_halt_clear(cdev);
 788         if (ret == -EBUSY) {
 789                 ccw_device_set_timeout(cdev, 3*HZ);
 790                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
 791                 return;
 792         }
 793         if (ret)
 794                 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
 795         else if (cdev->handler)
 796                 cdev->handler(cdev, cdev->private->intparm,
 797                               ERR_PTR(-ETIMEDOUT));
 798 }
 799
 800 /*
 801  * Got an interrupt for a basic sense.
 802  */
 803 static void
 804 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
 805 {
 806         struct irb *irb;
 807
 808         irb = this_cpu_ptr(&cio_irb);
 809         /* Check for unsolicited interrupt. */
 810         if (scsw_stctl(&irb->scsw) ==
 811             (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
 812                 if (scsw_cc(&irb->scsw) == 1)
 813                         /* Basic sense hasn't started. Try again. */
 814                         ccw_device_do_sense(cdev, irb);
 815                 else {
 816                         CIO_MSG_EVENT(0, "0.%x.%04x: unsolicited "
 817                                       "interrupt during w4sense...\n",
 818                                       cdev->private->dev_id.ssid,
 819                                       cdev->private->dev_id.devno);
 820                         if (cdev->handler)
 821                                 cdev->handler (cdev, 0, irb);
 822                 }
 823                 return;
 824         }
 825         /*
 826          * Check if a halt or clear has been issued in the meanwhile. If yes,
 827          * only deliver the halt/clear interrupt to the device driver as if it
 828          * had killed the original request.
 829          */
 830         if (scsw_fctl(&irb->scsw) &
 831             (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
 832                 cdev->private->flags.dosense = 0;
 833                 memset(&cdev->private->irb, 0, sizeof(struct irb));
 834                 ccw_device_accumulate_irb(cdev, irb);
 835                 goto call_handler;
 836         }
 837         /* Add basic sense info to irb. */
 838         ccw_device_accumulate_basic_sense(cdev, irb);
 839         if (cdev->private->flags.dosense) {
 840                 /* Another basic sense is needed. */
 841                 ccw_device_do_sense(cdev, irb);
 842                 return;
 843         }
 844 call_handler:
 845         cdev->private->state = DEV_STATE_ONLINE;
 846         /* In case sensing interfered with setting the device online */
 847         wake_up(&cdev->private->wait_q);
 848         /* Call the handler. */
 849         if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
 850                 /* Start delayed path verification. */
 851                 ccw_device_online_verify(cdev, 0);
 852 }
 853
 854 static void
 855 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
 856 {
 857         ccw_device_set_timeout(cdev, 0);
 858         /* Start delayed path verification. */
 859         ccw_device_online_verify(cdev, 0);
 860         /* OK, i/o is dead now. Call interrupt handler. */
 861         if (cdev->handler)
 862                 cdev->handler(cdev, cdev->private->intparm,
 863                               ERR_PTR(-EIO));
 864 }
 865
 866 static void
 867 ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 868 {
 869         int ret;
 870
 871         ret = ccw_device_cancel_halt_clear(cdev);
 872         if (ret == -EBUSY) {
 873                 ccw_device_set_timeout(cdev, 3*HZ);
 874                 return;
 875         }
 876         /* Start delayed path verification. */
 877         ccw_device_online_verify(cdev, 0);
 878         if (cdev->handler)
 879                 cdev->handler(cdev, cdev->private->intparm,
 880                               ERR_PTR(-EIO));
 881 }
 882
 883 void ccw_device_kill_io(struct ccw_device *cdev)
 884 {
 885         int ret;
 886
 887         cdev->private->iretry = 255;
 888         ret = ccw_device_cancel_halt_clear(cdev);
 889         if (ret == -EBUSY) {
 890                 ccw_device_set_timeout(cdev, 3*HZ);
 891                 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
 892                 return;
 893         }
 894         /* Start delayed path verification. */
 895         ccw_device_online_verify(cdev, 0);
 896         if (cdev->handler)
 897                 cdev->handler(cdev, cdev->private->intparm,
 898                               ERR_PTR(-EIO));
 899 }
 900
 901 static void
 902 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
 903 {
 904         /* Start verification after current task finished. */
 905         cdev->private->flags.doverify = 1;
 906 }
 907
 908 static void
 909 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
 910 {
 911         struct subchannel *sch;
 912
 913         sch = to_subchannel(cdev->dev.parent);
 914         if (cio_enable_subchannel(sch, (u32)(addr_t)sch) != 0)
 915                 /* Couldn't enable the subchannel for i/o. Sick device. */
 916                 return;
 917         cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
 918         ccw_device_sense_id_start(cdev);
 919 }
 920
 921 void ccw_device_trigger_reprobe(struct ccw_device *cdev)
 922 {
 923         struct subchannel *sch;
 924
 925         if (cdev->private->state != DEV_STATE_DISCONNECTED)
 926                 return;
 927
 928         sch = to_subchannel(cdev->dev.parent);
 929         /* Update some values. */
 930         if (cio_update_schib(sch))
 931                 return;
 932         /*
 933          * The pim, pam, pom values may not be accurate, but they are the best
 934          * we have before performing device selection :/
 935          */
 936         sch->lpm = sch->schib.pmcw.pam & sch->opm;
 937         /*
 938          * Use the initial configuration since we can't be shure that the old
 939          * paths are valid.
 940          */
 941         io_subchannel_init_config(sch);
 942         if (cio_commit_config(sch))
 943                 return;
 944
 945         /* We should also udate ssd info, but this has to wait. */
 946         /* Check if this is another device which appeared on the same sch. */
 947         if (sch->schib.pmcw.dev != cdev->private->dev_id.devno)
 948                 css_schedule_eval(sch->schid);
 949         else
 950                 ccw_device_start_id(cdev, 0);
 951 }
 952
 953 static void ccw_device_disabled_irq(struct ccw_device *cdev,
 954                                     enum dev_event dev_event)
 955 {
 956         struct subchannel *sch;
 957
 958         sch = to_subchannel(cdev->dev.parent);
 959         /*
 960          * An interrupt in a disabled state means a previous disable was not
 961          * successful - should not happen, but we try to disable again.
 962          */
 963         cio_disable_subchannel(sch);
 964 }
 965
 966 static void
 967 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
 968 {
 969         retry_set_schib(cdev);
 970         cdev->private->state = DEV_STATE_ONLINE;
 971         dev_fsm_event(cdev, dev_event);
 972 }
 973
 974 static void ccw_device_update_cmfblock(struct ccw_device *cdev,
 975                                        enum dev_event dev_event)
 976 {
 977         cmf_retry_copy_block(cdev);
 978         cdev->private->state = DEV_STATE_ONLINE;
 979         dev_fsm_event(cdev, dev_event);
 980 }
 981
 982 static void
 983 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
 984 {
 985         ccw_device_set_timeout(cdev, 0);
 986         cdev->private->state = DEV_STATE_NOT_OPER;
 987         wake_up(&cdev->private->wait_q);
 988 }
 989
 990 static void
 991 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
 992 {
 993         int ret;
 994
 995         ret = ccw_device_cancel_halt_clear(cdev);
 996         if (ret == -EBUSY) {
 997                 ccw_device_set_timeout(cdev, HZ/10);
 998         } else {
 999                 cdev->private->state = DEV_STATE_NOT_OPER;
1000                 wake_up(&cdev->private->wait_q);
1001         }
1002 }
1003
1004 /*
1005  * No operation action. This is used e.g. to ignore a timeout event in
1006  * state offline.
1007  */
1008 static void
1009 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1010 {
1011 }
1012
1013 /*
1014  * device statemachine
1015  */
1016 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
1017         [DEV_STATE_NOT_OPER] = {
1018                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1019                 [DEV_EVENT_INTERRUPT]   = ccw_device_disabled_irq,
1020                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1021                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1022         },
1023         [DEV_STATE_SENSE_PGID] = {
1024                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1025                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1026                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1027                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1028         },
1029         [DEV_STATE_SENSE_ID] = {
1030                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1031                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1032                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1033                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1034         },
1035         [DEV_STATE_OFFLINE] = {
1036                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1037                 [DEV_EVENT_INTERRUPT]   = ccw_device_disabled_irq,
1038                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1039                 [DEV_EVENT_VERIFY]      = ccw_device_offline_verify,
1040         },
1041         [DEV_STATE_VERIFY] = {
1042                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1043                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1044                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1045                 [DEV_EVENT_VERIFY]      = ccw_device_delay_verify,
1046         },
1047         [DEV_STATE_ONLINE] = {
1048                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1049                 [DEV_EVENT_INTERRUPT]   = ccw_device_irq,
1050                 [DEV_EVENT_TIMEOUT]     = ccw_device_online_timeout,
1051                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1052         },
1053         [DEV_STATE_W4SENSE] = {
1054                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1055                 [DEV_EVENT_INTERRUPT]   = ccw_device_w4sense,
1056                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1057                 [DEV_EVENT_VERIFY]      = ccw_device_online_verify,
1058         },
1059         [DEV_STATE_DISBAND_PGID] = {
1060                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1061                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1062                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1063                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1064         },
1065         [DEV_STATE_BOXED] = {
1066                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1067                 [DEV_EVENT_INTERRUPT]   = ccw_device_nop,
1068                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1069                 [DEV_EVENT_VERIFY]      = ccw_device_boxed_verify,
1070         },
1071         /* states to wait for i/o completion before doing something */
1072         [DEV_STATE_TIMEOUT_KILL] = {
1073                 [DEV_EVENT_NOTOPER]     = ccw_device_generic_notoper,
1074                 [DEV_EVENT_INTERRUPT]   = ccw_device_killing_irq,
1075                 [DEV_EVENT_TIMEOUT]     = ccw_device_killing_timeout,
1076                 [DEV_EVENT_VERIFY]      = ccw_device_nop, //FIXME
1077         },
1078         [DEV_STATE_QUIESCE] = {
1079                 [DEV_EVENT_NOTOPER]     = ccw_device_quiesce_done,
1080                 [DEV_EVENT_INTERRUPT]   = ccw_device_quiesce_done,
1081                 [DEV_EVENT_TIMEOUT]     = ccw_device_quiesce_timeout,
1082                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1083         },
1084         /* special states for devices gone not operational */
1085         [DEV_STATE_DISCONNECTED] = {
1086                 [DEV_EVENT_NOTOPER]     = ccw_device_nop,
1087                 [DEV_EVENT_INTERRUPT]   = ccw_device_start_id,
1088                 [DEV_EVENT_TIMEOUT]     = ccw_device_nop,
1089                 [DEV_EVENT_VERIFY]      = ccw_device_start_id,
1090         },
1091         [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1092                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1093                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1094                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1095                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1096         },
1097         [DEV_STATE_CMFCHANGE] = {
1098                 [DEV_EVENT_NOTOPER]     = ccw_device_change_cmfstate,
1099                 [DEV_EVENT_INTERRUPT]   = ccw_device_change_cmfstate,
1100                 [DEV_EVENT_TIMEOUT]     = ccw_device_change_cmfstate,
1101                 [DEV_EVENT_VERIFY]      = ccw_device_change_cmfstate,
1102         },
1103         [DEV_STATE_CMFUPDATE] = {
1104                 [DEV_EVENT_NOTOPER]     = ccw_device_update_cmfblock,
1105                 [DEV_EVENT_INTERRUPT]   = ccw_device_update_cmfblock,
1106                 [DEV_EVENT_TIMEOUT]     = ccw_device_update_cmfblock,
1107                 [DEV_EVENT_VERIFY]      = ccw_device_update_cmfblock,
1108         },
1109         [DEV_STATE_STEAL_LOCK] = {
1110                 [DEV_EVENT_NOTOPER]     = ccw_device_request_event,
1111                 [DEV_EVENT_INTERRUPT]   = ccw_device_request_event,
1112                 [DEV_EVENT_TIMEOUT]     = ccw_device_request_event,
1113                 [DEV_EVENT_VERIFY]      = ccw_device_nop,
1114         },
1115 };
1116
1117 EXPORT_SYMBOL_GPL(ccw_device_set_timeout);