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