1 /* 2 * drivers/s390/cio/css.c 3 * driver for channel subsystem 4 * 5 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, 6 * IBM Corporation 7 * Author(s): Arnd Bergmann (arndb@de.ibm.com) 8 * Cornelia Huck (cornelia.huck@de.ibm.com) 9 */ 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/device.h> 13 #include <linux/slab.h> 14 #include <linux/errno.h> 15 #include <linux/list.h> 16 #include <linux/reboot.h> 17 18 #include "css.h" 19 #include "cio.h" 20 #include "cio_debug.h" 21 #include "ioasm.h" 22 #include "chsc.h" 23 #include "device.h" 24 #include "idset.h" 25 #include "chp.h" 26 27 int css_init_done = 0; 28 static int need_reprobe = 0; 29 static int max_ssid = 0; 30 31 struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1]; 32 33 int css_characteristics_avail = 0; 34 35 int 36 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data) 37 { 38 struct subchannel_id schid; 39 int ret; 40 41 init_subchannel_id(&schid); 42 ret = -ENODEV; 43 do { 44 do { 45 ret = fn(schid, data); 46 if (ret) 47 break; 48 } while (schid.sch_no++ < __MAX_SUBCHANNEL); 49 schid.sch_no = 0; 50 } while (schid.ssid++ < max_ssid); 51 return ret; 52 } 53 54 struct cb_data { 55 void *data; 56 struct idset *set; 57 int (*fn_known_sch)(struct subchannel *, void *); 58 int (*fn_unknown_sch)(struct subchannel_id, void *); 59 }; 60 61 static int call_fn_known_sch(struct device *dev, void *data) 62 { 63 struct subchannel *sch = to_subchannel(dev); 64 struct cb_data *cb = data; 65 int rc = 0; 66 67 idset_sch_del(cb->set, sch->schid); 68 if (cb->fn_known_sch) 69 rc = cb->fn_known_sch(sch, cb->data); 70 return rc; 71 } 72 73 static int call_fn_unknown_sch(struct subchannel_id schid, void *data) 74 { 75 struct cb_data *cb = data; 76 int rc = 0; 77 78 if (idset_sch_contains(cb->set, schid)) 79 rc = cb->fn_unknown_sch(schid, cb->data); 80 return rc; 81 } 82 83 int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *), 84 int (*fn_unknown)(struct subchannel_id, 85 void *), void *data) 86 { 87 struct cb_data cb; 88 int rc; 89 90 cb.set = idset_sch_new(); 91 if (!cb.set) 92 return -ENOMEM; 93 idset_fill(cb.set); 94 cb.data = data; 95 cb.fn_known_sch = fn_known; 96 cb.fn_unknown_sch = fn_unknown; 97 /* Process registered subchannels. */ 98 rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch); 99 if (rc) 100 goto out; 101 /* Process unregistered subchannels. */ 102 if (fn_unknown) 103 rc = for_each_subchannel(call_fn_unknown_sch, &cb); 104 out: 105 idset_free(cb.set); 106 107 return rc; 108 } 109 110 static struct subchannel * 111 css_alloc_subchannel(struct subchannel_id schid) 112 { 113 struct subchannel *sch; 114 int ret; 115 116 sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA); 117 if (sch == NULL) 118 return ERR_PTR(-ENOMEM); 119 ret = cio_validate_subchannel (sch, schid); 120 if (ret < 0) { 121 kfree(sch); 122 return ERR_PTR(ret); 123 } 124 125 if (sch->st != SUBCHANNEL_TYPE_IO) { 126 /* For now we ignore all non-io subchannels. */ 127 kfree(sch); 128 return ERR_PTR(-EINVAL); 129 } 130 131 /* 132 * Set intparm to subchannel address. 133 * This is fine even on 64bit since the subchannel is always located 134 * under 2G. 135 */ 136 sch->schib.pmcw.intparm = (u32)(addr_t)sch; 137 ret = cio_modify(sch); 138 if (ret) { 139 kfree(sch->lock); 140 kfree(sch); 141 return ERR_PTR(ret); 142 } 143 return sch; 144 } 145 146 static void 147 css_free_subchannel(struct subchannel *sch) 148 { 149 if (sch) { 150 /* Reset intparm to zeroes. */ 151 sch->schib.pmcw.intparm = 0; 152 cio_modify(sch); 153 kfree(sch->lock); 154 kfree(sch); 155 } 156 } 157 158 static void 159 css_subchannel_release(struct device *dev) 160 { 161 struct subchannel *sch; 162 163 sch = to_subchannel(dev); 164 if (!cio_is_console(sch->schid)) { 165 kfree(sch->lock); 166 kfree(sch); 167 } 168 } 169 170 static int css_sch_device_register(struct subchannel *sch) 171 { 172 int ret; 173 174 mutex_lock(&sch->reg_mutex); 175 ret = device_register(&sch->dev); 176 mutex_unlock(&sch->reg_mutex); 177 return ret; 178 } 179 180 void css_sch_device_unregister(struct subchannel *sch) 181 { 182 mutex_lock(&sch->reg_mutex); 183 device_unregister(&sch->dev); 184 mutex_unlock(&sch->reg_mutex); 185 } 186 187 static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw) 188 { 189 int i; 190 int mask; 191 192 memset(ssd, 0, sizeof(struct chsc_ssd_info)); 193 ssd->path_mask = pmcw->pim; 194 for (i = 0; i < 8; i++) { 195 mask = 0x80 >> i; 196 if (pmcw->pim & mask) { 197 chp_id_init(&ssd->chpid[i]); 198 ssd->chpid[i].id = pmcw->chpid[i]; 199 } 200 } 201 } 202 203 static void ssd_register_chpids(struct chsc_ssd_info *ssd) 204 { 205 int i; 206 int mask; 207 208 for (i = 0; i < 8; i++) { 209 mask = 0x80 >> i; 210 if (ssd->path_mask & mask) 211 if (!chp_is_registered(ssd->chpid[i])) 212 chp_new(ssd->chpid[i]); 213 } 214 } 215 216 void css_update_ssd_info(struct subchannel *sch) 217 { 218 int ret; 219 220 if (cio_is_console(sch->schid)) { 221 /* Console is initialized too early for functions requiring 222 * memory allocation. */ 223 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw); 224 } else { 225 ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info); 226 if (ret) 227 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw); 228 ssd_register_chpids(&sch->ssd_info); 229 } 230 } 231 232 static int css_register_subchannel(struct subchannel *sch) 233 { 234 int ret; 235 236 /* Initialize the subchannel structure */ 237 sch->dev.parent = &channel_subsystems[0]->device; 238 sch->dev.bus = &css_bus_type; 239 sch->dev.release = &css_subchannel_release; 240 sch->dev.groups = subch_attr_groups; 241 /* 242 * We don't want to generate uevents for I/O subchannels that don't 243 * have a working ccw device behind them since they will be 244 * unregistered before they can be used anyway, so we delay the add 245 * uevent until after device recognition was successful. 246 */ 247 if (!cio_is_console(sch->schid)) 248 /* Console is special, no need to suppress. */ 249 sch->dev.uevent_suppress = 1; 250 css_update_ssd_info(sch); 251 /* make it known to the system */ 252 ret = css_sch_device_register(sch); 253 if (ret) { 254 CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n", 255 sch->schid.ssid, sch->schid.sch_no, ret); 256 return ret; 257 } 258 return ret; 259 } 260 261 static int css_probe_device(struct subchannel_id schid) 262 { 263 int ret; 264 struct subchannel *sch; 265 266 sch = css_alloc_subchannel(schid); 267 if (IS_ERR(sch)) 268 return PTR_ERR(sch); 269 ret = css_register_subchannel(sch); 270 if (ret) 271 css_free_subchannel(sch); 272 return ret; 273 } 274 275 static int 276 check_subchannel(struct device * dev, void * data) 277 { 278 struct subchannel *sch; 279 struct subchannel_id *schid = data; 280 281 sch = to_subchannel(dev); 282 return schid_equal(&sch->schid, schid); 283 } 284 285 struct subchannel * 286 get_subchannel_by_schid(struct subchannel_id schid) 287 { 288 struct device *dev; 289 290 dev = bus_find_device(&css_bus_type, NULL, 291 &schid, check_subchannel); 292 293 return dev ? to_subchannel(dev) : NULL; 294 } 295 296 /** 297 * css_sch_is_valid() - check if a subchannel is valid 298 * @schib: subchannel information block for the subchannel 299 */ 300 int css_sch_is_valid(struct schib *schib) 301 { 302 if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv) 303 return 0; 304 return 1; 305 } 306 EXPORT_SYMBOL_GPL(css_sch_is_valid); 307 308 static int css_get_subchannel_status(struct subchannel *sch) 309 { 310 struct schib schib; 311 312 if (stsch(sch->schid, &schib)) 313 return CIO_GONE; 314 if (!css_sch_is_valid(&schib)) 315 return CIO_GONE; 316 if (sch->schib.pmcw.dnv && (schib.pmcw.dev != sch->schib.pmcw.dev)) 317 return CIO_REVALIDATE; 318 if (!sch->lpm) 319 return CIO_NO_PATH; 320 return CIO_OPER; 321 } 322 323 static int css_evaluate_known_subchannel(struct subchannel *sch, int slow) 324 { 325 int event, ret, disc; 326 unsigned long flags; 327 enum { NONE, UNREGISTER, UNREGISTER_PROBE, REPROBE } action; 328 329 spin_lock_irqsave(sch->lock, flags); 330 disc = device_is_disconnected(sch); 331 if (disc && slow) { 332 /* Disconnected devices are evaluated directly only.*/ 333 spin_unlock_irqrestore(sch->lock, flags); 334 return 0; 335 } 336 /* No interrupt after machine check - kill pending timers. */ 337 device_kill_pending_timer(sch); 338 if (!disc && !slow) { 339 /* Non-disconnected devices are evaluated on the slow path. */ 340 spin_unlock_irqrestore(sch->lock, flags); 341 return -EAGAIN; 342 } 343 event = css_get_subchannel_status(sch); 344 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n", 345 sch->schid.ssid, sch->schid.sch_no, event, 346 disc ? "disconnected" : "normal", 347 slow ? "slow" : "fast"); 348 /* Analyze subchannel status. */ 349 action = NONE; 350 switch (event) { 351 case CIO_NO_PATH: 352 if (disc) { 353 /* Check if paths have become available. */ 354 action = REPROBE; 355 break; 356 } 357 /* fall through */ 358 case CIO_GONE: 359 /* Prevent unwanted effects when opening lock. */ 360 cio_disable_subchannel(sch); 361 device_set_disconnected(sch); 362 /* Ask driver what to do with device. */ 363 action = UNREGISTER; 364 if (sch->driver && sch->driver->notify) { 365 spin_unlock_irqrestore(sch->lock, flags); 366 ret = sch->driver->notify(sch, event); 367 spin_lock_irqsave(sch->lock, flags); 368 if (ret) 369 action = NONE; 370 } 371 break; 372 case CIO_REVALIDATE: 373 /* Device will be removed, so no notify necessary. */ 374 if (disc) 375 /* Reprobe because immediate unregister might block. */ 376 action = REPROBE; 377 else 378 action = UNREGISTER_PROBE; 379 break; 380 case CIO_OPER: 381 if (disc) 382 /* Get device operational again. */ 383 action = REPROBE; 384 break; 385 } 386 /* Perform action. */ 387 ret = 0; 388 switch (action) { 389 case UNREGISTER: 390 case UNREGISTER_PROBE: 391 /* Unregister device (will use subchannel lock). */ 392 spin_unlock_irqrestore(sch->lock, flags); 393 css_sch_device_unregister(sch); 394 spin_lock_irqsave(sch->lock, flags); 395 396 /* Reset intparm to zeroes. */ 397 sch->schib.pmcw.intparm = 0; 398 cio_modify(sch); 399 break; 400 case REPROBE: 401 device_trigger_reprobe(sch); 402 break; 403 default: 404 break; 405 } 406 spin_unlock_irqrestore(sch->lock, flags); 407 /* Probe if necessary. */ 408 if (action == UNREGISTER_PROBE) 409 ret = css_probe_device(sch->schid); 410 411 return ret; 412 } 413 414 static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow) 415 { 416 struct schib schib; 417 418 if (!slow) { 419 /* Will be done on the slow path. */ 420 return -EAGAIN; 421 } 422 if (stsch_err(schid, &schib) || !css_sch_is_valid(&schib)) { 423 /* Unusable - ignore. */ 424 return 0; 425 } 426 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, " 427 "slow path.\n", schid.ssid, schid.sch_no, CIO_OPER); 428 429 return css_probe_device(schid); 430 } 431 432 static void css_evaluate_subchannel(struct subchannel_id schid, int slow) 433 { 434 struct subchannel *sch; 435 int ret; 436 437 sch = get_subchannel_by_schid(schid); 438 if (sch) { 439 ret = css_evaluate_known_subchannel(sch, slow); 440 put_device(&sch->dev); 441 } else 442 ret = css_evaluate_new_subchannel(schid, slow); 443 if (ret == -EAGAIN) 444 css_schedule_eval(schid); 445 } 446 447 static struct idset *slow_subchannel_set; 448 static spinlock_t slow_subchannel_lock; 449 450 static int __init slow_subchannel_init(void) 451 { 452 spin_lock_init(&slow_subchannel_lock); 453 slow_subchannel_set = idset_sch_new(); 454 if (!slow_subchannel_set) { 455 CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n"); 456 return -ENOMEM; 457 } 458 return 0; 459 } 460 461 static int slow_eval_known_fn(struct subchannel *sch, void *data) 462 { 463 int eval; 464 int rc; 465 466 spin_lock_irq(&slow_subchannel_lock); 467 eval = idset_sch_contains(slow_subchannel_set, sch->schid); 468 idset_sch_del(slow_subchannel_set, sch->schid); 469 spin_unlock_irq(&slow_subchannel_lock); 470 if (eval) { 471 rc = css_evaluate_known_subchannel(sch, 1); 472 if (rc == -EAGAIN) 473 css_schedule_eval(sch->schid); 474 } 475 return 0; 476 } 477 478 static int slow_eval_unknown_fn(struct subchannel_id schid, void *data) 479 { 480 int eval; 481 int rc = 0; 482 483 spin_lock_irq(&slow_subchannel_lock); 484 eval = idset_sch_contains(slow_subchannel_set, schid); 485 idset_sch_del(slow_subchannel_set, schid); 486 spin_unlock_irq(&slow_subchannel_lock); 487 if (eval) { 488 rc = css_evaluate_new_subchannel(schid, 1); 489 switch (rc) { 490 case -EAGAIN: 491 css_schedule_eval(schid); 492 rc = 0; 493 break; 494 case -ENXIO: 495 case -ENOMEM: 496 case -EIO: 497 /* These should abort looping */ 498 break; 499 default: 500 rc = 0; 501 } 502 } 503 return rc; 504 } 505 506 static void css_slow_path_func(struct work_struct *unused) 507 { 508 CIO_TRACE_EVENT(4, "slowpath"); 509 for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn, 510 NULL); 511 } 512 513 static DECLARE_WORK(slow_path_work, css_slow_path_func); 514 struct workqueue_struct *slow_path_wq; 515 516 void css_schedule_eval(struct subchannel_id schid) 517 { 518 unsigned long flags; 519 520 spin_lock_irqsave(&slow_subchannel_lock, flags); 521 idset_sch_add(slow_subchannel_set, schid); 522 queue_work(slow_path_wq, &slow_path_work); 523 spin_unlock_irqrestore(&slow_subchannel_lock, flags); 524 } 525 526 void css_schedule_eval_all(void) 527 { 528 unsigned long flags; 529 530 spin_lock_irqsave(&slow_subchannel_lock, flags); 531 idset_fill(slow_subchannel_set); 532 queue_work(slow_path_wq, &slow_path_work); 533 spin_unlock_irqrestore(&slow_subchannel_lock, flags); 534 } 535 536 /* Reprobe subchannel if unregistered. */ 537 static int reprobe_subchannel(struct subchannel_id schid, void *data) 538 { 539 int ret; 540 541 CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n", 542 schid.ssid, schid.sch_no); 543 if (need_reprobe) 544 return -EAGAIN; 545 546 ret = css_probe_device(schid); 547 switch (ret) { 548 case 0: 549 break; 550 case -ENXIO: 551 case -ENOMEM: 552 case -EIO: 553 /* These should abort looping */ 554 break; 555 default: 556 ret = 0; 557 } 558 559 return ret; 560 } 561 562 /* Work function used to reprobe all unregistered subchannels. */ 563 static void reprobe_all(struct work_struct *unused) 564 { 565 int ret; 566 567 CIO_MSG_EVENT(2, "reprobe start\n"); 568 569 need_reprobe = 0; 570 /* Make sure initial subchannel scan is done. */ 571 wait_event(ccw_device_init_wq, 572 atomic_read(&ccw_device_init_count) == 0); 573 ret = for_each_subchannel_staged(NULL, reprobe_subchannel, NULL); 574 575 CIO_MSG_EVENT(2, "reprobe done (rc=%d, need_reprobe=%d)\n", ret, 576 need_reprobe); 577 } 578 579 static DECLARE_WORK(css_reprobe_work, reprobe_all); 580 581 /* Schedule reprobing of all unregistered subchannels. */ 582 void css_schedule_reprobe(void) 583 { 584 need_reprobe = 1; 585 queue_work(slow_path_wq, &css_reprobe_work); 586 } 587 588 EXPORT_SYMBOL_GPL(css_schedule_reprobe); 589 590 /* 591 * Called from the machine check handler for subchannel report words. 592 */ 593 void css_process_crw(int rsid1, int rsid2) 594 { 595 struct subchannel_id mchk_schid; 596 597 CIO_CRW_EVENT(2, "source is subchannel %04X, subsystem id %x\n", 598 rsid1, rsid2); 599 init_subchannel_id(&mchk_schid); 600 mchk_schid.sch_no = rsid1; 601 if (rsid2 != 0) 602 mchk_schid.ssid = (rsid2 >> 8) & 3; 603 604 /* 605 * Since we are always presented with IPI in the CRW, we have to 606 * use stsch() to find out if the subchannel in question has come 607 * or gone. 608 */ 609 css_evaluate_subchannel(mchk_schid, 0); 610 } 611 612 static int __init 613 __init_channel_subsystem(struct subchannel_id schid, void *data) 614 { 615 struct subchannel *sch; 616 int ret; 617 618 if (cio_is_console(schid)) 619 sch = cio_get_console_subchannel(); 620 else { 621 sch = css_alloc_subchannel(schid); 622 if (IS_ERR(sch)) 623 ret = PTR_ERR(sch); 624 else 625 ret = 0; 626 switch (ret) { 627 case 0: 628 break; 629 case -ENOMEM: 630 panic("Out of memory in init_channel_subsystem\n"); 631 /* -ENXIO: no more subchannels. */ 632 case -ENXIO: 633 return ret; 634 /* -EIO: this subchannel set not supported. */ 635 case -EIO: 636 return ret; 637 default: 638 return 0; 639 } 640 } 641 /* 642 * We register ALL valid subchannels in ioinfo, even those 643 * that have been present before init_channel_subsystem. 644 * These subchannels can't have been registered yet (kmalloc 645 * not working) so we do it now. This is true e.g. for the 646 * console subchannel. 647 */ 648 css_register_subchannel(sch); 649 return 0; 650 } 651 652 static void __init 653 css_generate_pgid(struct channel_subsystem *css, u32 tod_high) 654 { 655 if (css_characteristics_avail && css_general_characteristics.mcss) { 656 css->global_pgid.pgid_high.ext_cssid.version = 0x80; 657 css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid; 658 } else { 659 #ifdef CONFIG_SMP 660 css->global_pgid.pgid_high.cpu_addr = hard_smp_processor_id(); 661 #else 662 css->global_pgid.pgid_high.cpu_addr = 0; 663 #endif 664 } 665 css->global_pgid.cpu_id = ((cpuid_t *) __LC_CPUID)->ident; 666 css->global_pgid.cpu_model = ((cpuid_t *) __LC_CPUID)->machine; 667 css->global_pgid.tod_high = tod_high; 668 669 } 670 671 static void 672 channel_subsystem_release(struct device *dev) 673 { 674 struct channel_subsystem *css; 675 676 css = to_css(dev); 677 mutex_destroy(&css->mutex); 678 kfree(css); 679 } 680 681 static ssize_t 682 css_cm_enable_show(struct device *dev, struct device_attribute *attr, 683 char *buf) 684 { 685 struct channel_subsystem *css = to_css(dev); 686 687 if (!css) 688 return 0; 689 return sprintf(buf, "%x\n", css->cm_enabled); 690 } 691 692 static ssize_t 693 css_cm_enable_store(struct device *dev, struct device_attribute *attr, 694 const char *buf, size_t count) 695 { 696 struct channel_subsystem *css = to_css(dev); 697 int ret; 698 699 switch (buf[0]) { 700 case '0': 701 ret = css->cm_enabled ? chsc_secm(css, 0) : 0; 702 break; 703 case '1': 704 ret = css->cm_enabled ? 0 : chsc_secm(css, 1); 705 break; 706 default: 707 ret = -EINVAL; 708 } 709 return ret < 0 ? ret : count; 710 } 711 712 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store); 713 714 static int __init setup_css(int nr) 715 { 716 u32 tod_high; 717 int ret; 718 struct channel_subsystem *css; 719 720 css = channel_subsystems[nr]; 721 memset(css, 0, sizeof(struct channel_subsystem)); 722 css->pseudo_subchannel = 723 kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL); 724 if (!css->pseudo_subchannel) 725 return -ENOMEM; 726 css->pseudo_subchannel->dev.parent = &css->device; 727 css->pseudo_subchannel->dev.release = css_subchannel_release; 728 sprintf(css->pseudo_subchannel->dev.bus_id, "defunct"); 729 ret = cio_create_sch_lock(css->pseudo_subchannel); 730 if (ret) { 731 kfree(css->pseudo_subchannel); 732 return ret; 733 } 734 mutex_init(&css->mutex); 735 css->valid = 1; 736 css->cssid = nr; 737 sprintf(css->device.bus_id, "css%x", nr); 738 css->device.release = channel_subsystem_release; 739 tod_high = (u32) (get_clock() >> 32); 740 css_generate_pgid(css, tod_high); 741 return 0; 742 } 743 744 static int css_reboot_event(struct notifier_block *this, 745 unsigned long event, 746 void *ptr) 747 { 748 int ret, i; 749 750 ret = NOTIFY_DONE; 751 for (i = 0; i <= __MAX_CSSID; i++) { 752 struct channel_subsystem *css; 753 754 css = channel_subsystems[i]; 755 if (css->cm_enabled) 756 if (chsc_secm(css, 0)) 757 ret = NOTIFY_BAD; 758 } 759 760 return ret; 761 } 762 763 static struct notifier_block css_reboot_notifier = { 764 .notifier_call = css_reboot_event, 765 }; 766 767 /* 768 * Now that the driver core is running, we can setup our channel subsystem. 769 * The struct subchannel's are created during probing (except for the 770 * static console subchannel). 771 */ 772 static int __init 773 init_channel_subsystem (void) 774 { 775 int ret, i; 776 777 ret = chsc_determine_css_characteristics(); 778 if (ret == -ENOMEM) 779 goto out; /* No need to continue. */ 780 if (ret == 0) 781 css_characteristics_avail = 1; 782 783 ret = chsc_alloc_sei_area(); 784 if (ret) 785 goto out; 786 787 ret = slow_subchannel_init(); 788 if (ret) 789 goto out; 790 791 if ((ret = bus_register(&css_bus_type))) 792 goto out; 793 794 /* Try to enable MSS. */ 795 ret = chsc_enable_facility(CHSC_SDA_OC_MSS); 796 switch (ret) { 797 case 0: /* Success. */ 798 max_ssid = __MAX_SSID; 799 break; 800 case -ENOMEM: 801 goto out_bus; 802 default: 803 max_ssid = 0; 804 } 805 /* Setup css structure. */ 806 for (i = 0; i <= __MAX_CSSID; i++) { 807 struct channel_subsystem *css; 808 809 css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL); 810 if (!css) { 811 ret = -ENOMEM; 812 goto out_unregister; 813 } 814 channel_subsystems[i] = css; 815 ret = setup_css(i); 816 if (ret) 817 goto out_free; 818 ret = device_register(&css->device); 819 if (ret) 820 goto out_free_all; 821 if (css_characteristics_avail && 822 css_chsc_characteristics.secm) { 823 ret = device_create_file(&css->device, 824 &dev_attr_cm_enable); 825 if (ret) 826 goto out_device; 827 } 828 ret = device_register(&css->pseudo_subchannel->dev); 829 if (ret) 830 goto out_file; 831 } 832 ret = register_reboot_notifier(&css_reboot_notifier); 833 if (ret) 834 goto out_pseudo; 835 css_init_done = 1; 836 837 ctl_set_bit(6, 28); 838 839 for_each_subchannel(__init_channel_subsystem, NULL); 840 return 0; 841 out_pseudo: 842 device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev); 843 out_file: 844 device_remove_file(&channel_subsystems[i]->device, 845 &dev_attr_cm_enable); 846 out_device: 847 device_unregister(&channel_subsystems[i]->device); 848 out_free_all: 849 kfree(channel_subsystems[i]->pseudo_subchannel->lock); 850 kfree(channel_subsystems[i]->pseudo_subchannel); 851 out_free: 852 kfree(channel_subsystems[i]); 853 out_unregister: 854 while (i > 0) { 855 struct channel_subsystem *css; 856 857 i--; 858 css = channel_subsystems[i]; 859 device_unregister(&css->pseudo_subchannel->dev); 860 if (css_characteristics_avail && css_chsc_characteristics.secm) 861 device_remove_file(&css->device, 862 &dev_attr_cm_enable); 863 device_unregister(&css->device); 864 } 865 out_bus: 866 bus_unregister(&css_bus_type); 867 out: 868 chsc_free_sei_area(); 869 kfree(slow_subchannel_set); 870 printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n", 871 ret); 872 return ret; 873 } 874 875 int sch_is_pseudo_sch(struct subchannel *sch) 876 { 877 return sch == to_css(sch->dev.parent)->pseudo_subchannel; 878 } 879 880 /* 881 * find a driver for a subchannel. They identify by the subchannel 882 * type with the exception that the console subchannel driver has its own 883 * subchannel type although the device is an i/o subchannel 884 */ 885 static int 886 css_bus_match (struct device *dev, struct device_driver *drv) 887 { 888 struct subchannel *sch = to_subchannel(dev); 889 struct css_driver *driver = to_cssdriver(drv); 890 891 if (sch->st == driver->subchannel_type) 892 return 1; 893 894 return 0; 895 } 896 897 static int css_probe(struct device *dev) 898 { 899 struct subchannel *sch; 900 int ret; 901 902 sch = to_subchannel(dev); 903 sch->driver = to_cssdriver(dev->driver); 904 ret = sch->driver->probe ? sch->driver->probe(sch) : 0; 905 if (ret) 906 sch->driver = NULL; 907 return ret; 908 } 909 910 static int css_remove(struct device *dev) 911 { 912 struct subchannel *sch; 913 int ret; 914 915 sch = to_subchannel(dev); 916 ret = sch->driver->remove ? sch->driver->remove(sch) : 0; 917 sch->driver = NULL; 918 return ret; 919 } 920 921 static void css_shutdown(struct device *dev) 922 { 923 struct subchannel *sch; 924 925 sch = to_subchannel(dev); 926 if (sch->driver && sch->driver->shutdown) 927 sch->driver->shutdown(sch); 928 } 929 930 struct bus_type css_bus_type = { 931 .name = "css", 932 .match = css_bus_match, 933 .probe = css_probe, 934 .remove = css_remove, 935 .shutdown = css_shutdown, 936 }; 937 938 /** 939 * css_driver_register - register a css driver 940 * @cdrv: css driver to register 941 * 942 * This is mainly a wrapper around driver_register that sets name 943 * and bus_type in the embedded struct device_driver correctly. 944 */ 945 int css_driver_register(struct css_driver *cdrv) 946 { 947 cdrv->drv.name = cdrv->name; 948 cdrv->drv.bus = &css_bus_type; 949 cdrv->drv.owner = cdrv->owner; 950 return driver_register(&cdrv->drv); 951 } 952 EXPORT_SYMBOL_GPL(css_driver_register); 953 954 /** 955 * css_driver_unregister - unregister a css driver 956 * @cdrv: css driver to unregister 957 * 958 * This is a wrapper around driver_unregister. 959 */ 960 void css_driver_unregister(struct css_driver *cdrv) 961 { 962 driver_unregister(&cdrv->drv); 963 } 964 EXPORT_SYMBOL_GPL(css_driver_unregister); 965 966 subsys_initcall(init_channel_subsystem); 967 968 MODULE_LICENSE("GPL"); 969 EXPORT_SYMBOL(css_bus_type); 970 EXPORT_SYMBOL_GPL(css_characteristics_avail); 971