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