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 void css_wait_for_slow_path(void) 537 { 538 flush_workqueue(ccw_device_notify_work); 539 flush_workqueue(slow_path_wq); 540 } 541 542 /* Reprobe subchannel if unregistered. */ 543 static int reprobe_subchannel(struct subchannel_id schid, void *data) 544 { 545 int ret; 546 547 CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n", 548 schid.ssid, schid.sch_no); 549 if (need_reprobe) 550 return -EAGAIN; 551 552 ret = css_probe_device(schid); 553 switch (ret) { 554 case 0: 555 break; 556 case -ENXIO: 557 case -ENOMEM: 558 case -EIO: 559 /* These should abort looping */ 560 break; 561 default: 562 ret = 0; 563 } 564 565 return ret; 566 } 567 568 /* Work function used to reprobe all unregistered subchannels. */ 569 static void reprobe_all(struct work_struct *unused) 570 { 571 int ret; 572 573 CIO_MSG_EVENT(2, "reprobe start\n"); 574 575 need_reprobe = 0; 576 /* Make sure initial subchannel scan is done. */ 577 wait_event(ccw_device_init_wq, 578 atomic_read(&ccw_device_init_count) == 0); 579 ret = for_each_subchannel_staged(NULL, reprobe_subchannel, NULL); 580 581 CIO_MSG_EVENT(2, "reprobe done (rc=%d, need_reprobe=%d)\n", ret, 582 need_reprobe); 583 } 584 585 static DECLARE_WORK(css_reprobe_work, reprobe_all); 586 587 /* Schedule reprobing of all unregistered subchannels. */ 588 void css_schedule_reprobe(void) 589 { 590 need_reprobe = 1; 591 queue_work(slow_path_wq, &css_reprobe_work); 592 } 593 594 EXPORT_SYMBOL_GPL(css_schedule_reprobe); 595 596 /* 597 * Called from the machine check handler for subchannel report words. 598 */ 599 void css_process_crw(int rsid1, int rsid2) 600 { 601 struct subchannel_id mchk_schid; 602 603 CIO_CRW_EVENT(2, "source is subchannel %04X, subsystem id %x\n", 604 rsid1, rsid2); 605 init_subchannel_id(&mchk_schid); 606 mchk_schid.sch_no = rsid1; 607 if (rsid2 != 0) 608 mchk_schid.ssid = (rsid2 >> 8) & 3; 609 610 /* 611 * Since we are always presented with IPI in the CRW, we have to 612 * use stsch() to find out if the subchannel in question has come 613 * or gone. 614 */ 615 css_evaluate_subchannel(mchk_schid, 0); 616 } 617 618 static int __init 619 __init_channel_subsystem(struct subchannel_id schid, void *data) 620 { 621 struct subchannel *sch; 622 int ret; 623 624 if (cio_is_console(schid)) 625 sch = cio_get_console_subchannel(); 626 else { 627 sch = css_alloc_subchannel(schid); 628 if (IS_ERR(sch)) 629 ret = PTR_ERR(sch); 630 else 631 ret = 0; 632 switch (ret) { 633 case 0: 634 break; 635 case -ENOMEM: 636 panic("Out of memory in init_channel_subsystem\n"); 637 /* -ENXIO: no more subchannels. */ 638 case -ENXIO: 639 return ret; 640 /* -EIO: this subchannel set not supported. */ 641 case -EIO: 642 return ret; 643 default: 644 return 0; 645 } 646 } 647 /* 648 * We register ALL valid subchannels in ioinfo, even those 649 * that have been present before init_channel_subsystem. 650 * These subchannels can't have been registered yet (kmalloc 651 * not working) so we do it now. This is true e.g. for the 652 * console subchannel. 653 */ 654 css_register_subchannel(sch); 655 return 0; 656 } 657 658 static void __init 659 css_generate_pgid(struct channel_subsystem *css, u32 tod_high) 660 { 661 if (css_characteristics_avail && css_general_characteristics.mcss) { 662 css->global_pgid.pgid_high.ext_cssid.version = 0x80; 663 css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid; 664 } else { 665 #ifdef CONFIG_SMP 666 css->global_pgid.pgid_high.cpu_addr = hard_smp_processor_id(); 667 #else 668 css->global_pgid.pgid_high.cpu_addr = 0; 669 #endif 670 } 671 css->global_pgid.cpu_id = ((cpuid_t *) __LC_CPUID)->ident; 672 css->global_pgid.cpu_model = ((cpuid_t *) __LC_CPUID)->machine; 673 css->global_pgid.tod_high = tod_high; 674 675 } 676 677 static void 678 channel_subsystem_release(struct device *dev) 679 { 680 struct channel_subsystem *css; 681 682 css = to_css(dev); 683 mutex_destroy(&css->mutex); 684 kfree(css); 685 } 686 687 static ssize_t 688 css_cm_enable_show(struct device *dev, struct device_attribute *attr, 689 char *buf) 690 { 691 struct channel_subsystem *css = to_css(dev); 692 int ret; 693 694 if (!css) 695 return 0; 696 mutex_lock(&css->mutex); 697 ret = sprintf(buf, "%x\n", css->cm_enabled); 698 mutex_unlock(&css->mutex); 699 return ret; 700 } 701 702 static ssize_t 703 css_cm_enable_store(struct device *dev, struct device_attribute *attr, 704 const char *buf, size_t count) 705 { 706 struct channel_subsystem *css = to_css(dev); 707 int ret; 708 709 mutex_lock(&css->mutex); 710 switch (buf[0]) { 711 case '0': 712 ret = css->cm_enabled ? chsc_secm(css, 0) : 0; 713 break; 714 case '1': 715 ret = css->cm_enabled ? 0 : chsc_secm(css, 1); 716 break; 717 default: 718 ret = -EINVAL; 719 } 720 mutex_unlock(&css->mutex); 721 return ret < 0 ? ret : count; 722 } 723 724 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store); 725 726 static int __init setup_css(int nr) 727 { 728 u32 tod_high; 729 int ret; 730 struct channel_subsystem *css; 731 732 css = channel_subsystems[nr]; 733 memset(css, 0, sizeof(struct channel_subsystem)); 734 css->pseudo_subchannel = 735 kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL); 736 if (!css->pseudo_subchannel) 737 return -ENOMEM; 738 css->pseudo_subchannel->dev.parent = &css->device; 739 css->pseudo_subchannel->dev.release = css_subchannel_release; 740 sprintf(css->pseudo_subchannel->dev.bus_id, "defunct"); 741 ret = cio_create_sch_lock(css->pseudo_subchannel); 742 if (ret) { 743 kfree(css->pseudo_subchannel); 744 return ret; 745 } 746 mutex_init(&css->mutex); 747 css->valid = 1; 748 css->cssid = nr; 749 sprintf(css->device.bus_id, "css%x", nr); 750 css->device.release = channel_subsystem_release; 751 tod_high = (u32) (get_clock() >> 32); 752 css_generate_pgid(css, tod_high); 753 return 0; 754 } 755 756 static int css_reboot_event(struct notifier_block *this, 757 unsigned long event, 758 void *ptr) 759 { 760 int ret, i; 761 762 ret = NOTIFY_DONE; 763 for (i = 0; i <= __MAX_CSSID; i++) { 764 struct channel_subsystem *css; 765 766 css = channel_subsystems[i]; 767 mutex_lock(&css->mutex); 768 if (css->cm_enabled) 769 if (chsc_secm(css, 0)) 770 ret = NOTIFY_BAD; 771 mutex_unlock(&css->mutex); 772 } 773 774 return ret; 775 } 776 777 static struct notifier_block css_reboot_notifier = { 778 .notifier_call = css_reboot_event, 779 }; 780 781 /* 782 * Now that the driver core is running, we can setup our channel subsystem. 783 * The struct subchannel's are created during probing (except for the 784 * static console subchannel). 785 */ 786 static int __init 787 init_channel_subsystem (void) 788 { 789 int ret, i; 790 791 ret = chsc_determine_css_characteristics(); 792 if (ret == -ENOMEM) 793 goto out; /* No need to continue. */ 794 if (ret == 0) 795 css_characteristics_avail = 1; 796 797 ret = chsc_alloc_sei_area(); 798 if (ret) 799 goto out; 800 801 ret = slow_subchannel_init(); 802 if (ret) 803 goto out; 804 805 if ((ret = bus_register(&css_bus_type))) 806 goto out; 807 808 /* Try to enable MSS. */ 809 ret = chsc_enable_facility(CHSC_SDA_OC_MSS); 810 switch (ret) { 811 case 0: /* Success. */ 812 max_ssid = __MAX_SSID; 813 break; 814 case -ENOMEM: 815 goto out_bus; 816 default: 817 max_ssid = 0; 818 } 819 /* Setup css structure. */ 820 for (i = 0; i <= __MAX_CSSID; i++) { 821 struct channel_subsystem *css; 822 823 css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL); 824 if (!css) { 825 ret = -ENOMEM; 826 goto out_unregister; 827 } 828 channel_subsystems[i] = css; 829 ret = setup_css(i); 830 if (ret) 831 goto out_free; 832 ret = device_register(&css->device); 833 if (ret) 834 goto out_free_all; 835 if (css_characteristics_avail && 836 css_chsc_characteristics.secm) { 837 ret = device_create_file(&css->device, 838 &dev_attr_cm_enable); 839 if (ret) 840 goto out_device; 841 } 842 ret = device_register(&css->pseudo_subchannel->dev); 843 if (ret) 844 goto out_file; 845 } 846 ret = register_reboot_notifier(&css_reboot_notifier); 847 if (ret) 848 goto out_pseudo; 849 css_init_done = 1; 850 851 ctl_set_bit(6, 28); 852 853 for_each_subchannel(__init_channel_subsystem, NULL); 854 return 0; 855 out_pseudo: 856 device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev); 857 out_file: 858 device_remove_file(&channel_subsystems[i]->device, 859 &dev_attr_cm_enable); 860 out_device: 861 device_unregister(&channel_subsystems[i]->device); 862 out_free_all: 863 kfree(channel_subsystems[i]->pseudo_subchannel->lock); 864 kfree(channel_subsystems[i]->pseudo_subchannel); 865 out_free: 866 kfree(channel_subsystems[i]); 867 out_unregister: 868 while (i > 0) { 869 struct channel_subsystem *css; 870 871 i--; 872 css = channel_subsystems[i]; 873 device_unregister(&css->pseudo_subchannel->dev); 874 if (css_characteristics_avail && css_chsc_characteristics.secm) 875 device_remove_file(&css->device, 876 &dev_attr_cm_enable); 877 device_unregister(&css->device); 878 } 879 out_bus: 880 bus_unregister(&css_bus_type); 881 out: 882 chsc_free_sei_area(); 883 kfree(slow_subchannel_set); 884 printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n", 885 ret); 886 return ret; 887 } 888 889 int sch_is_pseudo_sch(struct subchannel *sch) 890 { 891 return sch == to_css(sch->dev.parent)->pseudo_subchannel; 892 } 893 894 /* 895 * find a driver for a subchannel. They identify by the subchannel 896 * type with the exception that the console subchannel driver has its own 897 * subchannel type although the device is an i/o subchannel 898 */ 899 static int 900 css_bus_match (struct device *dev, struct device_driver *drv) 901 { 902 struct subchannel *sch = to_subchannel(dev); 903 struct css_driver *driver = to_cssdriver(drv); 904 905 if (sch->st == driver->subchannel_type) 906 return 1; 907 908 return 0; 909 } 910 911 static int css_probe(struct device *dev) 912 { 913 struct subchannel *sch; 914 int ret; 915 916 sch = to_subchannel(dev); 917 sch->driver = to_cssdriver(dev->driver); 918 ret = sch->driver->probe ? sch->driver->probe(sch) : 0; 919 if (ret) 920 sch->driver = NULL; 921 return ret; 922 } 923 924 static int css_remove(struct device *dev) 925 { 926 struct subchannel *sch; 927 int ret; 928 929 sch = to_subchannel(dev); 930 ret = sch->driver->remove ? sch->driver->remove(sch) : 0; 931 sch->driver = NULL; 932 return ret; 933 } 934 935 static void css_shutdown(struct device *dev) 936 { 937 struct subchannel *sch; 938 939 sch = to_subchannel(dev); 940 if (sch->driver && sch->driver->shutdown) 941 sch->driver->shutdown(sch); 942 } 943 944 struct bus_type css_bus_type = { 945 .name = "css", 946 .match = css_bus_match, 947 .probe = css_probe, 948 .remove = css_remove, 949 .shutdown = css_shutdown, 950 }; 951 952 /** 953 * css_driver_register - register a css driver 954 * @cdrv: css driver to register 955 * 956 * This is mainly a wrapper around driver_register that sets name 957 * and bus_type in the embedded struct device_driver correctly. 958 */ 959 int css_driver_register(struct css_driver *cdrv) 960 { 961 cdrv->drv.name = cdrv->name; 962 cdrv->drv.bus = &css_bus_type; 963 cdrv->drv.owner = cdrv->owner; 964 return driver_register(&cdrv->drv); 965 } 966 EXPORT_SYMBOL_GPL(css_driver_register); 967 968 /** 969 * css_driver_unregister - unregister a css driver 970 * @cdrv: css driver to unregister 971 * 972 * This is a wrapper around driver_unregister. 973 */ 974 void css_driver_unregister(struct css_driver *cdrv) 975 { 976 driver_unregister(&cdrv->drv); 977 } 978 EXPORT_SYMBOL_GPL(css_driver_unregister); 979 980 subsys_initcall(init_channel_subsystem); 981 982 MODULE_LICENSE("GPL"); 983 EXPORT_SYMBOL(css_bus_type); 984 EXPORT_SYMBOL_GPL(css_characteristics_avail); 985