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