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) 148 /* Not operational -> 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 unsigned long flags; 338 339 priv = container_of(work, struct ccw_device_private, kick_work); 340 cdev = priv->cdev; 341 spin_lock_irqsave(cdev->ccwlock, flags); 342 sch = to_subchannel(cdev->dev.parent); 343 if (sch->driver && sch->driver->notify) { 344 spin_unlock_irqrestore(cdev->ccwlock, flags); 345 ret = sch->driver->notify(&sch->dev, CIO_OPER); 346 spin_lock_irqsave(cdev->ccwlock, flags); 347 } else 348 ret = 0; 349 if (ret) { 350 /* Reenable channel measurements, if needed. */ 351 spin_unlock_irqrestore(cdev->ccwlock, flags); 352 cmf_reenable(cdev); 353 spin_lock_irqsave(cdev->ccwlock, flags); 354 wake_up(&cdev->private->wait_q); 355 } 356 spin_unlock_irqrestore(cdev->ccwlock, flags); 357 if (!ret) 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_DEBUG(KERN_WARNING, 2, 385 "Boxed device %04x on subchannel %04x\n", 386 cdev->private->dev_id.devno, sch->schid.sch_no); 387 388 if (cdev->private->flags.donotify) { 389 cdev->private->flags.donotify = 0; 390 PREPARE_WORK(&cdev->private->kick_work, ccw_device_oper_notify); 391 queue_work(ccw_device_notify_work, &cdev->private->kick_work); 392 } 393 wake_up(&cdev->private->wait_q); 394 395 if (css_init_done && state != DEV_STATE_ONLINE) 396 put_device (&cdev->dev); 397 } 398 399 static int cmp_pgid(struct pgid *p1, struct pgid *p2) 400 { 401 char *c1; 402 char *c2; 403 404 c1 = (char *)p1; 405 c2 = (char *)p2; 406 407 return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1); 408 } 409 410 static void __ccw_device_get_common_pgid(struct ccw_device *cdev) 411 { 412 int i; 413 int last; 414 415 last = 0; 416 for (i = 0; i < 8; i++) { 417 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET) 418 /* No PGID yet */ 419 continue; 420 if (cdev->private->pgid[last].inf.ps.state1 == 421 SNID_STATE1_RESET) { 422 /* First non-zero PGID */ 423 last = i; 424 continue; 425 } 426 if (cmp_pgid(&cdev->private->pgid[i], 427 &cdev->private->pgid[last]) == 0) 428 /* Non-conflicting PGIDs */ 429 continue; 430 431 /* PGID mismatch, can't pathgroup. */ 432 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device " 433 "0.%x.%04x, can't pathgroup\n", 434 cdev->private->dev_id.ssid, 435 cdev->private->dev_id.devno); 436 cdev->private->options.pgroup = 0; 437 return; 438 } 439 if (cdev->private->pgid[last].inf.ps.state1 == 440 SNID_STATE1_RESET) 441 /* No previous pgid found */ 442 memcpy(&cdev->private->pgid[0], &css[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, sch->schib.pmcw.isc); 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 static void 540 ccw_device_nopath_notify(struct work_struct *work) 541 { 542 struct ccw_device_private *priv; 543 struct ccw_device *cdev; 544 struct subchannel *sch; 545 int ret; 546 unsigned long flags; 547 548 priv = container_of(work, struct ccw_device_private, kick_work); 549 cdev = priv->cdev; 550 spin_lock_irqsave(cdev->ccwlock, flags); 551 sch = to_subchannel(cdev->dev.parent); 552 /* Extra sanity. */ 553 if (sch->lpm) 554 goto out_unlock; 555 if (sch->driver && sch->driver->notify) { 556 spin_unlock_irqrestore(cdev->ccwlock, flags); 557 ret = sch->driver->notify(&sch->dev, CIO_NO_PATH); 558 spin_lock_irqsave(cdev->ccwlock, flags); 559 } else 560 ret = 0; 561 if (!ret) { 562 if (get_device(&sch->dev)) { 563 /* Driver doesn't want to keep device. */ 564 cio_disable_subchannel(sch); 565 if (get_device(&cdev->dev)) { 566 PREPARE_WORK(&cdev->private->kick_work, 567 ccw_device_call_sch_unregister); 568 queue_work(ccw_device_work, 569 &cdev->private->kick_work); 570 } else 571 put_device(&sch->dev); 572 } 573 } else { 574 cio_disable_subchannel(sch); 575 ccw_device_set_timeout(cdev, 0); 576 cdev->private->flags.fake_irb = 0; 577 cdev->private->state = DEV_STATE_DISCONNECTED; 578 wake_up(&cdev->private->wait_q); 579 } 580 out_unlock: 581 spin_unlock_irqrestore(cdev->ccwlock, flags); 582 } 583 584 void 585 ccw_device_verify_done(struct ccw_device *cdev, int err) 586 { 587 struct subchannel *sch; 588 589 sch = to_subchannel(cdev->dev.parent); 590 /* Update schib - pom may have changed. */ 591 stsch(sch->schid, &sch->schib); 592 /* Update lpm with verified path mask. */ 593 sch->lpm = sch->vpm; 594 /* Repeat path verification? */ 595 if (cdev->private->flags.doverify) { 596 cdev->private->flags.doverify = 0; 597 ccw_device_verify_start(cdev); 598 return; 599 } 600 switch (err) { 601 case -EOPNOTSUPP: /* path grouping not supported, just set online. */ 602 cdev->private->options.pgroup = 0; 603 case 0: 604 ccw_device_done(cdev, DEV_STATE_ONLINE); 605 /* Deliver fake irb to device driver, if needed. */ 606 if (cdev->private->flags.fake_irb) { 607 memset(&cdev->private->irb, 0, sizeof(struct irb)); 608 cdev->private->irb.scsw.cc = 1; 609 cdev->private->irb.scsw.fctl = SCSW_FCTL_START_FUNC; 610 cdev->private->irb.scsw.actl = SCSW_ACTL_START_PEND; 611 cdev->private->irb.scsw.stctl = SCSW_STCTL_STATUS_PEND; 612 cdev->private->flags.fake_irb = 0; 613 if (cdev->handler) 614 cdev->handler(cdev, cdev->private->intparm, 615 &cdev->private->irb); 616 memset(&cdev->private->irb, 0, sizeof(struct irb)); 617 } 618 break; 619 case -ETIME: 620 /* Reset oper notify indication after verify error. */ 621 cdev->private->flags.donotify = 0; 622 ccw_device_done(cdev, DEV_STATE_BOXED); 623 break; 624 default: 625 /* Reset oper notify indication after verify error. */ 626 cdev->private->flags.donotify = 0; 627 if (cdev->online) { 628 PREPARE_WORK(&cdev->private->kick_work, 629 ccw_device_nopath_notify); 630 queue_work(ccw_device_notify_work, 631 &cdev->private->kick_work); 632 } else 633 ccw_device_done(cdev, DEV_STATE_NOT_OPER); 634 break; 635 } 636 } 637 638 /* 639 * Get device online. 640 */ 641 int 642 ccw_device_online(struct ccw_device *cdev) 643 { 644 struct subchannel *sch; 645 int ret; 646 647 if ((cdev->private->state != DEV_STATE_OFFLINE) && 648 (cdev->private->state != DEV_STATE_BOXED)) 649 return -EINVAL; 650 sch = to_subchannel(cdev->dev.parent); 651 if (css_init_done && !get_device(&cdev->dev)) 652 return -ENODEV; 653 ret = cio_enable_subchannel(sch, sch->schib.pmcw.isc); 654 if (ret != 0) { 655 /* Couldn't enable the subchannel for i/o. Sick device. */ 656 if (ret == -ENODEV) 657 dev_fsm_event(cdev, DEV_EVENT_NOTOPER); 658 return ret; 659 } 660 /* Do we want to do path grouping? */ 661 if (!cdev->private->options.pgroup) { 662 /* Start initial path verification. */ 663 cdev->private->state = DEV_STATE_VERIFY; 664 cdev->private->flags.doverify = 0; 665 ccw_device_verify_start(cdev); 666 return 0; 667 } 668 /* Do a SensePGID first. */ 669 cdev->private->state = DEV_STATE_SENSE_PGID; 670 ccw_device_sense_pgid_start(cdev); 671 return 0; 672 } 673 674 void 675 ccw_device_disband_done(struct ccw_device *cdev, int err) 676 { 677 switch (err) { 678 case 0: 679 ccw_device_done(cdev, DEV_STATE_OFFLINE); 680 break; 681 case -ETIME: 682 ccw_device_done(cdev, DEV_STATE_BOXED); 683 break; 684 default: 685 ccw_device_done(cdev, DEV_STATE_NOT_OPER); 686 break; 687 } 688 } 689 690 /* 691 * Shutdown device. 692 */ 693 int 694 ccw_device_offline(struct ccw_device *cdev) 695 { 696 struct subchannel *sch; 697 698 if (ccw_device_is_orphan(cdev)) { 699 ccw_device_done(cdev, DEV_STATE_OFFLINE); 700 return 0; 701 } 702 sch = to_subchannel(cdev->dev.parent); 703 if (stsch(sch->schid, &sch->schib) || !sch->schib.pmcw.dnv) 704 return -ENODEV; 705 if (cdev->private->state != DEV_STATE_ONLINE) { 706 if (sch->schib.scsw.actl != 0) 707 return -EBUSY; 708 return -EINVAL; 709 } 710 if (sch->schib.scsw.actl != 0) 711 return -EBUSY; 712 /* Are we doing path grouping? */ 713 if (!cdev->private->options.pgroup) { 714 /* No, set state offline immediately. */ 715 ccw_device_done(cdev, DEV_STATE_OFFLINE); 716 return 0; 717 } 718 /* Start Set Path Group commands. */ 719 cdev->private->state = DEV_STATE_DISBAND_PGID; 720 ccw_device_disband_start(cdev); 721 return 0; 722 } 723 724 /* 725 * Handle timeout in device online/offline process. 726 */ 727 static void 728 ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event) 729 { 730 int ret; 731 732 ret = ccw_device_cancel_halt_clear(cdev); 733 switch (ret) { 734 case 0: 735 ccw_device_done(cdev, DEV_STATE_BOXED); 736 break; 737 case -ENODEV: 738 ccw_device_done(cdev, DEV_STATE_NOT_OPER); 739 break; 740 default: 741 ccw_device_set_timeout(cdev, 3*HZ); 742 } 743 } 744 745 /* 746 * Handle not oper event in device recognition. 747 */ 748 static void 749 ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event) 750 { 751 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER); 752 } 753 754 /* 755 * Handle not operational event while offline. 756 */ 757 static void 758 ccw_device_offline_notoper(struct ccw_device *cdev, enum dev_event dev_event) 759 { 760 struct subchannel *sch; 761 762 cdev->private->state = DEV_STATE_NOT_OPER; 763 sch = to_subchannel(cdev->dev.parent); 764 if (get_device(&cdev->dev)) { 765 PREPARE_WORK(&cdev->private->kick_work, 766 ccw_device_call_sch_unregister); 767 queue_work(ccw_device_work, &cdev->private->kick_work); 768 } 769 wake_up(&cdev->private->wait_q); 770 } 771 772 /* 773 * Handle not operational event while online. 774 */ 775 static void 776 ccw_device_online_notoper(struct ccw_device *cdev, enum dev_event dev_event) 777 { 778 struct subchannel *sch; 779 int ret; 780 781 sch = to_subchannel(cdev->dev.parent); 782 if (sch->driver->notify) { 783 spin_unlock_irq(cdev->ccwlock); 784 ret = sch->driver->notify(&sch->dev, 785 sch->lpm ? CIO_GONE : CIO_NO_PATH); 786 spin_lock_irq(cdev->ccwlock); 787 } else 788 ret = 0; 789 if (ret) { 790 ccw_device_set_timeout(cdev, 0); 791 cdev->private->flags.fake_irb = 0; 792 cdev->private->state = DEV_STATE_DISCONNECTED; 793 wake_up(&cdev->private->wait_q); 794 return; 795 } 796 cdev->private->state = DEV_STATE_NOT_OPER; 797 cio_disable_subchannel(sch); 798 if (sch->schib.scsw.actl != 0) { 799 // FIXME: not-oper indication to device driver ? 800 ccw_device_call_handler(cdev); 801 } 802 if (get_device(&cdev->dev)) { 803 PREPARE_WORK(&cdev->private->kick_work, 804 ccw_device_call_sch_unregister); 805 queue_work(ccw_device_work, &cdev->private->kick_work); 806 } 807 wake_up(&cdev->private->wait_q); 808 } 809 810 /* 811 * Handle path verification event. 812 */ 813 static void 814 ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event) 815 { 816 struct subchannel *sch; 817 818 if (cdev->private->state == DEV_STATE_W4SENSE) { 819 cdev->private->flags.doverify = 1; 820 return; 821 } 822 sch = to_subchannel(cdev->dev.parent); 823 /* 824 * Since we might not just be coming from an interrupt from the 825 * subchannel we have to update the schib. 826 */ 827 stsch(sch->schid, &sch->schib); 828 829 if (sch->schib.scsw.actl != 0 || 830 (sch->schib.scsw.stctl & SCSW_STCTL_STATUS_PEND) || 831 (cdev->private->irb.scsw.stctl & SCSW_STCTL_STATUS_PEND)) { 832 /* 833 * No final status yet or final status not yet delivered 834 * to the device driver. Can't do path verfication now, 835 * delay until final status was delivered. 836 */ 837 cdev->private->flags.doverify = 1; 838 return; 839 } 840 /* Device is idle, we can do the path verification. */ 841 cdev->private->state = DEV_STATE_VERIFY; 842 cdev->private->flags.doverify = 0; 843 ccw_device_verify_start(cdev); 844 } 845 846 /* 847 * Got an interrupt for a normal io (state online). 848 */ 849 static void 850 ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event) 851 { 852 struct irb *irb; 853 854 irb = (struct irb *) __LC_IRB; 855 /* Check for unsolicited interrupt. */ 856 if ((irb->scsw.stctl == 857 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) 858 && (!irb->scsw.cc)) { 859 if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) && 860 !irb->esw.esw0.erw.cons) { 861 /* Unit check but no sense data. Need basic sense. */ 862 if (ccw_device_do_sense(cdev, irb) != 0) 863 goto call_handler_unsol; 864 memcpy(&cdev->private->irb, irb, sizeof(struct irb)); 865 cdev->private->state = DEV_STATE_W4SENSE; 866 cdev->private->intparm = 0; 867 return; 868 } 869 call_handler_unsol: 870 if (cdev->handler) 871 cdev->handler (cdev, 0, irb); 872 if (cdev->private->flags.doverify) 873 ccw_device_online_verify(cdev, 0); 874 return; 875 } 876 /* Accumulate status and find out if a basic sense is needed. */ 877 ccw_device_accumulate_irb(cdev, irb); 878 if (cdev->private->flags.dosense) { 879 if (ccw_device_do_sense(cdev, irb) == 0) { 880 cdev->private->state = DEV_STATE_W4SENSE; 881 } 882 return; 883 } 884 /* Call the handler. */ 885 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify) 886 /* Start delayed path verification. */ 887 ccw_device_online_verify(cdev, 0); 888 } 889 890 /* 891 * Got an timeout in online state. 892 */ 893 static void 894 ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event) 895 { 896 int ret; 897 898 ccw_device_set_timeout(cdev, 0); 899 ret = ccw_device_cancel_halt_clear(cdev); 900 if (ret == -EBUSY) { 901 ccw_device_set_timeout(cdev, 3*HZ); 902 cdev->private->state = DEV_STATE_TIMEOUT_KILL; 903 return; 904 } 905 if (ret == -ENODEV) { 906 struct subchannel *sch; 907 908 sch = to_subchannel(cdev->dev.parent); 909 if (!sch->lpm) { 910 PREPARE_WORK(&cdev->private->kick_work, 911 ccw_device_nopath_notify); 912 queue_work(ccw_device_notify_work, 913 &cdev->private->kick_work); 914 } else 915 dev_fsm_event(cdev, DEV_EVENT_NOTOPER); 916 } else if (cdev->handler) 917 cdev->handler(cdev, cdev->private->intparm, 918 ERR_PTR(-ETIMEDOUT)); 919 } 920 921 /* 922 * Got an interrupt for a basic sense. 923 */ 924 static void 925 ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event) 926 { 927 struct irb *irb; 928 929 irb = (struct irb *) __LC_IRB; 930 /* Check for unsolicited interrupt. */ 931 if (irb->scsw.stctl == 932 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) { 933 if (irb->scsw.cc == 1) 934 /* Basic sense hasn't started. Try again. */ 935 ccw_device_do_sense(cdev, irb); 936 else { 937 printk(KERN_INFO "Huh? %s(%s): unsolicited " 938 "interrupt...\n", 939 __FUNCTION__, cdev->dev.bus_id); 940 if (cdev->handler) 941 cdev->handler (cdev, 0, irb); 942 } 943 return; 944 } 945 /* 946 * Check if a halt or clear has been issued in the meanwhile. If yes, 947 * only deliver the halt/clear interrupt to the device driver as if it 948 * had killed the original request. 949 */ 950 if (irb->scsw.fctl & (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) { 951 /* Retry Basic Sense if requested. */ 952 if (cdev->private->flags.intretry) { 953 cdev->private->flags.intretry = 0; 954 ccw_device_do_sense(cdev, irb); 955 return; 956 } 957 cdev->private->flags.dosense = 0; 958 memset(&cdev->private->irb, 0, sizeof(struct irb)); 959 ccw_device_accumulate_irb(cdev, irb); 960 goto call_handler; 961 } 962 /* Add basic sense info to irb. */ 963 ccw_device_accumulate_basic_sense(cdev, irb); 964 if (cdev->private->flags.dosense) { 965 /* Another basic sense is needed. */ 966 ccw_device_do_sense(cdev, irb); 967 return; 968 } 969 call_handler: 970 cdev->private->state = DEV_STATE_ONLINE; 971 /* Call the handler. */ 972 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify) 973 /* Start delayed path verification. */ 974 ccw_device_online_verify(cdev, 0); 975 } 976 977 static void 978 ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event) 979 { 980 struct irb *irb; 981 982 irb = (struct irb *) __LC_IRB; 983 /* Accumulate status. We don't do basic sense. */ 984 ccw_device_accumulate_irb(cdev, irb); 985 /* Remember to clear irb to avoid residuals. */ 986 memset(&cdev->private->irb, 0, sizeof(struct irb)); 987 /* Try to start delayed device verification. */ 988 ccw_device_online_verify(cdev, 0); 989 /* Note: Don't call handler for cio initiated clear! */ 990 } 991 992 static void 993 ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event) 994 { 995 struct subchannel *sch; 996 997 sch = to_subchannel(cdev->dev.parent); 998 ccw_device_set_timeout(cdev, 0); 999 /* Start delayed path verification. */ 1000 ccw_device_online_verify(cdev, 0); 1001 /* OK, i/o is dead now. Call interrupt handler. */ 1002 if (cdev->handler) 1003 cdev->handler(cdev, cdev->private->intparm, 1004 ERR_PTR(-EIO)); 1005 } 1006 1007 static void 1008 ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event) 1009 { 1010 int ret; 1011 1012 ret = ccw_device_cancel_halt_clear(cdev); 1013 if (ret == -EBUSY) { 1014 ccw_device_set_timeout(cdev, 3*HZ); 1015 return; 1016 } 1017 /* Start delayed path verification. */ 1018 ccw_device_online_verify(cdev, 0); 1019 if (cdev->handler) 1020 cdev->handler(cdev, cdev->private->intparm, 1021 ERR_PTR(-EIO)); 1022 } 1023 1024 void device_kill_io(struct subchannel *sch) 1025 { 1026 int ret; 1027 struct ccw_device *cdev; 1028 1029 cdev = sch->dev.driver_data; 1030 ret = ccw_device_cancel_halt_clear(cdev); 1031 if (ret == -EBUSY) { 1032 ccw_device_set_timeout(cdev, 3*HZ); 1033 cdev->private->state = DEV_STATE_TIMEOUT_KILL; 1034 return; 1035 } 1036 /* Start delayed path verification. */ 1037 ccw_device_online_verify(cdev, 0); 1038 if (cdev->handler) 1039 cdev->handler(cdev, cdev->private->intparm, 1040 ERR_PTR(-EIO)); 1041 } 1042 1043 static void 1044 ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event) 1045 { 1046 /* Start verification after current task finished. */ 1047 cdev->private->flags.doverify = 1; 1048 } 1049 1050 static void 1051 ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event) 1052 { 1053 struct irb *irb; 1054 1055 switch (dev_event) { 1056 case DEV_EVENT_INTERRUPT: 1057 irb = (struct irb *) __LC_IRB; 1058 /* Check for unsolicited interrupt. */ 1059 if ((irb->scsw.stctl == 1060 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) && 1061 (!irb->scsw.cc)) 1062 /* FIXME: we should restart stlck here, but this 1063 * is extremely unlikely ... */ 1064 goto out_wakeup; 1065 1066 ccw_device_accumulate_irb(cdev, irb); 1067 /* We don't care about basic sense etc. */ 1068 break; 1069 default: /* timeout */ 1070 break; 1071 } 1072 out_wakeup: 1073 wake_up(&cdev->private->wait_q); 1074 } 1075 1076 static void 1077 ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event) 1078 { 1079 struct subchannel *sch; 1080 1081 sch = to_subchannel(cdev->dev.parent); 1082 if (cio_enable_subchannel(sch, sch->schib.pmcw.isc) != 0) 1083 /* Couldn't enable the subchannel for i/o. Sick device. */ 1084 return; 1085 1086 /* After 60s the device recognition is considered to have failed. */ 1087 ccw_device_set_timeout(cdev, 60*HZ); 1088 1089 cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID; 1090 ccw_device_sense_id_start(cdev); 1091 } 1092 1093 void 1094 device_trigger_reprobe(struct subchannel *sch) 1095 { 1096 struct ccw_device *cdev; 1097 1098 if (!sch->dev.driver_data) 1099 return; 1100 cdev = sch->dev.driver_data; 1101 if (cdev->private->state != DEV_STATE_DISCONNECTED) 1102 return; 1103 1104 /* Update some values. */ 1105 if (stsch(sch->schid, &sch->schib)) 1106 return; 1107 if (!sch->schib.pmcw.dnv) 1108 return; 1109 /* 1110 * The pim, pam, pom values may not be accurate, but they are the best 1111 * we have before performing device selection :/ 1112 */ 1113 sch->lpm = sch->schib.pmcw.pam & sch->opm; 1114 /* Re-set some bits in the pmcw that were lost. */ 1115 sch->schib.pmcw.isc = 3; 1116 sch->schib.pmcw.csense = 1; 1117 sch->schib.pmcw.ena = 0; 1118 if ((sch->lpm & (sch->lpm - 1)) != 0) 1119 sch->schib.pmcw.mp = 1; 1120 sch->schib.pmcw.intparm = (__u32)(unsigned long)sch; 1121 /* We should also udate ssd info, but this has to wait. */ 1122 /* Check if this is another device which appeared on the same sch. */ 1123 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) { 1124 PREPARE_WORK(&cdev->private->kick_work, 1125 ccw_device_move_to_orphanage); 1126 queue_work(ccw_device_work, &cdev->private->kick_work); 1127 } else 1128 ccw_device_start_id(cdev, 0); 1129 } 1130 1131 static void 1132 ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event) 1133 { 1134 struct subchannel *sch; 1135 1136 sch = to_subchannel(cdev->dev.parent); 1137 /* 1138 * An interrupt in state offline means a previous disable was not 1139 * successful. Try again. 1140 */ 1141 cio_disable_subchannel(sch); 1142 } 1143 1144 static void 1145 ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event) 1146 { 1147 retry_set_schib(cdev); 1148 cdev->private->state = DEV_STATE_ONLINE; 1149 dev_fsm_event(cdev, dev_event); 1150 } 1151 1152 static void ccw_device_update_cmfblock(struct ccw_device *cdev, 1153 enum dev_event dev_event) 1154 { 1155 cmf_retry_copy_block(cdev); 1156 cdev->private->state = DEV_STATE_ONLINE; 1157 dev_fsm_event(cdev, dev_event); 1158 } 1159 1160 static void 1161 ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event) 1162 { 1163 ccw_device_set_timeout(cdev, 0); 1164 if (dev_event == DEV_EVENT_NOTOPER) 1165 cdev->private->state = DEV_STATE_NOT_OPER; 1166 else 1167 cdev->private->state = DEV_STATE_OFFLINE; 1168 wake_up(&cdev->private->wait_q); 1169 } 1170 1171 static void 1172 ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event) 1173 { 1174 int ret; 1175 1176 ret = ccw_device_cancel_halt_clear(cdev); 1177 switch (ret) { 1178 case 0: 1179 cdev->private->state = DEV_STATE_OFFLINE; 1180 wake_up(&cdev->private->wait_q); 1181 break; 1182 case -ENODEV: 1183 cdev->private->state = DEV_STATE_NOT_OPER; 1184 wake_up(&cdev->private->wait_q); 1185 break; 1186 default: 1187 ccw_device_set_timeout(cdev, HZ/10); 1188 } 1189 } 1190 1191 /* 1192 * No operation action. This is used e.g. to ignore a timeout event in 1193 * state offline. 1194 */ 1195 static void 1196 ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event) 1197 { 1198 } 1199 1200 /* 1201 * Bug operation action. 1202 */ 1203 static void 1204 ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event) 1205 { 1206 printk(KERN_EMERG "dev_jumptable[%i][%i] == NULL\n", 1207 cdev->private->state, dev_event); 1208 BUG(); 1209 } 1210 1211 /* 1212 * device statemachine 1213 */ 1214 fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = { 1215 [DEV_STATE_NOT_OPER] = { 1216 [DEV_EVENT_NOTOPER] = ccw_device_nop, 1217 [DEV_EVENT_INTERRUPT] = ccw_device_bug, 1218 [DEV_EVENT_TIMEOUT] = ccw_device_nop, 1219 [DEV_EVENT_VERIFY] = ccw_device_nop, 1220 }, 1221 [DEV_STATE_SENSE_PGID] = { 1222 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1223 [DEV_EVENT_INTERRUPT] = ccw_device_sense_pgid_irq, 1224 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout, 1225 [DEV_EVENT_VERIFY] = ccw_device_nop, 1226 }, 1227 [DEV_STATE_SENSE_ID] = { 1228 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper, 1229 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq, 1230 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout, 1231 [DEV_EVENT_VERIFY] = ccw_device_nop, 1232 }, 1233 [DEV_STATE_OFFLINE] = { 1234 [DEV_EVENT_NOTOPER] = ccw_device_offline_notoper, 1235 [DEV_EVENT_INTERRUPT] = ccw_device_offline_irq, 1236 [DEV_EVENT_TIMEOUT] = ccw_device_nop, 1237 [DEV_EVENT_VERIFY] = ccw_device_nop, 1238 }, 1239 [DEV_STATE_VERIFY] = { 1240 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1241 [DEV_EVENT_INTERRUPT] = ccw_device_verify_irq, 1242 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout, 1243 [DEV_EVENT_VERIFY] = ccw_device_delay_verify, 1244 }, 1245 [DEV_STATE_ONLINE] = { 1246 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1247 [DEV_EVENT_INTERRUPT] = ccw_device_irq, 1248 [DEV_EVENT_TIMEOUT] = ccw_device_online_timeout, 1249 [DEV_EVENT_VERIFY] = ccw_device_online_verify, 1250 }, 1251 [DEV_STATE_W4SENSE] = { 1252 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1253 [DEV_EVENT_INTERRUPT] = ccw_device_w4sense, 1254 [DEV_EVENT_TIMEOUT] = ccw_device_nop, 1255 [DEV_EVENT_VERIFY] = ccw_device_online_verify, 1256 }, 1257 [DEV_STATE_DISBAND_PGID] = { 1258 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1259 [DEV_EVENT_INTERRUPT] = ccw_device_disband_irq, 1260 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout, 1261 [DEV_EVENT_VERIFY] = ccw_device_nop, 1262 }, 1263 [DEV_STATE_BOXED] = { 1264 [DEV_EVENT_NOTOPER] = ccw_device_offline_notoper, 1265 [DEV_EVENT_INTERRUPT] = ccw_device_stlck_done, 1266 [DEV_EVENT_TIMEOUT] = ccw_device_stlck_done, 1267 [DEV_EVENT_VERIFY] = ccw_device_nop, 1268 }, 1269 /* states to wait for i/o completion before doing something */ 1270 [DEV_STATE_CLEAR_VERIFY] = { 1271 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1272 [DEV_EVENT_INTERRUPT] = ccw_device_clear_verify, 1273 [DEV_EVENT_TIMEOUT] = ccw_device_nop, 1274 [DEV_EVENT_VERIFY] = ccw_device_nop, 1275 }, 1276 [DEV_STATE_TIMEOUT_KILL] = { 1277 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper, 1278 [DEV_EVENT_INTERRUPT] = ccw_device_killing_irq, 1279 [DEV_EVENT_TIMEOUT] = ccw_device_killing_timeout, 1280 [DEV_EVENT_VERIFY] = ccw_device_nop, //FIXME 1281 }, 1282 [DEV_STATE_QUIESCE] = { 1283 [DEV_EVENT_NOTOPER] = ccw_device_quiesce_done, 1284 [DEV_EVENT_INTERRUPT] = ccw_device_quiesce_done, 1285 [DEV_EVENT_TIMEOUT] = ccw_device_quiesce_timeout, 1286 [DEV_EVENT_VERIFY] = ccw_device_nop, 1287 }, 1288 /* special states for devices gone not operational */ 1289 [DEV_STATE_DISCONNECTED] = { 1290 [DEV_EVENT_NOTOPER] = ccw_device_nop, 1291 [DEV_EVENT_INTERRUPT] = ccw_device_start_id, 1292 [DEV_EVENT_TIMEOUT] = ccw_device_bug, 1293 [DEV_EVENT_VERIFY] = ccw_device_start_id, 1294 }, 1295 [DEV_STATE_DISCONNECTED_SENSE_ID] = { 1296 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper, 1297 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq, 1298 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout, 1299 [DEV_EVENT_VERIFY] = ccw_device_nop, 1300 }, 1301 [DEV_STATE_CMFCHANGE] = { 1302 [DEV_EVENT_NOTOPER] = ccw_device_change_cmfstate, 1303 [DEV_EVENT_INTERRUPT] = ccw_device_change_cmfstate, 1304 [DEV_EVENT_TIMEOUT] = ccw_device_change_cmfstate, 1305 [DEV_EVENT_VERIFY] = ccw_device_change_cmfstate, 1306 }, 1307 [DEV_STATE_CMFUPDATE] = { 1308 [DEV_EVENT_NOTOPER] = ccw_device_update_cmfblock, 1309 [DEV_EVENT_INTERRUPT] = ccw_device_update_cmfblock, 1310 [DEV_EVENT_TIMEOUT] = ccw_device_update_cmfblock, 1311 [DEV_EVENT_VERIFY] = ccw_device_update_cmfblock, 1312 }, 1313 }; 1314 1315 /* 1316 * io_subchannel_irq is called for "real" interrupts or for status 1317 * pending conditions on msch. 1318 */ 1319 void 1320 io_subchannel_irq (struct device *pdev) 1321 { 1322 struct ccw_device *cdev; 1323 1324 cdev = to_subchannel(pdev)->dev.driver_data; 1325 1326 CIO_TRACE_EVENT (3, "IRQ"); 1327 CIO_TRACE_EVENT (3, pdev->bus_id); 1328 if (cdev) 1329 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT); 1330 } 1331 1332 EXPORT_SYMBOL_GPL(ccw_device_set_timeout); 1333