drivers/s390/cio/device_fsm.c

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