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