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