drivers/s390/cio/css.c

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