1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * driver for channel subsystem 4 * 5 * Copyright IBM Corp. 2002, 2010 6 * 7 * Author(s): Arnd Bergmann (arndb@de.ibm.com) 8 * Cornelia Huck (cornelia.huck@de.ibm.com) 9 */ 10 11 #define pr_fmt(fmt) "cio: " fmt 12 13 #include <linux/export.h> 14 #include <linux/init.h> 15 #include <linux/device.h> 16 #include <linux/slab.h> 17 #include <linux/errno.h> 18 #include <linux/list.h> 19 #include <linux/reboot.h> 20 #include <linux/proc_fs.h> 21 #include <linux/genalloc.h> 22 #include <linux/dma-mapping.h> 23 #include <asm/isc.h> 24 #include <asm/crw.h> 25 26 #include "css.h" 27 #include "cio.h" 28 #include "blacklist.h" 29 #include "cio_debug.h" 30 #include "ioasm.h" 31 #include "chsc.h" 32 #include "device.h" 33 #include "idset.h" 34 #include "chp.h" 35 36 int css_init_done = 0; 37 int max_ssid; 38 39 #define MAX_CSS_IDX 0 40 struct channel_subsystem *channel_subsystems[MAX_CSS_IDX + 1]; 41 static const struct bus_type css_bus_type; 42 43 int 44 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data) 45 { 46 struct subchannel_id schid; 47 int ret; 48 49 init_subchannel_id(&schid); 50 do { 51 do { 52 ret = fn(schid, data); 53 if (ret) 54 break; 55 } while (schid.sch_no++ < __MAX_SUBCHANNEL); 56 schid.sch_no = 0; 57 } while (schid.ssid++ < max_ssid); 58 return ret; 59 } 60 61 struct cb_data { 62 void *data; 63 struct idset *set; 64 int (*fn_known_sch)(struct subchannel *, void *); 65 int (*fn_unknown_sch)(struct subchannel_id, void *); 66 }; 67 68 static int call_fn_known_sch(struct device *dev, void *data) 69 { 70 struct subchannel *sch = to_subchannel(dev); 71 struct cb_data *cb = data; 72 int rc = 0; 73 74 if (cb->set) 75 idset_sch_del(cb->set, sch->schid); 76 if (cb->fn_known_sch) 77 rc = cb->fn_known_sch(sch, cb->data); 78 return rc; 79 } 80 81 static int call_fn_unknown_sch(struct subchannel_id schid, void *data) 82 { 83 struct cb_data *cb = data; 84 int rc = 0; 85 86 if (idset_sch_contains(cb->set, schid)) 87 rc = cb->fn_unknown_sch(schid, cb->data); 88 return rc; 89 } 90 91 static int call_fn_all_sch(struct subchannel_id schid, void *data) 92 { 93 struct cb_data *cb = data; 94 struct subchannel *sch; 95 int rc = 0; 96 97 sch = get_subchannel_by_schid(schid); 98 if (sch) { 99 if (cb->fn_known_sch) 100 rc = cb->fn_known_sch(sch, cb->data); 101 put_device(&sch->dev); 102 } else { 103 if (cb->fn_unknown_sch) 104 rc = cb->fn_unknown_sch(schid, cb->data); 105 } 106 107 return rc; 108 } 109 110 int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *), 111 int (*fn_unknown)(struct subchannel_id, 112 void *), void *data) 113 { 114 struct cb_data cb; 115 int rc; 116 117 cb.data = data; 118 cb.fn_known_sch = fn_known; 119 cb.fn_unknown_sch = fn_unknown; 120 121 if (fn_known && !fn_unknown) { 122 /* Skip idset allocation in case of known-only loop. */ 123 cb.set = NULL; 124 return bus_for_each_dev(&css_bus_type, NULL, &cb, 125 call_fn_known_sch); 126 } 127 128 cb.set = idset_sch_new(); 129 if (!cb.set) 130 /* fall back to brute force scanning in case of oom */ 131 return for_each_subchannel(call_fn_all_sch, &cb); 132 133 idset_fill(cb.set); 134 135 /* Process registered subchannels. */ 136 rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch); 137 if (rc) 138 goto out; 139 /* Process unregistered subchannels. */ 140 if (fn_unknown) 141 rc = for_each_subchannel(call_fn_unknown_sch, &cb); 142 out: 143 idset_free(cb.set); 144 145 return rc; 146 } 147 148 static void css_sch_todo(struct work_struct *work); 149 150 static void css_sch_create_locks(struct subchannel *sch) 151 { 152 spin_lock_init(&sch->lock); 153 mutex_init(&sch->reg_mutex); 154 } 155 156 static void css_subchannel_release(struct device *dev) 157 { 158 struct subchannel *sch = to_subchannel(dev); 159 160 sch->config.intparm = 0; 161 cio_commit_config(sch); 162 kfree(sch->driver_override); 163 kfree(sch); 164 } 165 166 static int css_validate_subchannel(struct subchannel_id schid, 167 struct schib *schib) 168 { 169 int err; 170 171 switch (schib->pmcw.st) { 172 case SUBCHANNEL_TYPE_IO: 173 case SUBCHANNEL_TYPE_MSG: 174 if (!css_sch_is_valid(schib)) 175 err = -ENODEV; 176 else if (is_blacklisted(schid.ssid, schib->pmcw.dev)) { 177 CIO_MSG_EVENT(6, "Blacklisted device detected " 178 "at devno %04X, subchannel set %x\n", 179 schib->pmcw.dev, schid.ssid); 180 err = -ENODEV; 181 } else 182 err = 0; 183 break; 184 default: 185 err = 0; 186 } 187 if (err) 188 goto out; 189 190 CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n", 191 schid.ssid, schid.sch_no, schib->pmcw.st); 192 out: 193 return err; 194 } 195 196 struct subchannel *css_alloc_subchannel(struct subchannel_id schid, 197 struct schib *schib) 198 { 199 struct subchannel *sch; 200 int ret; 201 202 ret = css_validate_subchannel(schid, schib); 203 if (ret < 0) 204 return ERR_PTR(ret); 205 206 sch = kzalloc(sizeof(*sch), GFP_KERNEL | GFP_DMA); 207 if (!sch) 208 return ERR_PTR(-ENOMEM); 209 210 sch->schid = schid; 211 sch->schib = *schib; 212 sch->st = schib->pmcw.st; 213 214 css_sch_create_locks(sch); 215 216 INIT_WORK(&sch->todo_work, css_sch_todo); 217 sch->dev.release = &css_subchannel_release; 218 sch->dev.dma_mask = &sch->dma_mask; 219 device_initialize(&sch->dev); 220 /* 221 * The physical addresses for some of the dma structures that can 222 * belong to a subchannel need to fit 31 bit width (e.g. ccw). 223 */ 224 ret = dma_set_coherent_mask(&sch->dev, DMA_BIT_MASK(31)); 225 if (ret) 226 goto err; 227 /* 228 * But we don't have such restrictions imposed on the stuff that 229 * is handled by the streaming API. 230 */ 231 ret = dma_set_mask(&sch->dev, DMA_BIT_MASK(64)); 232 if (ret) 233 goto err; 234 235 return sch; 236 237 err: 238 kfree(sch); 239 return ERR_PTR(ret); 240 } 241 242 static int css_sch_device_register(struct subchannel *sch) 243 { 244 int ret; 245 246 mutex_lock(&sch->reg_mutex); 247 dev_set_name(&sch->dev, "0.%x.%04x", sch->schid.ssid, 248 sch->schid.sch_no); 249 ret = device_add(&sch->dev); 250 mutex_unlock(&sch->reg_mutex); 251 return ret; 252 } 253 254 /** 255 * css_sch_device_unregister - unregister a subchannel 256 * @sch: subchannel to be unregistered 257 */ 258 void css_sch_device_unregister(struct subchannel *sch) 259 { 260 mutex_lock(&sch->reg_mutex); 261 if (device_is_registered(&sch->dev)) 262 device_unregister(&sch->dev); 263 mutex_unlock(&sch->reg_mutex); 264 } 265 EXPORT_SYMBOL_GPL(css_sch_device_unregister); 266 267 static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw) 268 { 269 int i; 270 int mask; 271 272 memset(ssd, 0, sizeof(struct chsc_ssd_info)); 273 ssd->path_mask = pmcw->pim; 274 for (i = 0; i < 8; i++) { 275 mask = 0x80 >> i; 276 if (pmcw->pim & mask) { 277 chp_id_init(&ssd->chpid[i]); 278 ssd->chpid[i].id = pmcw->chpid[i]; 279 } 280 } 281 } 282 283 static void ssd_register_chpids(struct chsc_ssd_info *ssd) 284 { 285 int i; 286 int mask; 287 288 for (i = 0; i < 8; i++) { 289 mask = 0x80 >> i; 290 if (ssd->path_mask & mask) 291 chp_new(ssd->chpid[i]); 292 } 293 } 294 295 void css_update_ssd_info(struct subchannel *sch) 296 { 297 int ret; 298 299 ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info); 300 if (ret) 301 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw); 302 303 ssd_register_chpids(&sch->ssd_info); 304 } 305 306 static ssize_t type_show(struct device *dev, struct device_attribute *attr, 307 char *buf) 308 { 309 struct subchannel *sch = to_subchannel(dev); 310 311 return sysfs_emit(buf, "%01x\n", sch->st); 312 } 313 314 static DEVICE_ATTR_RO(type); 315 316 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, 317 char *buf) 318 { 319 struct subchannel *sch = to_subchannel(dev); 320 321 return sysfs_emit(buf, "css:t%01X\n", sch->st); 322 } 323 324 static DEVICE_ATTR_RO(modalias); 325 326 static ssize_t driver_override_store(struct device *dev, 327 struct device_attribute *attr, 328 const char *buf, size_t count) 329 { 330 struct subchannel *sch = to_subchannel(dev); 331 int ret; 332 333 ret = driver_set_override(dev, &sch->driver_override, buf, count); 334 if (ret) 335 return ret; 336 337 return count; 338 } 339 340 static ssize_t driver_override_show(struct device *dev, 341 struct device_attribute *attr, char *buf) 342 { 343 struct subchannel *sch = to_subchannel(dev); 344 ssize_t len; 345 346 device_lock(dev); 347 len = sysfs_emit(buf, "%s\n", sch->driver_override); 348 device_unlock(dev); 349 return len; 350 } 351 static DEVICE_ATTR_RW(driver_override); 352 353 static struct attribute *subch_attrs[] = { 354 &dev_attr_type.attr, 355 &dev_attr_modalias.attr, 356 &dev_attr_driver_override.attr, 357 NULL, 358 }; 359 360 static struct attribute_group subch_attr_group = { 361 .attrs = subch_attrs, 362 }; 363 364 static const struct attribute_group *default_subch_attr_groups[] = { 365 &subch_attr_group, 366 NULL, 367 }; 368 369 static ssize_t chpids_show(struct device *dev, 370 struct device_attribute *attr, 371 char *buf) 372 { 373 struct subchannel *sch = to_subchannel(dev); 374 struct chsc_ssd_info *ssd = &sch->ssd_info; 375 ssize_t ret = 0; 376 int mask; 377 int chp; 378 379 for (chp = 0; chp < 8; chp++) { 380 mask = 0x80 >> chp; 381 if (ssd->path_mask & mask) 382 ret += sysfs_emit_at(buf, ret, "%02x ", ssd->chpid[chp].id); 383 else 384 ret += sysfs_emit_at(buf, ret, "00 "); 385 } 386 ret += sysfs_emit_at(buf, ret, "\n"); 387 return ret; 388 } 389 static DEVICE_ATTR_RO(chpids); 390 391 static ssize_t pimpampom_show(struct device *dev, 392 struct device_attribute *attr, 393 char *buf) 394 { 395 struct subchannel *sch = to_subchannel(dev); 396 struct pmcw *pmcw = &sch->schib.pmcw; 397 398 return sysfs_emit(buf, "%02x %02x %02x\n", 399 pmcw->pim, pmcw->pam, pmcw->pom); 400 } 401 static DEVICE_ATTR_RO(pimpampom); 402 403 static ssize_t dev_busid_show(struct device *dev, 404 struct device_attribute *attr, 405 char *buf) 406 { 407 struct subchannel *sch = to_subchannel(dev); 408 struct pmcw *pmcw = &sch->schib.pmcw; 409 410 if ((pmcw->st == SUBCHANNEL_TYPE_IO && pmcw->dnv) || 411 (pmcw->st == SUBCHANNEL_TYPE_MSG && pmcw->w)) 412 return sysfs_emit(buf, "0.%x.%04x\n", sch->schid.ssid, 413 pmcw->dev); 414 else 415 return sysfs_emit(buf, "none\n"); 416 } 417 static DEVICE_ATTR_RO(dev_busid); 418 419 static struct attribute *io_subchannel_type_attrs[] = { 420 &dev_attr_chpids.attr, 421 &dev_attr_pimpampom.attr, 422 &dev_attr_dev_busid.attr, 423 NULL, 424 }; 425 ATTRIBUTE_GROUPS(io_subchannel_type); 426 427 static const struct device_type io_subchannel_type = { 428 .groups = io_subchannel_type_groups, 429 }; 430 431 int css_register_subchannel(struct subchannel *sch) 432 { 433 int ret; 434 435 /* Initialize the subchannel structure */ 436 sch->dev.parent = &channel_subsystems[0]->device; 437 sch->dev.bus = &css_bus_type; 438 sch->dev.groups = default_subch_attr_groups; 439 440 if (sch->st == SUBCHANNEL_TYPE_IO) 441 sch->dev.type = &io_subchannel_type; 442 443 css_update_ssd_info(sch); 444 /* make it known to the system */ 445 ret = css_sch_device_register(sch); 446 if (ret) { 447 CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n", 448 sch->schid.ssid, sch->schid.sch_no, ret); 449 return ret; 450 } 451 return ret; 452 } 453 454 static int css_probe_device(struct subchannel_id schid, struct schib *schib) 455 { 456 struct subchannel *sch; 457 int ret; 458 459 sch = css_alloc_subchannel(schid, schib); 460 if (IS_ERR(sch)) 461 return PTR_ERR(sch); 462 463 ret = css_register_subchannel(sch); 464 if (ret) 465 put_device(&sch->dev); 466 467 return ret; 468 } 469 470 static int 471 check_subchannel(struct device *dev, const void *data) 472 { 473 struct subchannel *sch; 474 struct subchannel_id *schid = (void *)data; 475 476 sch = to_subchannel(dev); 477 return schid_equal(&sch->schid, schid); 478 } 479 480 struct subchannel * 481 get_subchannel_by_schid(struct subchannel_id schid) 482 { 483 struct device *dev; 484 485 dev = bus_find_device(&css_bus_type, NULL, 486 &schid, check_subchannel); 487 488 return dev ? to_subchannel(dev) : NULL; 489 } 490 491 /** 492 * css_sch_is_valid() - check if a subchannel is valid 493 * @schib: subchannel information block for the subchannel 494 */ 495 int css_sch_is_valid(struct schib *schib) 496 { 497 if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv) 498 return 0; 499 if ((schib->pmcw.st == SUBCHANNEL_TYPE_MSG) && !schib->pmcw.w) 500 return 0; 501 return 1; 502 } 503 EXPORT_SYMBOL_GPL(css_sch_is_valid); 504 505 static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow) 506 { 507 struct schib schib; 508 int ccode; 509 510 if (!slow) { 511 /* Will be done on the slow path. */ 512 return -EAGAIN; 513 } 514 /* 515 * The first subchannel that is not-operational (ccode==3) 516 * indicates that there aren't any more devices available. 517 * If stsch gets an exception, it means the current subchannel set 518 * is not valid. 519 */ 520 ccode = stsch(schid, &schib); 521 if (ccode) 522 return (ccode == 3) ? -ENXIO : ccode; 523 524 return css_probe_device(schid, &schib); 525 } 526 527 static int css_evaluate_known_subchannel(struct subchannel *sch, int slow) 528 { 529 int ret = 0; 530 531 if (sch->driver) { 532 if (sch->driver->sch_event) 533 ret = sch->driver->sch_event(sch, slow); 534 else 535 dev_dbg(&sch->dev, 536 "Got subchannel machine check but " 537 "no sch_event handler provided.\n"); 538 } 539 if (ret != 0 && ret != -EAGAIN) { 540 CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n", 541 sch->schid.ssid, sch->schid.sch_no, ret); 542 } 543 return ret; 544 } 545 546 static void css_evaluate_subchannel(struct subchannel_id schid, int slow) 547 { 548 struct subchannel *sch; 549 int ret; 550 551 sch = get_subchannel_by_schid(schid); 552 if (sch) { 553 ret = css_evaluate_known_subchannel(sch, slow); 554 put_device(&sch->dev); 555 } else 556 ret = css_evaluate_new_subchannel(schid, slow); 557 if (ret == -EAGAIN) 558 css_schedule_eval(schid); 559 } 560 561 /** 562 * css_sched_sch_todo - schedule a subchannel operation 563 * @sch: subchannel 564 * @todo: todo 565 * 566 * Schedule the operation identified by @todo to be performed on the slow path 567 * workqueue. Do nothing if another operation with higher priority is already 568 * scheduled. Needs to be called with subchannel lock held. 569 */ 570 void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo) 571 { 572 CIO_MSG_EVENT(4, "sch_todo: sched sch=0.%x.%04x todo=%d\n", 573 sch->schid.ssid, sch->schid.sch_no, todo); 574 if (sch->todo >= todo) 575 return; 576 /* Get workqueue ref. */ 577 if (!get_device(&sch->dev)) 578 return; 579 sch->todo = todo; 580 if (!queue_work(cio_work_q, &sch->todo_work)) { 581 /* Already queued, release workqueue ref. */ 582 put_device(&sch->dev); 583 } 584 } 585 EXPORT_SYMBOL_GPL(css_sched_sch_todo); 586 587 static void css_sch_todo(struct work_struct *work) 588 { 589 struct subchannel *sch; 590 enum sch_todo todo; 591 int ret; 592 593 sch = container_of(work, struct subchannel, todo_work); 594 /* Find out todo. */ 595 spin_lock_irq(&sch->lock); 596 todo = sch->todo; 597 CIO_MSG_EVENT(4, "sch_todo: sch=0.%x.%04x, todo=%d\n", sch->schid.ssid, 598 sch->schid.sch_no, todo); 599 sch->todo = SCH_TODO_NOTHING; 600 spin_unlock_irq(&sch->lock); 601 /* Perform todo. */ 602 switch (todo) { 603 case SCH_TODO_NOTHING: 604 break; 605 case SCH_TODO_EVAL: 606 ret = css_evaluate_known_subchannel(sch, 1); 607 if (ret == -EAGAIN) { 608 spin_lock_irq(&sch->lock); 609 css_sched_sch_todo(sch, todo); 610 spin_unlock_irq(&sch->lock); 611 } 612 break; 613 case SCH_TODO_UNREG: 614 css_sch_device_unregister(sch); 615 break; 616 } 617 /* Release workqueue ref. */ 618 put_device(&sch->dev); 619 } 620 621 static struct idset *slow_subchannel_set; 622 static DEFINE_SPINLOCK(slow_subchannel_lock); 623 static DECLARE_WAIT_QUEUE_HEAD(css_eval_wq); 624 static atomic_t css_eval_scheduled; 625 626 static int __init slow_subchannel_init(void) 627 { 628 atomic_set(&css_eval_scheduled, 0); 629 slow_subchannel_set = idset_sch_new(); 630 if (!slow_subchannel_set) { 631 CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n"); 632 return -ENOMEM; 633 } 634 return 0; 635 } 636 637 static int slow_eval_known_fn(struct subchannel *sch, void *data) 638 { 639 int eval; 640 int rc; 641 642 spin_lock_irq(&slow_subchannel_lock); 643 eval = idset_sch_contains(slow_subchannel_set, sch->schid); 644 idset_sch_del(slow_subchannel_set, sch->schid); 645 spin_unlock_irq(&slow_subchannel_lock); 646 if (eval) { 647 rc = css_evaluate_known_subchannel(sch, 1); 648 if (rc == -EAGAIN) 649 css_schedule_eval(sch->schid); 650 /* 651 * The loop might take long time for platforms with lots of 652 * known devices. Allow scheduling here. 653 */ 654 cond_resched(); 655 } 656 return 0; 657 } 658 659 static int slow_eval_unknown_fn(struct subchannel_id schid, void *data) 660 { 661 int eval; 662 int rc = 0; 663 664 spin_lock_irq(&slow_subchannel_lock); 665 eval = idset_sch_contains(slow_subchannel_set, schid); 666 idset_sch_del(slow_subchannel_set, schid); 667 spin_unlock_irq(&slow_subchannel_lock); 668 if (eval) { 669 rc = css_evaluate_new_subchannel(schid, 1); 670 switch (rc) { 671 case -EAGAIN: 672 css_schedule_eval(schid); 673 rc = 0; 674 break; 675 case -ENXIO: 676 case -ENOMEM: 677 case -EIO: 678 /* These should abort looping */ 679 spin_lock_irq(&slow_subchannel_lock); 680 idset_sch_del_subseq(slow_subchannel_set, schid); 681 spin_unlock_irq(&slow_subchannel_lock); 682 break; 683 default: 684 rc = 0; 685 } 686 /* Allow scheduling here since the containing loop might 687 * take a while. */ 688 cond_resched(); 689 } 690 return rc; 691 } 692 693 static void css_slow_path_func(struct work_struct *unused) 694 { 695 unsigned long flags; 696 697 CIO_TRACE_EVENT(4, "slowpath"); 698 for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn, 699 NULL); 700 spin_lock_irqsave(&slow_subchannel_lock, flags); 701 if (idset_is_empty(slow_subchannel_set)) { 702 atomic_set(&css_eval_scheduled, 0); 703 wake_up(&css_eval_wq); 704 } 705 spin_unlock_irqrestore(&slow_subchannel_lock, flags); 706 } 707 708 static DECLARE_DELAYED_WORK(slow_path_work, css_slow_path_func); 709 struct workqueue_struct *cio_work_q; 710 711 void css_schedule_eval(struct subchannel_id schid) 712 { 713 unsigned long flags; 714 715 spin_lock_irqsave(&slow_subchannel_lock, flags); 716 idset_sch_add(slow_subchannel_set, schid); 717 atomic_set(&css_eval_scheduled, 1); 718 queue_delayed_work(cio_work_q, &slow_path_work, 0); 719 spin_unlock_irqrestore(&slow_subchannel_lock, flags); 720 } 721 722 void css_schedule_eval_all(void) 723 { 724 unsigned long flags; 725 726 spin_lock_irqsave(&slow_subchannel_lock, flags); 727 idset_fill(slow_subchannel_set); 728 atomic_set(&css_eval_scheduled, 1); 729 queue_delayed_work(cio_work_q, &slow_path_work, 0); 730 spin_unlock_irqrestore(&slow_subchannel_lock, flags); 731 } 732 733 static int __unset_validpath(struct device *dev, void *data) 734 { 735 struct idset *set = data; 736 struct subchannel *sch = to_subchannel(dev); 737 struct pmcw *pmcw = &sch->schib.pmcw; 738 739 /* Here we want to make sure that we are considering only those subchannels 740 * which do not have an operational device attached to it. This can be found 741 * with the help of PAM and POM values of pmcw. OPM provides the information 742 * about any path which is currently vary-off, so that we should not consider. 743 */ 744 if (sch->st == SUBCHANNEL_TYPE_IO && 745 (sch->opm & pmcw->pam & pmcw->pom)) 746 idset_sch_del(set, sch->schid); 747 748 return 0; 749 } 750 751 static int __unset_online(struct device *dev, void *data) 752 { 753 struct idset *set = data; 754 struct subchannel *sch = to_subchannel(dev); 755 756 if (sch->st == SUBCHANNEL_TYPE_IO && sch->config.ena) 757 idset_sch_del(set, sch->schid); 758 759 return 0; 760 } 761 762 void css_schedule_eval_cond(enum css_eval_cond cond, unsigned long delay) 763 { 764 unsigned long flags; 765 struct idset *set; 766 767 /* Find unregistered subchannels. */ 768 set = idset_sch_new(); 769 if (!set) { 770 /* Fallback. */ 771 css_schedule_eval_all(); 772 return; 773 } 774 idset_fill(set); 775 switch (cond) { 776 case CSS_EVAL_NO_PATH: 777 bus_for_each_dev(&css_bus_type, NULL, set, __unset_validpath); 778 break; 779 case CSS_EVAL_NOT_ONLINE: 780 bus_for_each_dev(&css_bus_type, NULL, set, __unset_online); 781 break; 782 default: 783 break; 784 } 785 786 /* Apply to slow_subchannel_set. */ 787 spin_lock_irqsave(&slow_subchannel_lock, flags); 788 idset_add_set(slow_subchannel_set, set); 789 atomic_set(&css_eval_scheduled, 1); 790 queue_delayed_work(cio_work_q, &slow_path_work, delay); 791 spin_unlock_irqrestore(&slow_subchannel_lock, flags); 792 idset_free(set); 793 } 794 795 void css_wait_for_slow_path(void) 796 { 797 flush_workqueue(cio_work_q); 798 } 799 800 /* Schedule reprobing of all subchannels with no valid operational path. */ 801 void css_schedule_reprobe(void) 802 { 803 /* Schedule with a delay to allow merging of subsequent calls. */ 804 css_schedule_eval_cond(CSS_EVAL_NO_PATH, 1 * HZ); 805 } 806 EXPORT_SYMBOL_GPL(css_schedule_reprobe); 807 808 /* 809 * Called from the machine check handler for subchannel report words. 810 */ 811 static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow) 812 { 813 struct subchannel_id mchk_schid; 814 struct subchannel *sch; 815 816 if (overflow) { 817 css_schedule_eval_all(); 818 return; 819 } 820 CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, " 821 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n", 822 crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc, 823 crw0->erc, crw0->rsid); 824 if (crw1) 825 CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, " 826 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n", 827 crw1->slct, crw1->oflw, crw1->chn, crw1->rsc, 828 crw1->anc, crw1->erc, crw1->rsid); 829 init_subchannel_id(&mchk_schid); 830 mchk_schid.sch_no = crw0->rsid; 831 if (crw1) 832 mchk_schid.ssid = (crw1->rsid >> 4) & 3; 833 834 if (crw0->erc == CRW_ERC_PMOD) { 835 sch = get_subchannel_by_schid(mchk_schid); 836 if (sch) { 837 css_update_ssd_info(sch); 838 put_device(&sch->dev); 839 } 840 } 841 /* 842 * Since we are always presented with IPI in the CRW, we have to 843 * use stsch() to find out if the subchannel in question has come 844 * or gone. 845 */ 846 css_evaluate_subchannel(mchk_schid, 0); 847 } 848 849 static void __init 850 css_generate_pgid(struct channel_subsystem *css, u32 tod_high) 851 { 852 struct cpuid cpu_id; 853 854 if (css_general_characteristics.mcss) { 855 css->global_pgid.pgid_high.ext_cssid.version = 0x80; 856 css->global_pgid.pgid_high.ext_cssid.cssid = 857 css->id_valid ? css->cssid : 0; 858 } else { 859 css->global_pgid.pgid_high.cpu_addr = stap(); 860 } 861 get_cpu_id(&cpu_id); 862 css->global_pgid.cpu_id = cpu_id.ident; 863 css->global_pgid.cpu_model = cpu_id.machine; 864 css->global_pgid.tod_high = tod_high; 865 } 866 867 static void channel_subsystem_release(struct device *dev) 868 { 869 struct channel_subsystem *css = to_css(dev); 870 871 mutex_destroy(&css->mutex); 872 kfree(css); 873 } 874 875 static ssize_t real_cssid_show(struct device *dev, struct device_attribute *a, 876 char *buf) 877 { 878 struct channel_subsystem *css = to_css(dev); 879 880 if (!css->id_valid) 881 return -EINVAL; 882 883 return sysfs_emit(buf, "%x\n", css->cssid); 884 } 885 static DEVICE_ATTR_RO(real_cssid); 886 887 static ssize_t rescan_store(struct device *dev, struct device_attribute *a, 888 const char *buf, size_t count) 889 { 890 CIO_TRACE_EVENT(4, "usr-rescan"); 891 892 css_schedule_eval_all(); 893 css_complete_work(); 894 895 return count; 896 } 897 static DEVICE_ATTR_WO(rescan); 898 899 static ssize_t cm_enable_show(struct device *dev, struct device_attribute *a, 900 char *buf) 901 { 902 struct channel_subsystem *css = to_css(dev); 903 int ret; 904 905 mutex_lock(&css->mutex); 906 ret = sysfs_emit(buf, "%x\n", css->cm_enabled); 907 mutex_unlock(&css->mutex); 908 return ret; 909 } 910 911 static ssize_t cm_enable_store(struct device *dev, struct device_attribute *a, 912 const char *buf, size_t count) 913 { 914 struct channel_subsystem *css = to_css(dev); 915 unsigned long val; 916 int ret; 917 918 ret = kstrtoul(buf, 16, &val); 919 if (ret) 920 return ret; 921 mutex_lock(&css->mutex); 922 switch (val) { 923 case 0: 924 ret = css->cm_enabled ? chsc_secm(css, 0) : 0; 925 break; 926 case 1: 927 ret = css->cm_enabled ? 0 : chsc_secm(css, 1); 928 break; 929 default: 930 ret = -EINVAL; 931 } 932 mutex_unlock(&css->mutex); 933 return ret < 0 ? ret : count; 934 } 935 static DEVICE_ATTR_RW(cm_enable); 936 937 static umode_t cm_enable_mode(struct kobject *kobj, struct attribute *attr, 938 int index) 939 { 940 return css_chsc_characteristics.secm ? attr->mode : 0; 941 } 942 943 static struct attribute *cssdev_attrs[] = { 944 &dev_attr_real_cssid.attr, 945 &dev_attr_rescan.attr, 946 NULL, 947 }; 948 949 static struct attribute_group cssdev_attr_group = { 950 .attrs = cssdev_attrs, 951 }; 952 953 static struct attribute *cssdev_cm_attrs[] = { 954 &dev_attr_cm_enable.attr, 955 NULL, 956 }; 957 958 static struct attribute_group cssdev_cm_attr_group = { 959 .attrs = cssdev_cm_attrs, 960 .is_visible = cm_enable_mode, 961 }; 962 963 static const struct attribute_group *cssdev_attr_groups[] = { 964 &cssdev_attr_group, 965 &cssdev_cm_attr_group, 966 NULL, 967 }; 968 969 static int __init setup_css(int nr) 970 { 971 struct channel_subsystem *css; 972 int ret; 973 974 css = kzalloc(sizeof(*css), GFP_KERNEL); 975 if (!css) 976 return -ENOMEM; 977 978 channel_subsystems[nr] = css; 979 dev_set_name(&css->device, "css%x", nr); 980 css->device.groups = cssdev_attr_groups; 981 css->device.release = channel_subsystem_release; 982 /* 983 * We currently allocate notifier bits with this (using 984 * css->device as the device argument with the DMA API) 985 * and are fine with 64 bit addresses. 986 */ 987 ret = dma_coerce_mask_and_coherent(&css->device, DMA_BIT_MASK(64)); 988 if (ret) { 989 kfree(css); 990 goto out_err; 991 } 992 993 mutex_init(&css->mutex); 994 ret = chsc_get_cssid_iid(nr, &css->cssid, &css->iid); 995 if (!ret) { 996 css->id_valid = true; 997 pr_info("Partition identifier %01x.%01x\n", css->cssid, 998 css->iid); 999 } 1000 css_generate_pgid(css, (u32) (get_tod_clock() >> 32)); 1001 1002 ret = device_register(&css->device); 1003 if (ret) { 1004 put_device(&css->device); 1005 goto out_err; 1006 } 1007 1008 css->pseudo_subchannel = kzalloc(sizeof(*css->pseudo_subchannel), 1009 GFP_KERNEL); 1010 if (!css->pseudo_subchannel) { 1011 device_unregister(&css->device); 1012 ret = -ENOMEM; 1013 goto out_err; 1014 } 1015 1016 css->pseudo_subchannel->dev.parent = &css->device; 1017 css->pseudo_subchannel->dev.release = css_subchannel_release; 1018 mutex_init(&css->pseudo_subchannel->reg_mutex); 1019 css_sch_create_locks(css->pseudo_subchannel); 1020 1021 dev_set_name(&css->pseudo_subchannel->dev, "defunct"); 1022 ret = device_register(&css->pseudo_subchannel->dev); 1023 if (ret) { 1024 put_device(&css->pseudo_subchannel->dev); 1025 device_unregister(&css->device); 1026 goto out_err; 1027 } 1028 1029 return ret; 1030 out_err: 1031 channel_subsystems[nr] = NULL; 1032 return ret; 1033 } 1034 1035 static int css_reboot_event(struct notifier_block *this, 1036 unsigned long event, 1037 void *ptr) 1038 { 1039 struct channel_subsystem *css; 1040 int ret; 1041 1042 ret = NOTIFY_DONE; 1043 for_each_css(css) { 1044 mutex_lock(&css->mutex); 1045 if (css->cm_enabled) 1046 if (chsc_secm(css, 0)) 1047 ret = NOTIFY_BAD; 1048 mutex_unlock(&css->mutex); 1049 } 1050 1051 return ret; 1052 } 1053 1054 static struct notifier_block css_reboot_notifier = { 1055 .notifier_call = css_reboot_event, 1056 }; 1057 1058 #define CIO_DMA_GFP (GFP_KERNEL | __GFP_ZERO) 1059 static struct gen_pool *cio_dma_pool; 1060 1061 /* Currently cio supports only a single css */ 1062 struct device *cio_get_dma_css_dev(void) 1063 { 1064 return &channel_subsystems[0]->device; 1065 } 1066 1067 struct gen_pool *cio_gp_dma_create(struct device *dma_dev, int nr_pages) 1068 { 1069 struct gen_pool *gp_dma; 1070 void *cpu_addr; 1071 dma_addr_t dma_addr; 1072 int i; 1073 1074 gp_dma = gen_pool_create(3, -1); 1075 if (!gp_dma) 1076 return NULL; 1077 for (i = 0; i < nr_pages; ++i) { 1078 cpu_addr = dma_alloc_coherent(dma_dev, PAGE_SIZE, &dma_addr, 1079 CIO_DMA_GFP); 1080 if (!cpu_addr) 1081 return gp_dma; 1082 gen_pool_add_virt(gp_dma, (unsigned long) cpu_addr, 1083 dma_addr, PAGE_SIZE, -1); 1084 } 1085 return gp_dma; 1086 } 1087 1088 static void __gp_dma_free_dma(struct gen_pool *pool, 1089 struct gen_pool_chunk *chunk, void *data) 1090 { 1091 size_t chunk_size = chunk->end_addr - chunk->start_addr + 1; 1092 1093 dma_free_coherent((struct device *) data, chunk_size, 1094 (void *) chunk->start_addr, 1095 (dma_addr_t) chunk->phys_addr); 1096 } 1097 1098 void cio_gp_dma_destroy(struct gen_pool *gp_dma, struct device *dma_dev) 1099 { 1100 if (!gp_dma) 1101 return; 1102 /* this is quite ugly but no better idea */ 1103 gen_pool_for_each_chunk(gp_dma, __gp_dma_free_dma, dma_dev); 1104 gen_pool_destroy(gp_dma); 1105 } 1106 1107 static int cio_dma_pool_init(void) 1108 { 1109 /* No need to free up the resources: compiled in */ 1110 cio_dma_pool = cio_gp_dma_create(cio_get_dma_css_dev(), 1); 1111 if (!cio_dma_pool) 1112 return -ENOMEM; 1113 return 0; 1114 } 1115 1116 void *__cio_gp_dma_zalloc(struct gen_pool *gp_dma, struct device *dma_dev, 1117 size_t size, dma32_t *dma_handle) 1118 { 1119 dma_addr_t dma_addr; 1120 size_t chunk_size; 1121 void *addr; 1122 1123 if (!gp_dma) 1124 return NULL; 1125 addr = gen_pool_dma_alloc(gp_dma, size, &dma_addr); 1126 while (!addr) { 1127 chunk_size = round_up(size, PAGE_SIZE); 1128 addr = dma_alloc_coherent(dma_dev, chunk_size, &dma_addr, CIO_DMA_GFP); 1129 if (!addr) 1130 return NULL; 1131 gen_pool_add_virt(gp_dma, (unsigned long)addr, dma_addr, chunk_size, -1); 1132 addr = gen_pool_dma_alloc(gp_dma, size, dma_handle ? &dma_addr : NULL); 1133 } 1134 if (dma_handle) 1135 *dma_handle = (__force dma32_t)dma_addr; 1136 return addr; 1137 } 1138 1139 void *cio_gp_dma_zalloc(struct gen_pool *gp_dma, struct device *dma_dev, 1140 size_t size) 1141 { 1142 return __cio_gp_dma_zalloc(gp_dma, dma_dev, size, NULL); 1143 } 1144 1145 void cio_gp_dma_free(struct gen_pool *gp_dma, void *cpu_addr, size_t size) 1146 { 1147 if (!cpu_addr) 1148 return; 1149 memset(cpu_addr, 0, size); 1150 gen_pool_free(gp_dma, (unsigned long) cpu_addr, size); 1151 } 1152 1153 /* 1154 * Allocate dma memory from the css global pool. Intended for memory not 1155 * specific to any single device within the css. The allocated memory 1156 * is not guaranteed to be 31-bit addressable. 1157 * 1158 * Caution: Not suitable for early stuff like console. 1159 */ 1160 void *cio_dma_zalloc(size_t size) 1161 { 1162 return cio_gp_dma_zalloc(cio_dma_pool, cio_get_dma_css_dev(), size); 1163 } 1164 1165 void cio_dma_free(void *cpu_addr, size_t size) 1166 { 1167 cio_gp_dma_free(cio_dma_pool, cpu_addr, size); 1168 } 1169 1170 /* 1171 * Now that the driver core is running, we can setup our channel subsystem. 1172 * The struct subchannel's are created during probing. 1173 */ 1174 static int __init css_bus_init(void) 1175 { 1176 int ret, i; 1177 1178 ret = chsc_init(); 1179 if (ret) 1180 return ret; 1181 1182 chsc_determine_css_characteristics(); 1183 /* Try to enable MSS. */ 1184 ret = chsc_enable_facility(CHSC_SDA_OC_MSS); 1185 if (ret) 1186 max_ssid = 0; 1187 else /* Success. */ 1188 max_ssid = __MAX_SSID; 1189 1190 ret = slow_subchannel_init(); 1191 if (ret) 1192 goto out; 1193 1194 ret = crw_register_handler(CRW_RSC_SCH, css_process_crw); 1195 if (ret) 1196 goto out; 1197 1198 if ((ret = bus_register(&css_bus_type))) 1199 goto out; 1200 1201 /* Setup css structure. */ 1202 for (i = 0; i <= MAX_CSS_IDX; i++) { 1203 ret = setup_css(i); 1204 if (ret) 1205 goto out_unregister; 1206 } 1207 ret = register_reboot_notifier(&css_reboot_notifier); 1208 if (ret) 1209 goto out_unregister; 1210 ret = cio_dma_pool_init(); 1211 if (ret) 1212 goto out_unregister_rn; 1213 airq_init(); 1214 css_init_done = 1; 1215 1216 /* Enable default isc for I/O subchannels. */ 1217 isc_register(IO_SCH_ISC); 1218 1219 return 0; 1220 out_unregister_rn: 1221 unregister_reboot_notifier(&css_reboot_notifier); 1222 out_unregister: 1223 while (i-- > 0) { 1224 struct channel_subsystem *css = channel_subsystems[i]; 1225 device_unregister(&css->pseudo_subchannel->dev); 1226 device_unregister(&css->device); 1227 } 1228 bus_unregister(&css_bus_type); 1229 out: 1230 crw_unregister_handler(CRW_RSC_SCH); 1231 idset_free(slow_subchannel_set); 1232 chsc_init_cleanup(); 1233 pr_alert("The CSS device driver initialization failed with " 1234 "errno=%d\n", ret); 1235 return ret; 1236 } 1237 1238 static void __init css_bus_cleanup(void) 1239 { 1240 struct channel_subsystem *css; 1241 1242 for_each_css(css) { 1243 device_unregister(&css->pseudo_subchannel->dev); 1244 device_unregister(&css->device); 1245 } 1246 bus_unregister(&css_bus_type); 1247 crw_unregister_handler(CRW_RSC_SCH); 1248 idset_free(slow_subchannel_set); 1249 chsc_init_cleanup(); 1250 isc_unregister(IO_SCH_ISC); 1251 } 1252 1253 static int __init channel_subsystem_init(void) 1254 { 1255 int ret; 1256 1257 ret = css_bus_init(); 1258 if (ret) 1259 return ret; 1260 cio_work_q = create_singlethread_workqueue("cio"); 1261 if (!cio_work_q) { 1262 ret = -ENOMEM; 1263 goto out_bus; 1264 } 1265 ret = io_subchannel_init(); 1266 if (ret) 1267 goto out_wq; 1268 1269 /* Register subchannels which are already in use. */ 1270 cio_register_early_subchannels(); 1271 /* Start initial subchannel evaluation. */ 1272 css_schedule_eval_all(); 1273 1274 return ret; 1275 out_wq: 1276 destroy_workqueue(cio_work_q); 1277 out_bus: 1278 css_bus_cleanup(); 1279 return ret; 1280 } 1281 subsys_initcall(channel_subsystem_init); 1282 1283 static int css_settle(struct device_driver *drv, void *unused) 1284 { 1285 struct css_driver *cssdrv = to_cssdriver(drv); 1286 1287 if (cssdrv->settle) 1288 return cssdrv->settle(); 1289 return 0; 1290 } 1291 1292 int css_complete_work(void) 1293 { 1294 int ret; 1295 1296 /* Wait for the evaluation of subchannels to finish. */ 1297 ret = wait_event_interruptible(css_eval_wq, 1298 atomic_read(&css_eval_scheduled) == 0); 1299 if (ret) 1300 return -EINTR; 1301 flush_workqueue(cio_work_q); 1302 /* Wait for the subchannel type specific initialization to finish */ 1303 return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle); 1304 } 1305 1306 1307 /* 1308 * Wait for the initialization of devices to finish, to make sure we are 1309 * done with our setup if the search for the root device starts. 1310 */ 1311 static int __init channel_subsystem_init_sync(void) 1312 { 1313 css_complete_work(); 1314 return 0; 1315 } 1316 subsys_initcall_sync(channel_subsystem_init_sync); 1317 1318 #ifdef CONFIG_PROC_FS 1319 static ssize_t cio_settle_write(struct file *file, const char __user *buf, 1320 size_t count, loff_t *ppos) 1321 { 1322 int ret; 1323 1324 /* Handle pending CRW's. */ 1325 crw_wait_for_channel_report(); 1326 ret = css_complete_work(); 1327 1328 return ret ? ret : count; 1329 } 1330 1331 static const struct proc_ops cio_settle_proc_ops = { 1332 .proc_open = nonseekable_open, 1333 .proc_write = cio_settle_write, 1334 }; 1335 1336 static int __init cio_settle_init(void) 1337 { 1338 struct proc_dir_entry *entry; 1339 1340 entry = proc_create("cio_settle", S_IWUSR, NULL, &cio_settle_proc_ops); 1341 if (!entry) 1342 return -ENOMEM; 1343 return 0; 1344 } 1345 device_initcall(cio_settle_init); 1346 #endif /*CONFIG_PROC_FS*/ 1347 1348 int sch_is_pseudo_sch(struct subchannel *sch) 1349 { 1350 if (!sch->dev.parent) 1351 return 0; 1352 return sch == to_css(sch->dev.parent)->pseudo_subchannel; 1353 } 1354 1355 static int css_bus_match(struct device *dev, const struct device_driver *drv) 1356 { 1357 struct subchannel *sch = to_subchannel(dev); 1358 const struct css_driver *driver = to_cssdriver(drv); 1359 struct css_device_id *id; 1360 1361 /* When driver_override is set, only bind to the matching driver */ 1362 if (sch->driver_override && strcmp(sch->driver_override, drv->name)) 1363 return 0; 1364 1365 for (id = driver->subchannel_type; id->match_flags; id++) { 1366 if (sch->st == id->type) 1367 return 1; 1368 } 1369 1370 return 0; 1371 } 1372 1373 static int css_probe(struct device *dev) 1374 { 1375 struct subchannel *sch; 1376 int ret; 1377 1378 sch = to_subchannel(dev); 1379 sch->driver = to_cssdriver(dev->driver); 1380 ret = sch->driver->probe ? sch->driver->probe(sch) : 0; 1381 if (ret) 1382 sch->driver = NULL; 1383 return ret; 1384 } 1385 1386 static void css_remove(struct device *dev) 1387 { 1388 struct subchannel *sch; 1389 1390 sch = to_subchannel(dev); 1391 if (sch->driver->remove) 1392 sch->driver->remove(sch); 1393 sch->driver = NULL; 1394 } 1395 1396 static void css_shutdown(struct device *dev) 1397 { 1398 struct subchannel *sch; 1399 1400 sch = to_subchannel(dev); 1401 if (sch->driver && sch->driver->shutdown) 1402 sch->driver->shutdown(sch); 1403 } 1404 1405 static int css_uevent(const struct device *dev, struct kobj_uevent_env *env) 1406 { 1407 const struct subchannel *sch = to_subchannel(dev); 1408 int ret; 1409 1410 ret = add_uevent_var(env, "ST=%01X", sch->st); 1411 if (ret) 1412 return ret; 1413 ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st); 1414 return ret; 1415 } 1416 1417 static const struct bus_type css_bus_type = { 1418 .name = "css", 1419 .match = css_bus_match, 1420 .probe = css_probe, 1421 .remove = css_remove, 1422 .shutdown = css_shutdown, 1423 .uevent = css_uevent, 1424 }; 1425 1426 /** 1427 * css_driver_register - register a css driver 1428 * @cdrv: css driver to register 1429 * 1430 * This is mainly a wrapper around driver_register that sets name 1431 * and bus_type in the embedded struct device_driver correctly. 1432 */ 1433 int css_driver_register(struct css_driver *cdrv) 1434 { 1435 cdrv->drv.bus = &css_bus_type; 1436 return driver_register(&cdrv->drv); 1437 } 1438 EXPORT_SYMBOL_GPL(css_driver_register); 1439 1440 /** 1441 * css_driver_unregister - unregister a css driver 1442 * @cdrv: css driver to unregister 1443 * 1444 * This is a wrapper around driver_unregister. 1445 */ 1446 void css_driver_unregister(struct css_driver *cdrv) 1447 { 1448 driver_unregister(&cdrv->drv); 1449 } 1450 EXPORT_SYMBOL_GPL(css_driver_unregister); 1451