SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/s390/cio/css.c

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