1 /* 2 * drivers/s390/cio/device.c 3 * bus driver for ccw devices 4 * 5 * Copyright IBM Corp. 2002,2008 6 * Author(s): Arnd Bergmann (arndb@de.ibm.com) 7 * Cornelia Huck (cornelia.huck@de.ibm.com) 8 * Martin Schwidefsky (schwidefsky@de.ibm.com) 9 */ 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/spinlock.h> 13 #include <linux/errno.h> 14 #include <linux/err.h> 15 #include <linux/slab.h> 16 #include <linux/list.h> 17 #include <linux/device.h> 18 #include <linux/workqueue.h> 19 #include <linux/timer.h> 20 21 #include <asm/ccwdev.h> 22 #include <asm/cio.h> 23 #include <asm/param.h> /* HZ */ 24 #include <asm/cmb.h> 25 #include <asm/isc.h> 26 27 #include "chp.h" 28 #include "cio.h" 29 #include "cio_debug.h" 30 #include "css.h" 31 #include "device.h" 32 #include "ioasm.h" 33 #include "io_sch.h" 34 35 static struct timer_list recovery_timer; 36 static DEFINE_SPINLOCK(recovery_lock); 37 static int recovery_phase; 38 static const unsigned long recovery_delay[] = { 3, 30, 300 }; 39 40 /******************* bus type handling ***********************/ 41 42 /* The Linux driver model distinguishes between a bus type and 43 * the bus itself. Of course we only have one channel 44 * subsystem driver and one channel system per machine, but 45 * we still use the abstraction. T.R. says it's a good idea. */ 46 static int 47 ccw_bus_match (struct device * dev, struct device_driver * drv) 48 { 49 struct ccw_device *cdev = to_ccwdev(dev); 50 struct ccw_driver *cdrv = to_ccwdrv(drv); 51 const struct ccw_device_id *ids = cdrv->ids, *found; 52 53 if (!ids) 54 return 0; 55 56 found = ccw_device_id_match(ids, &cdev->id); 57 if (!found) 58 return 0; 59 60 cdev->id.driver_info = found->driver_info; 61 62 return 1; 63 } 64 65 /* Store modalias string delimited by prefix/suffix string into buffer with 66 * specified size. Return length of resulting string (excluding trailing '\0') 67 * even if string doesn't fit buffer (snprintf semantics). */ 68 static int snprint_alias(char *buf, size_t size, 69 struct ccw_device_id *id, const char *suffix) 70 { 71 int len; 72 73 len = snprintf(buf, size, "ccw:t%04Xm%02X", id->cu_type, id->cu_model); 74 if (len > size) 75 return len; 76 buf += len; 77 size -= len; 78 79 if (id->dev_type != 0) 80 len += snprintf(buf, size, "dt%04Xdm%02X%s", id->dev_type, 81 id->dev_model, suffix); 82 else 83 len += snprintf(buf, size, "dtdm%s", suffix); 84 85 return len; 86 } 87 88 /* Set up environment variables for ccw device uevent. Return 0 on success, 89 * non-zero otherwise. */ 90 static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env) 91 { 92 struct ccw_device *cdev = to_ccwdev(dev); 93 struct ccw_device_id *id = &(cdev->id); 94 int ret; 95 char modalias_buf[30]; 96 97 /* CU_TYPE= */ 98 ret = add_uevent_var(env, "CU_TYPE=%04X", id->cu_type); 99 if (ret) 100 return ret; 101 102 /* CU_MODEL= */ 103 ret = add_uevent_var(env, "CU_MODEL=%02X", id->cu_model); 104 if (ret) 105 return ret; 106 107 /* The next two can be zero, that's ok for us */ 108 /* DEV_TYPE= */ 109 ret = add_uevent_var(env, "DEV_TYPE=%04X", id->dev_type); 110 if (ret) 111 return ret; 112 113 /* DEV_MODEL= */ 114 ret = add_uevent_var(env, "DEV_MODEL=%02X", id->dev_model); 115 if (ret) 116 return ret; 117 118 /* MODALIAS= */ 119 snprint_alias(modalias_buf, sizeof(modalias_buf), id, ""); 120 ret = add_uevent_var(env, "MODALIAS=%s", modalias_buf); 121 return ret; 122 } 123 124 struct bus_type ccw_bus_type; 125 126 static void io_subchannel_irq(struct subchannel *); 127 static int io_subchannel_probe(struct subchannel *); 128 static int io_subchannel_remove(struct subchannel *); 129 static void io_subchannel_shutdown(struct subchannel *); 130 static int io_subchannel_sch_event(struct subchannel *, int); 131 static int io_subchannel_chp_event(struct subchannel *, struct chp_link *, 132 int); 133 134 static struct css_device_id io_subchannel_ids[] = { 135 { .match_flags = 0x1, .type = SUBCHANNEL_TYPE_IO, }, 136 { /* end of list */ }, 137 }; 138 MODULE_DEVICE_TABLE(css, io_subchannel_ids); 139 140 static struct css_driver io_subchannel_driver = { 141 .owner = THIS_MODULE, 142 .subchannel_type = io_subchannel_ids, 143 .name = "io_subchannel", 144 .irq = io_subchannel_irq, 145 .sch_event = io_subchannel_sch_event, 146 .chp_event = io_subchannel_chp_event, 147 .probe = io_subchannel_probe, 148 .remove = io_subchannel_remove, 149 .shutdown = io_subchannel_shutdown, 150 }; 151 152 struct workqueue_struct *ccw_device_work; 153 wait_queue_head_t ccw_device_init_wq; 154 atomic_t ccw_device_init_count; 155 156 static void recovery_func(unsigned long data); 157 158 static int __init 159 init_ccw_bus_type (void) 160 { 161 int ret; 162 163 init_waitqueue_head(&ccw_device_init_wq); 164 atomic_set(&ccw_device_init_count, 0); 165 setup_timer(&recovery_timer, recovery_func, 0); 166 167 ccw_device_work = create_singlethread_workqueue("cio"); 168 if (!ccw_device_work) 169 return -ENOMEM; /* FIXME: better errno ? */ 170 slow_path_wq = create_singlethread_workqueue("kslowcrw"); 171 if (!slow_path_wq) { 172 ret = -ENOMEM; /* FIXME: better errno ? */ 173 goto out_err; 174 } 175 if ((ret = bus_register (&ccw_bus_type))) 176 goto out_err; 177 178 ret = css_driver_register(&io_subchannel_driver); 179 if (ret) 180 goto out_err; 181 182 wait_event(ccw_device_init_wq, 183 atomic_read(&ccw_device_init_count) == 0); 184 flush_workqueue(ccw_device_work); 185 return 0; 186 out_err: 187 if (ccw_device_work) 188 destroy_workqueue(ccw_device_work); 189 if (slow_path_wq) 190 destroy_workqueue(slow_path_wq); 191 return ret; 192 } 193 194 static void __exit 195 cleanup_ccw_bus_type (void) 196 { 197 css_driver_unregister(&io_subchannel_driver); 198 bus_unregister(&ccw_bus_type); 199 destroy_workqueue(ccw_device_work); 200 } 201 202 subsys_initcall(init_ccw_bus_type); 203 module_exit(cleanup_ccw_bus_type); 204 205 /************************ device handling **************************/ 206 207 /* 208 * A ccw_device has some interfaces in sysfs in addition to the 209 * standard ones. 210 * The following entries are designed to export the information which 211 * resided in 2.4 in /proc/subchannels. Subchannel and device number 212 * are obvious, so they don't have an entry :) 213 * TODO: Split chpids and pimpampom up? Where is "in use" in the tree? 214 */ 215 static ssize_t 216 chpids_show (struct device * dev, struct device_attribute *attr, char * buf) 217 { 218 struct subchannel *sch = to_subchannel(dev); 219 struct chsc_ssd_info *ssd = &sch->ssd_info; 220 ssize_t ret = 0; 221 int chp; 222 int mask; 223 224 for (chp = 0; chp < 8; chp++) { 225 mask = 0x80 >> chp; 226 if (ssd->path_mask & mask) 227 ret += sprintf(buf + ret, "%02x ", ssd->chpid[chp].id); 228 else 229 ret += sprintf(buf + ret, "00 "); 230 } 231 ret += sprintf (buf+ret, "\n"); 232 return min((ssize_t)PAGE_SIZE, ret); 233 } 234 235 static ssize_t 236 pimpampom_show (struct device * dev, struct device_attribute *attr, char * buf) 237 { 238 struct subchannel *sch = to_subchannel(dev); 239 struct pmcw *pmcw = &sch->schib.pmcw; 240 241 return sprintf (buf, "%02x %02x %02x\n", 242 pmcw->pim, pmcw->pam, pmcw->pom); 243 } 244 245 static ssize_t 246 devtype_show (struct device *dev, struct device_attribute *attr, char *buf) 247 { 248 struct ccw_device *cdev = to_ccwdev(dev); 249 struct ccw_device_id *id = &(cdev->id); 250 251 if (id->dev_type != 0) 252 return sprintf(buf, "%04x/%02x\n", 253 id->dev_type, id->dev_model); 254 else 255 return sprintf(buf, "n/a\n"); 256 } 257 258 static ssize_t 259 cutype_show (struct device *dev, struct device_attribute *attr, char *buf) 260 { 261 struct ccw_device *cdev = to_ccwdev(dev); 262 struct ccw_device_id *id = &(cdev->id); 263 264 return sprintf(buf, "%04x/%02x\n", 265 id->cu_type, id->cu_model); 266 } 267 268 static ssize_t 269 modalias_show (struct device *dev, struct device_attribute *attr, char *buf) 270 { 271 struct ccw_device *cdev = to_ccwdev(dev); 272 struct ccw_device_id *id = &(cdev->id); 273 int len; 274 275 len = snprint_alias(buf, PAGE_SIZE, id, "\n"); 276 277 return len > PAGE_SIZE ? PAGE_SIZE : len; 278 } 279 280 static ssize_t 281 online_show (struct device *dev, struct device_attribute *attr, char *buf) 282 { 283 struct ccw_device *cdev = to_ccwdev(dev); 284 285 return sprintf(buf, cdev->online ? "1\n" : "0\n"); 286 } 287 288 int ccw_device_is_orphan(struct ccw_device *cdev) 289 { 290 return sch_is_pseudo_sch(to_subchannel(cdev->dev.parent)); 291 } 292 293 static void ccw_device_unregister(struct ccw_device *cdev) 294 { 295 if (test_and_clear_bit(1, &cdev->private->registered)) 296 device_del(&cdev->dev); 297 } 298 299 static void ccw_device_remove_orphan_cb(struct device *dev) 300 { 301 struct ccw_device *cdev = to_ccwdev(dev); 302 303 ccw_device_unregister(cdev); 304 put_device(&cdev->dev); 305 } 306 307 static void ccw_device_remove_sch_cb(struct device *dev) 308 { 309 struct subchannel *sch; 310 311 sch = to_subchannel(dev); 312 css_sch_device_unregister(sch); 313 /* Reset intparm to zeroes. */ 314 sch->schib.pmcw.intparm = 0; 315 cio_modify(sch); 316 put_device(&sch->dev); 317 } 318 319 static void 320 ccw_device_remove_disconnected(struct ccw_device *cdev) 321 { 322 unsigned long flags; 323 int rc; 324 325 /* 326 * Forced offline in disconnected state means 327 * 'throw away device'. 328 */ 329 if (ccw_device_is_orphan(cdev)) { 330 /* 331 * Deregister ccw device. 332 * Unfortunately, we cannot do this directly from the 333 * attribute method. 334 */ 335 spin_lock_irqsave(cdev->ccwlock, flags); 336 cdev->private->state = DEV_STATE_NOT_OPER; 337 spin_unlock_irqrestore(cdev->ccwlock, flags); 338 rc = device_schedule_callback(&cdev->dev, 339 ccw_device_remove_orphan_cb); 340 if (rc) 341 CIO_MSG_EVENT(0, "Couldn't unregister orphan " 342 "0.%x.%04x\n", 343 cdev->private->dev_id.ssid, 344 cdev->private->dev_id.devno); 345 return; 346 } 347 /* Deregister subchannel, which will kill the ccw device. */ 348 rc = device_schedule_callback(cdev->dev.parent, 349 ccw_device_remove_sch_cb); 350 if (rc) 351 CIO_MSG_EVENT(0, "Couldn't unregister disconnected device " 352 "0.%x.%04x\n", 353 cdev->private->dev_id.ssid, 354 cdev->private->dev_id.devno); 355 } 356 357 /** 358 * ccw_device_set_offline() - disable a ccw device for I/O 359 * @cdev: target ccw device 360 * 361 * This function calls the driver's set_offline() function for @cdev, if 362 * given, and then disables @cdev. 363 * Returns: 364 * %0 on success and a negative error value on failure. 365 * Context: 366 * enabled, ccw device lock not held 367 */ 368 int ccw_device_set_offline(struct ccw_device *cdev) 369 { 370 int ret; 371 372 if (!cdev) 373 return -ENODEV; 374 if (!cdev->online || !cdev->drv) 375 return -EINVAL; 376 377 if (cdev->drv->set_offline) { 378 ret = cdev->drv->set_offline(cdev); 379 if (ret != 0) 380 return ret; 381 } 382 cdev->online = 0; 383 spin_lock_irq(cdev->ccwlock); 384 ret = ccw_device_offline(cdev); 385 if (ret == -ENODEV) { 386 if (cdev->private->state != DEV_STATE_NOT_OPER) { 387 cdev->private->state = DEV_STATE_OFFLINE; 388 dev_fsm_event(cdev, DEV_EVENT_NOTOPER); 389 } 390 spin_unlock_irq(cdev->ccwlock); 391 return ret; 392 } 393 spin_unlock_irq(cdev->ccwlock); 394 if (ret == 0) 395 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev)); 396 else { 397 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, " 398 "device 0.%x.%04x\n", 399 ret, cdev->private->dev_id.ssid, 400 cdev->private->dev_id.devno); 401 cdev->online = 1; 402 } 403 return ret; 404 } 405 406 /** 407 * ccw_device_set_online() - enable a ccw device for I/O 408 * @cdev: target ccw device 409 * 410 * This function first enables @cdev and then calls the driver's set_online() 411 * function for @cdev, if given. If set_online() returns an error, @cdev is 412 * disabled again. 413 * Returns: 414 * %0 on success and a negative error value on failure. 415 * Context: 416 * enabled, ccw device lock not held 417 */ 418 int ccw_device_set_online(struct ccw_device *cdev) 419 { 420 int ret; 421 422 if (!cdev) 423 return -ENODEV; 424 if (cdev->online || !cdev->drv) 425 return -EINVAL; 426 427 spin_lock_irq(cdev->ccwlock); 428 ret = ccw_device_online(cdev); 429 spin_unlock_irq(cdev->ccwlock); 430 if (ret == 0) 431 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev)); 432 else { 433 CIO_MSG_EVENT(0, "ccw_device_online returned %d, " 434 "device 0.%x.%04x\n", 435 ret, cdev->private->dev_id.ssid, 436 cdev->private->dev_id.devno); 437 return ret; 438 } 439 if (cdev->private->state != DEV_STATE_ONLINE) 440 return -ENODEV; 441 if (!cdev->drv->set_online || cdev->drv->set_online(cdev) == 0) { 442 cdev->online = 1; 443 return 0; 444 } 445 spin_lock_irq(cdev->ccwlock); 446 ret = ccw_device_offline(cdev); 447 spin_unlock_irq(cdev->ccwlock); 448 if (ret == 0) 449 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev)); 450 else 451 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, " 452 "device 0.%x.%04x\n", 453 ret, cdev->private->dev_id.ssid, 454 cdev->private->dev_id.devno); 455 return (ret == 0) ? -ENODEV : ret; 456 } 457 458 static void online_store_handle_offline(struct ccw_device *cdev) 459 { 460 if (cdev->private->state == DEV_STATE_DISCONNECTED) 461 ccw_device_remove_disconnected(cdev); 462 else if (cdev->drv && cdev->drv->set_offline) 463 ccw_device_set_offline(cdev); 464 } 465 466 static int online_store_recog_and_online(struct ccw_device *cdev) 467 { 468 int ret; 469 470 /* Do device recognition, if needed. */ 471 if (cdev->id.cu_type == 0) { 472 ret = ccw_device_recognition(cdev); 473 if (ret) { 474 CIO_MSG_EVENT(0, "Couldn't start recognition " 475 "for device 0.%x.%04x (ret=%d)\n", 476 cdev->private->dev_id.ssid, 477 cdev->private->dev_id.devno, ret); 478 return ret; 479 } 480 wait_event(cdev->private->wait_q, 481 cdev->private->flags.recog_done); 482 } 483 if (cdev->drv && cdev->drv->set_online) 484 ccw_device_set_online(cdev); 485 return 0; 486 } 487 static int online_store_handle_online(struct ccw_device *cdev, int force) 488 { 489 int ret; 490 491 ret = online_store_recog_and_online(cdev); 492 if (ret) 493 return ret; 494 if (force && cdev->private->state == DEV_STATE_BOXED) { 495 ret = ccw_device_stlck(cdev); 496 if (ret) 497 return ret; 498 if (cdev->id.cu_type == 0) 499 cdev->private->state = DEV_STATE_NOT_OPER; 500 online_store_recog_and_online(cdev); 501 } 502 return 0; 503 } 504 505 static ssize_t online_store (struct device *dev, struct device_attribute *attr, 506 const char *buf, size_t count) 507 { 508 struct ccw_device *cdev = to_ccwdev(dev); 509 int force, ret; 510 unsigned long i; 511 512 if (atomic_cmpxchg(&cdev->private->onoff, 0, 1) != 0) 513 return -EAGAIN; 514 515 if (cdev->drv && !try_module_get(cdev->drv->owner)) { 516 atomic_set(&cdev->private->onoff, 0); 517 return -EINVAL; 518 } 519 if (!strncmp(buf, "force\n", count)) { 520 force = 1; 521 i = 1; 522 ret = 0; 523 } else { 524 force = 0; 525 ret = strict_strtoul(buf, 16, &i); 526 } 527 if (ret) 528 goto out; 529 switch (i) { 530 case 0: 531 online_store_handle_offline(cdev); 532 ret = count; 533 break; 534 case 1: 535 ret = online_store_handle_online(cdev, force); 536 if (!ret) 537 ret = count; 538 break; 539 default: 540 ret = -EINVAL; 541 } 542 out: 543 if (cdev->drv) 544 module_put(cdev->drv->owner); 545 atomic_set(&cdev->private->onoff, 0); 546 return ret; 547 } 548 549 static ssize_t 550 available_show (struct device *dev, struct device_attribute *attr, char *buf) 551 { 552 struct ccw_device *cdev = to_ccwdev(dev); 553 struct subchannel *sch; 554 555 if (ccw_device_is_orphan(cdev)) 556 return sprintf(buf, "no device\n"); 557 switch (cdev->private->state) { 558 case DEV_STATE_BOXED: 559 return sprintf(buf, "boxed\n"); 560 case DEV_STATE_DISCONNECTED: 561 case DEV_STATE_DISCONNECTED_SENSE_ID: 562 case DEV_STATE_NOT_OPER: 563 sch = to_subchannel(dev->parent); 564 if (!sch->lpm) 565 return sprintf(buf, "no path\n"); 566 else 567 return sprintf(buf, "no device\n"); 568 default: 569 /* All other states considered fine. */ 570 return sprintf(buf, "good\n"); 571 } 572 } 573 574 static DEVICE_ATTR(chpids, 0444, chpids_show, NULL); 575 static DEVICE_ATTR(pimpampom, 0444, pimpampom_show, NULL); 576 static DEVICE_ATTR(devtype, 0444, devtype_show, NULL); 577 static DEVICE_ATTR(cutype, 0444, cutype_show, NULL); 578 static DEVICE_ATTR(modalias, 0444, modalias_show, NULL); 579 static DEVICE_ATTR(online, 0644, online_show, online_store); 580 static DEVICE_ATTR(availability, 0444, available_show, NULL); 581 582 static struct attribute *io_subchannel_attrs[] = { 583 &dev_attr_chpids.attr, 584 &dev_attr_pimpampom.attr, 585 NULL, 586 }; 587 588 static struct attribute_group io_subchannel_attr_group = { 589 .attrs = io_subchannel_attrs, 590 }; 591 592 static struct attribute * ccwdev_attrs[] = { 593 &dev_attr_devtype.attr, 594 &dev_attr_cutype.attr, 595 &dev_attr_modalias.attr, 596 &dev_attr_online.attr, 597 &dev_attr_cmb_enable.attr, 598 &dev_attr_availability.attr, 599 NULL, 600 }; 601 602 static struct attribute_group ccwdev_attr_group = { 603 .attrs = ccwdev_attrs, 604 }; 605 606 static struct attribute_group *ccwdev_attr_groups[] = { 607 &ccwdev_attr_group, 608 NULL, 609 }; 610 611 /* this is a simple abstraction for device_register that sets the 612 * correct bus type and adds the bus specific files */ 613 static int ccw_device_register(struct ccw_device *cdev) 614 { 615 struct device *dev = &cdev->dev; 616 int ret; 617 618 dev->bus = &ccw_bus_type; 619 620 if ((ret = device_add(dev))) 621 return ret; 622 623 set_bit(1, &cdev->private->registered); 624 return ret; 625 } 626 627 struct match_data { 628 struct ccw_dev_id dev_id; 629 struct ccw_device * sibling; 630 }; 631 632 static int 633 match_devno(struct device * dev, void * data) 634 { 635 struct match_data * d = data; 636 struct ccw_device * cdev; 637 638 cdev = to_ccwdev(dev); 639 if ((cdev->private->state == DEV_STATE_DISCONNECTED) && 640 !ccw_device_is_orphan(cdev) && 641 ccw_dev_id_is_equal(&cdev->private->dev_id, &d->dev_id) && 642 (cdev != d->sibling)) 643 return 1; 644 return 0; 645 } 646 647 static struct ccw_device * get_disc_ccwdev_by_dev_id(struct ccw_dev_id *dev_id, 648 struct ccw_device *sibling) 649 { 650 struct device *dev; 651 struct match_data data; 652 653 data.dev_id = *dev_id; 654 data.sibling = sibling; 655 dev = bus_find_device(&ccw_bus_type, NULL, &data, match_devno); 656 657 return dev ? to_ccwdev(dev) : NULL; 658 } 659 660 static int match_orphan(struct device *dev, void *data) 661 { 662 struct ccw_dev_id *dev_id; 663 struct ccw_device *cdev; 664 665 dev_id = data; 666 cdev = to_ccwdev(dev); 667 return ccw_dev_id_is_equal(&cdev->private->dev_id, dev_id); 668 } 669 670 static struct ccw_device * 671 get_orphaned_ccwdev_by_dev_id(struct channel_subsystem *css, 672 struct ccw_dev_id *dev_id) 673 { 674 struct device *dev; 675 676 dev = device_find_child(&css->pseudo_subchannel->dev, dev_id, 677 match_orphan); 678 679 return dev ? to_ccwdev(dev) : NULL; 680 } 681 682 static void 683 ccw_device_add_changed(struct work_struct *work) 684 { 685 struct ccw_device_private *priv; 686 struct ccw_device *cdev; 687 688 priv = container_of(work, struct ccw_device_private, kick_work); 689 cdev = priv->cdev; 690 if (device_add(&cdev->dev)) { 691 put_device(&cdev->dev); 692 return; 693 } 694 set_bit(1, &cdev->private->registered); 695 } 696 697 void ccw_device_do_unreg_rereg(struct work_struct *work) 698 { 699 struct ccw_device_private *priv; 700 struct ccw_device *cdev; 701 struct subchannel *sch; 702 703 priv = container_of(work, struct ccw_device_private, kick_work); 704 cdev = priv->cdev; 705 sch = to_subchannel(cdev->dev.parent); 706 707 ccw_device_unregister(cdev); 708 PREPARE_WORK(&cdev->private->kick_work, 709 ccw_device_add_changed); 710 queue_work(ccw_device_work, &cdev->private->kick_work); 711 } 712 713 static void 714 ccw_device_release(struct device *dev) 715 { 716 struct ccw_device *cdev; 717 718 cdev = to_ccwdev(dev); 719 kfree(cdev->private); 720 kfree(cdev); 721 } 722 723 static struct ccw_device * io_subchannel_allocate_dev(struct subchannel *sch) 724 { 725 struct ccw_device *cdev; 726 727 cdev = kzalloc(sizeof(*cdev), GFP_KERNEL); 728 if (cdev) { 729 cdev->private = kzalloc(sizeof(struct ccw_device_private), 730 GFP_KERNEL | GFP_DMA); 731 if (cdev->private) 732 return cdev; 733 } 734 kfree(cdev); 735 return ERR_PTR(-ENOMEM); 736 } 737 738 static int io_subchannel_initialize_dev(struct subchannel *sch, 739 struct ccw_device *cdev) 740 { 741 cdev->private->cdev = cdev; 742 atomic_set(&cdev->private->onoff, 0); 743 cdev->dev.parent = &sch->dev; 744 cdev->dev.release = ccw_device_release; 745 INIT_WORK(&cdev->private->kick_work, NULL); 746 cdev->dev.groups = ccwdev_attr_groups; 747 /* Do first half of device_register. */ 748 device_initialize(&cdev->dev); 749 if (!get_device(&sch->dev)) { 750 if (cdev->dev.release) 751 cdev->dev.release(&cdev->dev); 752 return -ENODEV; 753 } 754 return 0; 755 } 756 757 static struct ccw_device * io_subchannel_create_ccwdev(struct subchannel *sch) 758 { 759 struct ccw_device *cdev; 760 int ret; 761 762 cdev = io_subchannel_allocate_dev(sch); 763 if (!IS_ERR(cdev)) { 764 ret = io_subchannel_initialize_dev(sch, cdev); 765 if (ret) { 766 kfree(cdev); 767 cdev = ERR_PTR(ret); 768 } 769 } 770 return cdev; 771 } 772 773 static int io_subchannel_recog(struct ccw_device *, struct subchannel *); 774 775 static void sch_attach_device(struct subchannel *sch, 776 struct ccw_device *cdev) 777 { 778 css_update_ssd_info(sch); 779 spin_lock_irq(sch->lock); 780 sch_set_cdev(sch, cdev); 781 cdev->private->schid = sch->schid; 782 cdev->ccwlock = sch->lock; 783 ccw_device_trigger_reprobe(cdev); 784 spin_unlock_irq(sch->lock); 785 } 786 787 static void sch_attach_disconnected_device(struct subchannel *sch, 788 struct ccw_device *cdev) 789 { 790 struct subchannel *other_sch; 791 int ret; 792 793 other_sch = to_subchannel(get_device(cdev->dev.parent)); 794 ret = device_move(&cdev->dev, &sch->dev); 795 if (ret) { 796 CIO_MSG_EVENT(0, "Moving disconnected device 0.%x.%04x failed " 797 "(ret=%d)!\n", cdev->private->dev_id.ssid, 798 cdev->private->dev_id.devno, ret); 799 put_device(&other_sch->dev); 800 return; 801 } 802 sch_set_cdev(other_sch, NULL); 803 /* No need to keep a subchannel without ccw device around. */ 804 css_sch_device_unregister(other_sch); 805 put_device(&other_sch->dev); 806 sch_attach_device(sch, cdev); 807 } 808 809 static void sch_attach_orphaned_device(struct subchannel *sch, 810 struct ccw_device *cdev) 811 { 812 int ret; 813 814 /* Try to move the ccw device to its new subchannel. */ 815 ret = device_move(&cdev->dev, &sch->dev); 816 if (ret) { 817 CIO_MSG_EVENT(0, "Moving device 0.%x.%04x from orphanage " 818 "failed (ret=%d)!\n", 819 cdev->private->dev_id.ssid, 820 cdev->private->dev_id.devno, ret); 821 return; 822 } 823 sch_attach_device(sch, cdev); 824 } 825 826 static void sch_create_and_recog_new_device(struct subchannel *sch) 827 { 828 struct ccw_device *cdev; 829 830 /* Need to allocate a new ccw device. */ 831 cdev = io_subchannel_create_ccwdev(sch); 832 if (IS_ERR(cdev)) { 833 /* OK, we did everything we could... */ 834 css_sch_device_unregister(sch); 835 return; 836 } 837 spin_lock_irq(sch->lock); 838 sch_set_cdev(sch, cdev); 839 spin_unlock_irq(sch->lock); 840 /* Start recognition for the new ccw device. */ 841 if (io_subchannel_recog(cdev, sch)) { 842 spin_lock_irq(sch->lock); 843 sch_set_cdev(sch, NULL); 844 spin_unlock_irq(sch->lock); 845 if (cdev->dev.release) 846 cdev->dev.release(&cdev->dev); 847 css_sch_device_unregister(sch); 848 } 849 } 850 851 852 void ccw_device_move_to_orphanage(struct work_struct *work) 853 { 854 struct ccw_device_private *priv; 855 struct ccw_device *cdev; 856 struct ccw_device *replacing_cdev; 857 struct subchannel *sch; 858 int ret; 859 struct channel_subsystem *css; 860 struct ccw_dev_id dev_id; 861 862 priv = container_of(work, struct ccw_device_private, kick_work); 863 cdev = priv->cdev; 864 sch = to_subchannel(cdev->dev.parent); 865 css = to_css(sch->dev.parent); 866 dev_id.devno = sch->schib.pmcw.dev; 867 dev_id.ssid = sch->schid.ssid; 868 869 /* 870 * Move the orphaned ccw device to the orphanage so the replacing 871 * ccw device can take its place on the subchannel. 872 */ 873 ret = device_move(&cdev->dev, &css->pseudo_subchannel->dev); 874 if (ret) { 875 CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to orphanage failed " 876 "(ret=%d)!\n", cdev->private->dev_id.ssid, 877 cdev->private->dev_id.devno, ret); 878 return; 879 } 880 cdev->ccwlock = css->pseudo_subchannel->lock; 881 /* 882 * Search for the replacing ccw device 883 * - among the disconnected devices 884 * - in the orphanage 885 */ 886 replacing_cdev = get_disc_ccwdev_by_dev_id(&dev_id, cdev); 887 if (replacing_cdev) { 888 sch_attach_disconnected_device(sch, replacing_cdev); 889 return; 890 } 891 replacing_cdev = get_orphaned_ccwdev_by_dev_id(css, &dev_id); 892 if (replacing_cdev) { 893 sch_attach_orphaned_device(sch, replacing_cdev); 894 return; 895 } 896 sch_create_and_recog_new_device(sch); 897 } 898 899 /* 900 * Register recognized device. 901 */ 902 static void 903 io_subchannel_register(struct work_struct *work) 904 { 905 struct ccw_device_private *priv; 906 struct ccw_device *cdev; 907 struct subchannel *sch; 908 int ret; 909 unsigned long flags; 910 911 priv = container_of(work, struct ccw_device_private, kick_work); 912 cdev = priv->cdev; 913 sch = to_subchannel(cdev->dev.parent); 914 css_update_ssd_info(sch); 915 /* 916 * io_subchannel_register() will also be called after device 917 * recognition has been done for a boxed device (which will already 918 * be registered). We need to reprobe since we may now have sense id 919 * information. 920 */ 921 if (klist_node_attached(&cdev->dev.knode_parent)) { 922 if (!cdev->drv) { 923 ret = device_reprobe(&cdev->dev); 924 if (ret) 925 /* We can't do much here. */ 926 CIO_MSG_EVENT(0, "device_reprobe() returned" 927 " %d for 0.%x.%04x\n", ret, 928 cdev->private->dev_id.ssid, 929 cdev->private->dev_id.devno); 930 } 931 goto out; 932 } 933 /* 934 * Now we know this subchannel will stay, we can throw 935 * our delayed uevent. 936 */ 937 sch->dev.uevent_suppress = 0; 938 kobject_uevent(&sch->dev.kobj, KOBJ_ADD); 939 /* make it known to the system */ 940 ret = ccw_device_register(cdev); 941 if (ret) { 942 CIO_MSG_EVENT(0, "Could not register ccw dev 0.%x.%04x: %d\n", 943 cdev->private->dev_id.ssid, 944 cdev->private->dev_id.devno, ret); 945 put_device(&cdev->dev); 946 spin_lock_irqsave(sch->lock, flags); 947 sch_set_cdev(sch, NULL); 948 spin_unlock_irqrestore(sch->lock, flags); 949 kfree (cdev->private); 950 kfree (cdev); 951 put_device(&sch->dev); 952 if (atomic_dec_and_test(&ccw_device_init_count)) 953 wake_up(&ccw_device_init_wq); 954 return; 955 } 956 put_device(&cdev->dev); 957 out: 958 cdev->private->flags.recog_done = 1; 959 put_device(&sch->dev); 960 wake_up(&cdev->private->wait_q); 961 if (atomic_dec_and_test(&ccw_device_init_count)) 962 wake_up(&ccw_device_init_wq); 963 } 964 965 static void ccw_device_call_sch_unregister(struct work_struct *work) 966 { 967 struct ccw_device_private *priv; 968 struct ccw_device *cdev; 969 struct subchannel *sch; 970 971 priv = container_of(work, struct ccw_device_private, kick_work); 972 cdev = priv->cdev; 973 sch = to_subchannel(cdev->dev.parent); 974 css_sch_device_unregister(sch); 975 /* Reset intparm to zeroes. */ 976 sch->schib.pmcw.intparm = 0; 977 cio_modify(sch); 978 put_device(&cdev->dev); 979 put_device(&sch->dev); 980 } 981 982 /* 983 * subchannel recognition done. Called from the state machine. 984 */ 985 void 986 io_subchannel_recog_done(struct ccw_device *cdev) 987 { 988 struct subchannel *sch; 989 990 if (css_init_done == 0) { 991 cdev->private->flags.recog_done = 1; 992 return; 993 } 994 switch (cdev->private->state) { 995 case DEV_STATE_NOT_OPER: 996 cdev->private->flags.recog_done = 1; 997 /* Remove device found not operational. */ 998 if (!get_device(&cdev->dev)) 999 break; 1000 sch = to_subchannel(cdev->dev.parent); 1001 PREPARE_WORK(&cdev->private->kick_work, 1002 ccw_device_call_sch_unregister); 1003 queue_work(slow_path_wq, &cdev->private->kick_work); 1004 if (atomic_dec_and_test(&ccw_device_init_count)) 1005 wake_up(&ccw_device_init_wq); 1006 break; 1007 case DEV_STATE_BOXED: 1008 /* Device did not respond in time. */ 1009 case DEV_STATE_OFFLINE: 1010 /* 1011 * We can't register the device in interrupt context so 1012 * we schedule a work item. 1013 */ 1014 if (!get_device(&cdev->dev)) 1015 break; 1016 PREPARE_WORK(&cdev->private->kick_work, 1017 io_subchannel_register); 1018 queue_work(slow_path_wq, &cdev->private->kick_work); 1019 break; 1020 } 1021 } 1022 1023 static int 1024 io_subchannel_recog(struct ccw_device *cdev, struct subchannel *sch) 1025 { 1026 int rc; 1027 struct ccw_device_private *priv; 1028 1029 sch_set_cdev(sch, cdev); 1030 cdev->ccwlock = sch->lock; 1031 1032 /* Init private data. */ 1033 priv = cdev->private; 1034 priv->dev_id.devno = sch->schib.pmcw.dev; 1035 priv->dev_id.ssid = sch->schid.ssid; 1036 priv->schid = sch->schid; 1037 priv->state = DEV_STATE_NOT_OPER; 1038 INIT_LIST_HEAD(&priv->cmb_list); 1039 init_waitqueue_head(&priv->wait_q); 1040 init_timer(&priv->timer); 1041 1042 /* Set an initial name for the device. */ 1043 snprintf (cdev->dev.bus_id, BUS_ID_SIZE, "0.%x.%04x", 1044 sch->schid.ssid, sch->schib.pmcw.dev); 1045 1046 /* Increase counter of devices currently in recognition. */ 1047 atomic_inc(&ccw_device_init_count); 1048 1049 /* Start async. device sensing. */ 1050 spin_lock_irq(sch->lock); 1051 rc = ccw_device_recognition(cdev); 1052 spin_unlock_irq(sch->lock); 1053 if (rc) { 1054 if (atomic_dec_and_test(&ccw_device_init_count)) 1055 wake_up(&ccw_device_init_wq); 1056 } 1057 return rc; 1058 } 1059 1060 static void ccw_device_move_to_sch(struct work_struct *work) 1061 { 1062 struct ccw_device_private *priv; 1063 int rc; 1064 struct subchannel *sch; 1065 struct ccw_device *cdev; 1066 struct subchannel *former_parent; 1067 1068 priv = container_of(work, struct ccw_device_private, kick_work); 1069 sch = priv->sch; 1070 cdev = priv->cdev; 1071 former_parent = ccw_device_is_orphan(cdev) ? 1072 NULL : to_subchannel(get_device(cdev->dev.parent)); 1073 mutex_lock(&sch->reg_mutex); 1074 /* Try to move the ccw device to its new subchannel. */ 1075 rc = device_move(&cdev->dev, &sch->dev); 1076 mutex_unlock(&sch->reg_mutex); 1077 if (rc) { 1078 CIO_MSG_EVENT(0, "Moving device 0.%x.%04x to subchannel " 1079 "0.%x.%04x failed (ret=%d)!\n", 1080 cdev->private->dev_id.ssid, 1081 cdev->private->dev_id.devno, sch->schid.ssid, 1082 sch->schid.sch_no, rc); 1083 css_sch_device_unregister(sch); 1084 goto out; 1085 } 1086 if (former_parent) { 1087 spin_lock_irq(former_parent->lock); 1088 sch_set_cdev(former_parent, NULL); 1089 spin_unlock_irq(former_parent->lock); 1090 css_sch_device_unregister(former_parent); 1091 /* Reset intparm to zeroes. */ 1092 former_parent->schib.pmcw.intparm = 0; 1093 cio_modify(former_parent); 1094 } 1095 sch_attach_device(sch, cdev); 1096 out: 1097 if (former_parent) 1098 put_device(&former_parent->dev); 1099 put_device(&cdev->dev); 1100 } 1101 1102 static void io_subchannel_irq(struct subchannel *sch) 1103 { 1104 struct ccw_device *cdev; 1105 1106 cdev = sch_get_cdev(sch); 1107 1108 CIO_TRACE_EVENT(3, "IRQ"); 1109 CIO_TRACE_EVENT(3, sch->dev.bus_id); 1110 if (cdev) 1111 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT); 1112 } 1113 1114 static void io_subchannel_init_fields(struct subchannel *sch) 1115 { 1116 if (cio_is_console(sch->schid)) 1117 sch->opm = 0xff; 1118 else 1119 sch->opm = chp_get_sch_opm(sch); 1120 sch->lpm = sch->schib.pmcw.pam & sch->opm; 1121 sch->isc = cio_is_console(sch->schid) ? CONSOLE_ISC : IO_SCH_ISC; 1122 1123 CIO_MSG_EVENT(6, "Detected device %04x on subchannel 0.%x.%04X" 1124 " - PIM = %02X, PAM = %02X, POM = %02X\n", 1125 sch->schib.pmcw.dev, sch->schid.ssid, 1126 sch->schid.sch_no, sch->schib.pmcw.pim, 1127 sch->schib.pmcw.pam, sch->schib.pmcw.pom); 1128 /* Initially set up some fields in the pmcw. */ 1129 sch->schib.pmcw.ena = 0; 1130 sch->schib.pmcw.csense = 1; /* concurrent sense */ 1131 if ((sch->lpm & (sch->lpm - 1)) != 0) 1132 sch->schib.pmcw.mp = 1; /* multipath mode */ 1133 /* clean up possible residual cmf stuff */ 1134 sch->schib.pmcw.mme = 0; 1135 sch->schib.pmcw.mbfc = 0; 1136 sch->schib.pmcw.mbi = 0; 1137 sch->schib.mba = 0; 1138 } 1139 1140 static int io_subchannel_probe(struct subchannel *sch) 1141 { 1142 struct ccw_device *cdev; 1143 int rc; 1144 unsigned long flags; 1145 struct ccw_dev_id dev_id; 1146 1147 cdev = sch_get_cdev(sch); 1148 if (cdev) { 1149 rc = sysfs_create_group(&sch->dev.kobj, 1150 &io_subchannel_attr_group); 1151 if (rc) 1152 CIO_MSG_EVENT(0, "Failed to create io subchannel " 1153 "attributes for subchannel " 1154 "0.%x.%04x (rc=%d)\n", 1155 sch->schid.ssid, sch->schid.sch_no, rc); 1156 /* 1157 * This subchannel already has an associated ccw_device. 1158 * Throw the delayed uevent for the subchannel, register 1159 * the ccw_device and exit. This happens for all early 1160 * devices, e.g. the console. 1161 */ 1162 sch->dev.uevent_suppress = 0; 1163 kobject_uevent(&sch->dev.kobj, KOBJ_ADD); 1164 cdev->dev.groups = ccwdev_attr_groups; 1165 device_initialize(&cdev->dev); 1166 ccw_device_register(cdev); 1167 /* 1168 * Check if the device is already online. If it is 1169 * the reference count needs to be corrected 1170 * (see ccw_device_online and css_init_done for the 1171 * ugly details). 1172 */ 1173 if (cdev->private->state != DEV_STATE_NOT_OPER && 1174 cdev->private->state != DEV_STATE_OFFLINE && 1175 cdev->private->state != DEV_STATE_BOXED) 1176 get_device(&cdev->dev); 1177 return 0; 1178 } 1179 io_subchannel_init_fields(sch); 1180 /* 1181 * First check if a fitting device may be found amongst the 1182 * disconnected devices or in the orphanage. 1183 */ 1184 dev_id.devno = sch->schib.pmcw.dev; 1185 dev_id.ssid = sch->schid.ssid; 1186 rc = sysfs_create_group(&sch->dev.kobj, 1187 &io_subchannel_attr_group); 1188 if (rc) 1189 return rc; 1190 /* Allocate I/O subchannel private data. */ 1191 sch->private = kzalloc(sizeof(struct io_subchannel_private), 1192 GFP_KERNEL | GFP_DMA); 1193 if (!sch->private) { 1194 rc = -ENOMEM; 1195 goto out_err; 1196 } 1197 cdev = get_disc_ccwdev_by_dev_id(&dev_id, NULL); 1198 if (!cdev) 1199 cdev = get_orphaned_ccwdev_by_dev_id(to_css(sch->dev.parent), 1200 &dev_id); 1201 if (cdev) { 1202 /* 1203 * Schedule moving the device until when we have a registered 1204 * subchannel to move to and succeed the probe. We can 1205 * unregister later again, when the probe is through. 1206 */ 1207 cdev->private->sch = sch; 1208 PREPARE_WORK(&cdev->private->kick_work, 1209 ccw_device_move_to_sch); 1210 queue_work(slow_path_wq, &cdev->private->kick_work); 1211 return 0; 1212 } 1213 cdev = io_subchannel_create_ccwdev(sch); 1214 if (IS_ERR(cdev)) { 1215 rc = PTR_ERR(cdev); 1216 goto out_err; 1217 } 1218 rc = io_subchannel_recog(cdev, sch); 1219 if (rc) { 1220 spin_lock_irqsave(sch->lock, flags); 1221 sch_set_cdev(sch, NULL); 1222 spin_unlock_irqrestore(sch->lock, flags); 1223 if (cdev->dev.release) 1224 cdev->dev.release(&cdev->dev); 1225 goto out_err; 1226 } 1227 return 0; 1228 out_err: 1229 kfree(sch->private); 1230 sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group); 1231 return rc; 1232 } 1233 1234 static int 1235 io_subchannel_remove (struct subchannel *sch) 1236 { 1237 struct ccw_device *cdev; 1238 unsigned long flags; 1239 1240 cdev = sch_get_cdev(sch); 1241 if (!cdev) 1242 return 0; 1243 /* Set ccw device to not operational and drop reference. */ 1244 spin_lock_irqsave(cdev->ccwlock, flags); 1245 sch_set_cdev(sch, NULL); 1246 cdev->private->state = DEV_STATE_NOT_OPER; 1247 spin_unlock_irqrestore(cdev->ccwlock, flags); 1248 ccw_device_unregister(cdev); 1249 put_device(&cdev->dev); 1250 kfree(sch->private); 1251 sysfs_remove_group(&sch->dev.kobj, &io_subchannel_attr_group); 1252 return 0; 1253 } 1254 1255 static int io_subchannel_notify(struct subchannel *sch, int event) 1256 { 1257 struct ccw_device *cdev; 1258 1259 cdev = sch_get_cdev(sch); 1260 if (!cdev) 1261 return 0; 1262 return ccw_device_notify(cdev, event); 1263 } 1264 1265 static void io_subchannel_verify(struct subchannel *sch) 1266 { 1267 struct ccw_device *cdev; 1268 1269 cdev = sch_get_cdev(sch); 1270 if (cdev) 1271 dev_fsm_event(cdev, DEV_EVENT_VERIFY); 1272 } 1273 1274 static int check_for_io_on_path(struct subchannel *sch, int mask) 1275 { 1276 int cc; 1277 1278 cc = stsch(sch->schid, &sch->schib); 1279 if (cc) 1280 return 0; 1281 if (scsw_actl(&sch->schib.scsw) && sch->schib.pmcw.lpum == mask) 1282 return 1; 1283 return 0; 1284 } 1285 1286 static void terminate_internal_io(struct subchannel *sch, 1287 struct ccw_device *cdev) 1288 { 1289 if (cio_clear(sch)) { 1290 /* Recheck device in case clear failed. */ 1291 sch->lpm = 0; 1292 if (cdev->online) 1293 dev_fsm_event(cdev, DEV_EVENT_VERIFY); 1294 else 1295 css_schedule_eval(sch->schid); 1296 return; 1297 } 1298 cdev->private->state = DEV_STATE_CLEAR_VERIFY; 1299 /* Request retry of internal operation. */ 1300 cdev->private->flags.intretry = 1; 1301 /* Call handler. */ 1302 if (cdev->handler) 1303 cdev->handler(cdev, cdev->private->intparm, 1304 ERR_PTR(-EIO)); 1305 } 1306 1307 static void io_subchannel_terminate_path(struct subchannel *sch, u8 mask) 1308 { 1309 struct ccw_device *cdev; 1310 1311 cdev = sch_get_cdev(sch); 1312 if (!cdev) 1313 return; 1314 if (check_for_io_on_path(sch, mask)) { 1315 if (cdev->private->state == DEV_STATE_ONLINE) 1316 ccw_device_kill_io(cdev); 1317 else { 1318 terminate_internal_io(sch, cdev); 1319 /* Re-start path verification. */ 1320 dev_fsm_event(cdev, DEV_EVENT_VERIFY); 1321 } 1322 } else 1323 /* trigger path verification. */ 1324 dev_fsm_event(cdev, DEV_EVENT_VERIFY); 1325 1326 } 1327 1328 static int io_subchannel_chp_event(struct subchannel *sch, 1329 struct chp_link *link, int event) 1330 { 1331 int mask; 1332 1333 mask = chp_ssd_get_mask(&sch->ssd_info, link); 1334 if (!mask) 1335 return 0; 1336 switch (event) { 1337 case CHP_VARY_OFF: 1338 sch->opm &= ~mask; 1339 sch->lpm &= ~mask; 1340 io_subchannel_terminate_path(sch, mask); 1341 break; 1342 case CHP_VARY_ON: 1343 sch->opm |= mask; 1344 sch->lpm |= mask; 1345 io_subchannel_verify(sch); 1346 break; 1347 case CHP_OFFLINE: 1348 if (stsch(sch->schid, &sch->schib)) 1349 return -ENXIO; 1350 if (!css_sch_is_valid(&sch->schib)) 1351 return -ENODEV; 1352 io_subchannel_terminate_path(sch, mask); 1353 break; 1354 case CHP_ONLINE: 1355 if (stsch(sch->schid, &sch->schib)) 1356 return -ENXIO; 1357 sch->lpm |= mask & sch->opm; 1358 io_subchannel_verify(sch); 1359 break; 1360 } 1361 return 0; 1362 } 1363 1364 static void 1365 io_subchannel_shutdown(struct subchannel *sch) 1366 { 1367 struct ccw_device *cdev; 1368 int ret; 1369 1370 cdev = sch_get_cdev(sch); 1371 1372 if (cio_is_console(sch->schid)) 1373 return; 1374 if (!sch->schib.pmcw.ena) 1375 /* Nothing to do. */ 1376 return; 1377 ret = cio_disable_subchannel(sch); 1378 if (ret != -EBUSY) 1379 /* Subchannel is disabled, we're done. */ 1380 return; 1381 cdev->private->state = DEV_STATE_QUIESCE; 1382 if (cdev->handler) 1383 cdev->handler(cdev, cdev->private->intparm, 1384 ERR_PTR(-EIO)); 1385 ret = ccw_device_cancel_halt_clear(cdev); 1386 if (ret == -EBUSY) { 1387 ccw_device_set_timeout(cdev, HZ/10); 1388 wait_event(cdev->private->wait_q, dev_fsm_final_state(cdev)); 1389 } 1390 cio_disable_subchannel(sch); 1391 } 1392 1393 static int io_subchannel_get_status(struct subchannel *sch) 1394 { 1395 struct schib schib; 1396 1397 if (stsch(sch->schid, &schib) || !schib.pmcw.dnv) 1398 return CIO_GONE; 1399 if (sch->schib.pmcw.dnv && (schib.pmcw.dev != sch->schib.pmcw.dev)) 1400 return CIO_REVALIDATE; 1401 if (!sch->lpm) 1402 return CIO_NO_PATH; 1403 return CIO_OPER; 1404 } 1405 1406 static int device_is_disconnected(struct ccw_device *cdev) 1407 { 1408 if (!cdev) 1409 return 0; 1410 return (cdev->private->state == DEV_STATE_DISCONNECTED || 1411 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID); 1412 } 1413 1414 static int recovery_check(struct device *dev, void *data) 1415 { 1416 struct ccw_device *cdev = to_ccwdev(dev); 1417 int *redo = data; 1418 1419 spin_lock_irq(cdev->ccwlock); 1420 switch (cdev->private->state) { 1421 case DEV_STATE_DISCONNECTED: 1422 CIO_MSG_EVENT(3, "recovery: trigger 0.%x.%04x\n", 1423 cdev->private->dev_id.ssid, 1424 cdev->private->dev_id.devno); 1425 dev_fsm_event(cdev, DEV_EVENT_VERIFY); 1426 *redo = 1; 1427 break; 1428 case DEV_STATE_DISCONNECTED_SENSE_ID: 1429 *redo = 1; 1430 break; 1431 } 1432 spin_unlock_irq(cdev->ccwlock); 1433 1434 return 0; 1435 } 1436 1437 static void recovery_work_func(struct work_struct *unused) 1438 { 1439 int redo = 0; 1440 1441 bus_for_each_dev(&ccw_bus_type, NULL, &redo, recovery_check); 1442 if (redo) { 1443 spin_lock_irq(&recovery_lock); 1444 if (!timer_pending(&recovery_timer)) { 1445 if (recovery_phase < ARRAY_SIZE(recovery_delay) - 1) 1446 recovery_phase++; 1447 mod_timer(&recovery_timer, jiffies + 1448 recovery_delay[recovery_phase] * HZ); 1449 } 1450 spin_unlock_irq(&recovery_lock); 1451 } else 1452 CIO_MSG_EVENT(4, "recovery: end\n"); 1453 } 1454 1455 static DECLARE_WORK(recovery_work, recovery_work_func); 1456 1457 static void recovery_func(unsigned long data) 1458 { 1459 /* 1460 * We can't do our recovery in softirq context and it's not 1461 * performance critical, so we schedule it. 1462 */ 1463 schedule_work(&recovery_work); 1464 } 1465 1466 static void ccw_device_schedule_recovery(void) 1467 { 1468 unsigned long flags; 1469 1470 CIO_MSG_EVENT(4, "recovery: schedule\n"); 1471 spin_lock_irqsave(&recovery_lock, flags); 1472 if (!timer_pending(&recovery_timer) || (recovery_phase != 0)) { 1473 recovery_phase = 0; 1474 mod_timer(&recovery_timer, jiffies + recovery_delay[0] * HZ); 1475 } 1476 spin_unlock_irqrestore(&recovery_lock, flags); 1477 } 1478 1479 static void device_set_disconnected(struct ccw_device *cdev) 1480 { 1481 if (!cdev) 1482 return; 1483 ccw_device_set_timeout(cdev, 0); 1484 cdev->private->flags.fake_irb = 0; 1485 cdev->private->state = DEV_STATE_DISCONNECTED; 1486 if (cdev->online) 1487 ccw_device_schedule_recovery(); 1488 } 1489 1490 void ccw_device_set_notoper(struct ccw_device *cdev) 1491 { 1492 struct subchannel *sch = to_subchannel(cdev->dev.parent); 1493 1494 CIO_TRACE_EVENT(2, "notoper"); 1495 CIO_TRACE_EVENT(2, sch->dev.bus_id); 1496 ccw_device_set_timeout(cdev, 0); 1497 cio_disable_subchannel(sch); 1498 cdev->private->state = DEV_STATE_NOT_OPER; 1499 } 1500 1501 static int io_subchannel_sch_event(struct subchannel *sch, int slow) 1502 { 1503 int event, ret, disc; 1504 unsigned long flags; 1505 enum { NONE, UNREGISTER, UNREGISTER_PROBE, REPROBE, DISC } action; 1506 struct ccw_device *cdev; 1507 1508 spin_lock_irqsave(sch->lock, flags); 1509 cdev = sch_get_cdev(sch); 1510 disc = device_is_disconnected(cdev); 1511 if (disc && slow) { 1512 /* Disconnected devices are evaluated directly only.*/ 1513 spin_unlock_irqrestore(sch->lock, flags); 1514 return 0; 1515 } 1516 /* No interrupt after machine check - kill pending timers. */ 1517 if (cdev) 1518 ccw_device_set_timeout(cdev, 0); 1519 if (!disc && !slow) { 1520 /* Non-disconnected devices are evaluated on the slow path. */ 1521 spin_unlock_irqrestore(sch->lock, flags); 1522 return -EAGAIN; 1523 } 1524 event = io_subchannel_get_status(sch); 1525 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n", 1526 sch->schid.ssid, sch->schid.sch_no, event, 1527 disc ? "disconnected" : "normal", 1528 slow ? "slow" : "fast"); 1529 /* Analyze subchannel status. */ 1530 action = NONE; 1531 switch (event) { 1532 case CIO_NO_PATH: 1533 if (disc) { 1534 /* Check if paths have become available. */ 1535 action = REPROBE; 1536 break; 1537 } 1538 /* fall through */ 1539 case CIO_GONE: 1540 /* Ask driver what to do with device. */ 1541 if (io_subchannel_notify(sch, event)) 1542 action = DISC; 1543 else 1544 action = UNREGISTER; 1545 break; 1546 case CIO_REVALIDATE: 1547 /* Device will be removed, so no notify necessary. */ 1548 if (disc) 1549 /* Reprobe because immediate unregister might block. */ 1550 action = REPROBE; 1551 else 1552 action = UNREGISTER_PROBE; 1553 break; 1554 case CIO_OPER: 1555 if (disc) 1556 /* Get device operational again. */ 1557 action = REPROBE; 1558 break; 1559 } 1560 /* Perform action. */ 1561 ret = 0; 1562 switch (action) { 1563 case UNREGISTER: 1564 case UNREGISTER_PROBE: 1565 ccw_device_set_notoper(cdev); 1566 /* Unregister device (will use subchannel lock). */ 1567 spin_unlock_irqrestore(sch->lock, flags); 1568 css_sch_device_unregister(sch); 1569 spin_lock_irqsave(sch->lock, flags); 1570 1571 /* Reset intparm to zeroes. */ 1572 sch->schib.pmcw.intparm = 0; 1573 cio_modify(sch); 1574 break; 1575 case REPROBE: 1576 ccw_device_trigger_reprobe(cdev); 1577 break; 1578 case DISC: 1579 device_set_disconnected(cdev); 1580 break; 1581 default: 1582 break; 1583 } 1584 spin_unlock_irqrestore(sch->lock, flags); 1585 /* Probe if necessary. */ 1586 if (action == UNREGISTER_PROBE) 1587 ret = css_probe_device(sch->schid); 1588 1589 return ret; 1590 } 1591 1592 #ifdef CONFIG_CCW_CONSOLE 1593 static struct ccw_device console_cdev; 1594 static struct ccw_device_private console_private; 1595 static int console_cdev_in_use; 1596 1597 static DEFINE_SPINLOCK(ccw_console_lock); 1598 1599 spinlock_t * cio_get_console_lock(void) 1600 { 1601 return &ccw_console_lock; 1602 } 1603 1604 static int ccw_device_console_enable(struct ccw_device *cdev, 1605 struct subchannel *sch) 1606 { 1607 int rc; 1608 1609 /* Attach subchannel private data. */ 1610 sch->private = cio_get_console_priv(); 1611 memset(sch->private, 0, sizeof(struct io_subchannel_private)); 1612 io_subchannel_init_fields(sch); 1613 sch->driver = &io_subchannel_driver; 1614 /* Initialize the ccw_device structure. */ 1615 cdev->dev.parent= &sch->dev; 1616 rc = io_subchannel_recog(cdev, sch); 1617 if (rc) 1618 return rc; 1619 1620 /* Now wait for the async. recognition to come to an end. */ 1621 spin_lock_irq(cdev->ccwlock); 1622 while (!dev_fsm_final_state(cdev)) 1623 wait_cons_dev(); 1624 rc = -EIO; 1625 if (cdev->private->state != DEV_STATE_OFFLINE) 1626 goto out_unlock; 1627 ccw_device_online(cdev); 1628 while (!dev_fsm_final_state(cdev)) 1629 wait_cons_dev(); 1630 if (cdev->private->state != DEV_STATE_ONLINE) 1631 goto out_unlock; 1632 rc = 0; 1633 out_unlock: 1634 spin_unlock_irq(cdev->ccwlock); 1635 return 0; 1636 } 1637 1638 struct ccw_device * 1639 ccw_device_probe_console(void) 1640 { 1641 struct subchannel *sch; 1642 int ret; 1643 1644 if (xchg(&console_cdev_in_use, 1) != 0) 1645 return ERR_PTR(-EBUSY); 1646 sch = cio_probe_console(); 1647 if (IS_ERR(sch)) { 1648 console_cdev_in_use = 0; 1649 return (void *) sch; 1650 } 1651 memset(&console_cdev, 0, sizeof(struct ccw_device)); 1652 memset(&console_private, 0, sizeof(struct ccw_device_private)); 1653 console_cdev.private = &console_private; 1654 console_private.cdev = &console_cdev; 1655 ret = ccw_device_console_enable(&console_cdev, sch); 1656 if (ret) { 1657 cio_release_console(); 1658 console_cdev_in_use = 0; 1659 return ERR_PTR(ret); 1660 } 1661 console_cdev.online = 1; 1662 return &console_cdev; 1663 } 1664 #endif 1665 1666 /* 1667 * get ccw_device matching the busid, but only if owned by cdrv 1668 */ 1669 static int 1670 __ccwdev_check_busid(struct device *dev, void *id) 1671 { 1672 char *bus_id; 1673 1674 bus_id = id; 1675 1676 return (strncmp(bus_id, dev->bus_id, BUS_ID_SIZE) == 0); 1677 } 1678 1679 1680 /** 1681 * get_ccwdev_by_busid() - obtain device from a bus id 1682 * @cdrv: driver the device is owned by 1683 * @bus_id: bus id of the device to be searched 1684 * 1685 * This function searches all devices owned by @cdrv for a device with a bus 1686 * id matching @bus_id. 1687 * Returns: 1688 * If a match is found, its reference count of the found device is increased 1689 * and it is returned; else %NULL is returned. 1690 */ 1691 struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv, 1692 const char *bus_id) 1693 { 1694 struct device *dev; 1695 struct device_driver *drv; 1696 1697 drv = get_driver(&cdrv->driver); 1698 if (!drv) 1699 return NULL; 1700 1701 dev = driver_find_device(drv, NULL, (void *)bus_id, 1702 __ccwdev_check_busid); 1703 put_driver(drv); 1704 1705 return dev ? to_ccwdev(dev) : NULL; 1706 } 1707 1708 /************************** device driver handling ************************/ 1709 1710 /* This is the implementation of the ccw_driver class. The probe, remove 1711 * and release methods are initially very similar to the device_driver 1712 * implementations, with the difference that they have ccw_device 1713 * arguments. 1714 * 1715 * A ccw driver also contains the information that is needed for 1716 * device matching. 1717 */ 1718 static int 1719 ccw_device_probe (struct device *dev) 1720 { 1721 struct ccw_device *cdev = to_ccwdev(dev); 1722 struct ccw_driver *cdrv = to_ccwdrv(dev->driver); 1723 int ret; 1724 1725 cdev->drv = cdrv; /* to let the driver call _set_online */ 1726 1727 ret = cdrv->probe ? cdrv->probe(cdev) : -ENODEV; 1728 1729 if (ret) { 1730 cdev->drv = NULL; 1731 return ret; 1732 } 1733 1734 return 0; 1735 } 1736 1737 static int 1738 ccw_device_remove (struct device *dev) 1739 { 1740 struct ccw_device *cdev = to_ccwdev(dev); 1741 struct ccw_driver *cdrv = cdev->drv; 1742 int ret; 1743 1744 if (cdrv->remove) 1745 cdrv->remove(cdev); 1746 if (cdev->online) { 1747 cdev->online = 0; 1748 spin_lock_irq(cdev->ccwlock); 1749 ret = ccw_device_offline(cdev); 1750 spin_unlock_irq(cdev->ccwlock); 1751 if (ret == 0) 1752 wait_event(cdev->private->wait_q, 1753 dev_fsm_final_state(cdev)); 1754 else 1755 CIO_MSG_EVENT(0, "ccw_device_offline returned %d, " 1756 "device 0.%x.%04x\n", 1757 ret, cdev->private->dev_id.ssid, 1758 cdev->private->dev_id.devno); 1759 } 1760 ccw_device_set_timeout(cdev, 0); 1761 cdev->drv = NULL; 1762 return 0; 1763 } 1764 1765 static void ccw_device_shutdown(struct device *dev) 1766 { 1767 struct ccw_device *cdev; 1768 1769 cdev = to_ccwdev(dev); 1770 if (cdev->drv && cdev->drv->shutdown) 1771 cdev->drv->shutdown(cdev); 1772 disable_cmf(cdev); 1773 } 1774 1775 struct bus_type ccw_bus_type = { 1776 .name = "ccw", 1777 .match = ccw_bus_match, 1778 .uevent = ccw_uevent, 1779 .probe = ccw_device_probe, 1780 .remove = ccw_device_remove, 1781 .shutdown = ccw_device_shutdown, 1782 }; 1783 1784 /** 1785 * ccw_driver_register() - register a ccw driver 1786 * @cdriver: driver to be registered 1787 * 1788 * This function is mainly a wrapper around driver_register(). 1789 * Returns: 1790 * %0 on success and a negative error value on failure. 1791 */ 1792 int ccw_driver_register(struct ccw_driver *cdriver) 1793 { 1794 struct device_driver *drv = &cdriver->driver; 1795 1796 drv->bus = &ccw_bus_type; 1797 drv->name = cdriver->name; 1798 drv->owner = cdriver->owner; 1799 1800 return driver_register(drv); 1801 } 1802 1803 /** 1804 * ccw_driver_unregister() - deregister a ccw driver 1805 * @cdriver: driver to be deregistered 1806 * 1807 * This function is mainly a wrapper around driver_unregister(). 1808 */ 1809 void ccw_driver_unregister(struct ccw_driver *cdriver) 1810 { 1811 driver_unregister(&cdriver->driver); 1812 } 1813 1814 /* Helper func for qdio. */ 1815 struct subchannel_id 1816 ccw_device_get_subchannel_id(struct ccw_device *cdev) 1817 { 1818 struct subchannel *sch; 1819 1820 sch = to_subchannel(cdev->dev.parent); 1821 return sch->schid; 1822 } 1823 1824 MODULE_LICENSE("GPL"); 1825 EXPORT_SYMBOL(ccw_device_set_online); 1826 EXPORT_SYMBOL(ccw_device_set_offline); 1827 EXPORT_SYMBOL(ccw_driver_register); 1828 EXPORT_SYMBOL(ccw_driver_unregister); 1829 EXPORT_SYMBOL(get_ccwdev_by_busid); 1830 EXPORT_SYMBOL(ccw_bus_type); 1831 EXPORT_SYMBOL(ccw_device_work); 1832 EXPORT_SYMBOL_GPL(ccw_device_get_subchannel_id); 1833