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(4, "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(4, "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 unsigned long val; 709 710 ret = strict_strtoul(buf, 16, &val); 711 if (ret) 712 return ret; 713 mutex_lock(&css->mutex); 714 switch (val) { 715 case 0: 716 ret = css->cm_enabled ? chsc_secm(css, 0) : 0; 717 break; 718 case 1: 719 ret = css->cm_enabled ? 0 : chsc_secm(css, 1); 720 break; 721 default: 722 ret = -EINVAL; 723 } 724 mutex_unlock(&css->mutex); 725 return ret < 0 ? ret : count; 726 } 727 728 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store); 729 730 static int __init setup_css(int nr) 731 { 732 u32 tod_high; 733 int ret; 734 struct channel_subsystem *css; 735 736 css = channel_subsystems[nr]; 737 memset(css, 0, sizeof(struct channel_subsystem)); 738 css->pseudo_subchannel = 739 kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL); 740 if (!css->pseudo_subchannel) 741 return -ENOMEM; 742 css->pseudo_subchannel->dev.parent = &css->device; 743 css->pseudo_subchannel->dev.release = css_subchannel_release; 744 sprintf(css->pseudo_subchannel->dev.bus_id, "defunct"); 745 ret = cio_create_sch_lock(css->pseudo_subchannel); 746 if (ret) { 747 kfree(css->pseudo_subchannel); 748 return ret; 749 } 750 mutex_init(&css->mutex); 751 css->valid = 1; 752 css->cssid = nr; 753 sprintf(css->device.bus_id, "css%x", nr); 754 css->device.release = channel_subsystem_release; 755 tod_high = (u32) (get_clock() >> 32); 756 css_generate_pgid(css, tod_high); 757 return 0; 758 } 759 760 static int css_reboot_event(struct notifier_block *this, 761 unsigned long event, 762 void *ptr) 763 { 764 int ret, i; 765 766 ret = NOTIFY_DONE; 767 for (i = 0; i <= __MAX_CSSID; i++) { 768 struct channel_subsystem *css; 769 770 css = channel_subsystems[i]; 771 mutex_lock(&css->mutex); 772 if (css->cm_enabled) 773 if (chsc_secm(css, 0)) 774 ret = NOTIFY_BAD; 775 mutex_unlock(&css->mutex); 776 } 777 778 return ret; 779 } 780 781 static struct notifier_block css_reboot_notifier = { 782 .notifier_call = css_reboot_event, 783 }; 784 785 /* 786 * Now that the driver core is running, we can setup our channel subsystem. 787 * The struct subchannel's are created during probing (except for the 788 * static console subchannel). 789 */ 790 static int __init 791 init_channel_subsystem (void) 792 { 793 int ret, i; 794 795 ret = chsc_determine_css_characteristics(); 796 if (ret == -ENOMEM) 797 goto out; /* No need to continue. */ 798 if (ret == 0) 799 css_characteristics_avail = 1; 800 801 ret = chsc_alloc_sei_area(); 802 if (ret) 803 goto out; 804 805 ret = slow_subchannel_init(); 806 if (ret) 807 goto out; 808 809 if ((ret = bus_register(&css_bus_type))) 810 goto out; 811 812 /* Try to enable MSS. */ 813 ret = chsc_enable_facility(CHSC_SDA_OC_MSS); 814 switch (ret) { 815 case 0: /* Success. */ 816 max_ssid = __MAX_SSID; 817 break; 818 case -ENOMEM: 819 goto out_bus; 820 default: 821 max_ssid = 0; 822 } 823 /* Setup css structure. */ 824 for (i = 0; i <= __MAX_CSSID; i++) { 825 struct channel_subsystem *css; 826 827 css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL); 828 if (!css) { 829 ret = -ENOMEM; 830 goto out_unregister; 831 } 832 channel_subsystems[i] = css; 833 ret = setup_css(i); 834 if (ret) 835 goto out_free; 836 ret = device_register(&css->device); 837 if (ret) 838 goto out_free_all; 839 if (css_characteristics_avail && 840 css_chsc_characteristics.secm) { 841 ret = device_create_file(&css->device, 842 &dev_attr_cm_enable); 843 if (ret) 844 goto out_device; 845 } 846 ret = device_register(&css->pseudo_subchannel->dev); 847 if (ret) 848 goto out_file; 849 } 850 ret = register_reboot_notifier(&css_reboot_notifier); 851 if (ret) 852 goto out_pseudo; 853 css_init_done = 1; 854 855 ctl_set_bit(6, 28); 856 857 for_each_subchannel(__init_channel_subsystem, NULL); 858 return 0; 859 out_pseudo: 860 device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev); 861 out_file: 862 device_remove_file(&channel_subsystems[i]->device, 863 &dev_attr_cm_enable); 864 out_device: 865 device_unregister(&channel_subsystems[i]->device); 866 out_free_all: 867 kfree(channel_subsystems[i]->pseudo_subchannel->lock); 868 kfree(channel_subsystems[i]->pseudo_subchannel); 869 out_free: 870 kfree(channel_subsystems[i]); 871 out_unregister: 872 while (i > 0) { 873 struct channel_subsystem *css; 874 875 i--; 876 css = channel_subsystems[i]; 877 device_unregister(&css->pseudo_subchannel->dev); 878 if (css_characteristics_avail && css_chsc_characteristics.secm) 879 device_remove_file(&css->device, 880 &dev_attr_cm_enable); 881 device_unregister(&css->device); 882 } 883 out_bus: 884 bus_unregister(&css_bus_type); 885 out: 886 chsc_free_sei_area(); 887 kfree(slow_subchannel_set); 888 printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n", 889 ret); 890 return ret; 891 } 892 893 int sch_is_pseudo_sch(struct subchannel *sch) 894 { 895 return sch == to_css(sch->dev.parent)->pseudo_subchannel; 896 } 897 898 /* 899 * find a driver for a subchannel. They identify by the subchannel 900 * type with the exception that the console subchannel driver has its own 901 * subchannel type although the device is an i/o subchannel 902 */ 903 static int 904 css_bus_match (struct device *dev, struct device_driver *drv) 905 { 906 struct subchannel *sch = to_subchannel(dev); 907 struct css_driver *driver = to_cssdriver(drv); 908 909 if (sch->st == driver->subchannel_type) 910 return 1; 911 912 return 0; 913 } 914 915 static int css_probe(struct device *dev) 916 { 917 struct subchannel *sch; 918 int ret; 919 920 sch = to_subchannel(dev); 921 sch->driver = to_cssdriver(dev->driver); 922 ret = sch->driver->probe ? sch->driver->probe(sch) : 0; 923 if (ret) 924 sch->driver = NULL; 925 return ret; 926 } 927 928 static int css_remove(struct device *dev) 929 { 930 struct subchannel *sch; 931 int ret; 932 933 sch = to_subchannel(dev); 934 ret = sch->driver->remove ? sch->driver->remove(sch) : 0; 935 sch->driver = NULL; 936 return ret; 937 } 938 939 static void css_shutdown(struct device *dev) 940 { 941 struct subchannel *sch; 942 943 sch = to_subchannel(dev); 944 if (sch->driver && sch->driver->shutdown) 945 sch->driver->shutdown(sch); 946 } 947 948 struct bus_type css_bus_type = { 949 .name = "css", 950 .match = css_bus_match, 951 .probe = css_probe, 952 .remove = css_remove, 953 .shutdown = css_shutdown, 954 }; 955 956 /** 957 * css_driver_register - register a css driver 958 * @cdrv: css driver to register 959 * 960 * This is mainly a wrapper around driver_register that sets name 961 * and bus_type in the embedded struct device_driver correctly. 962 */ 963 int css_driver_register(struct css_driver *cdrv) 964 { 965 cdrv->drv.name = cdrv->name; 966 cdrv->drv.bus = &css_bus_type; 967 cdrv->drv.owner = cdrv->owner; 968 return driver_register(&cdrv->drv); 969 } 970 EXPORT_SYMBOL_GPL(css_driver_register); 971 972 /** 973 * css_driver_unregister - unregister a css driver 974 * @cdrv: css driver to unregister 975 * 976 * This is a wrapper around driver_unregister. 977 */ 978 void css_driver_unregister(struct css_driver *cdrv) 979 { 980 driver_unregister(&cdrv->drv); 981 } 982 EXPORT_SYMBOL_GPL(css_driver_unregister); 983 984 subsys_initcall(init_channel_subsystem); 985 986 MODULE_LICENSE("GPL"); 987 EXPORT_SYMBOL(css_bus_type); 988 EXPORT_SYMBOL_GPL(css_characteristics_avail); 989