Merge branch 'linus' into x86/timers
[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 void css_wait_for_slow_path(void)
537 {
538         flush_workqueue(ccw_device_notify_work);
539         flush_workqueue(slow_path_wq);
540 }
541
542 /* Reprobe subchannel if unregistered. */
543 static int reprobe_subchannel(struct subchannel_id schid, void *data)
544 {
545         int ret;
546
547         CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n",
548                       schid.ssid, schid.sch_no);
549         if (need_reprobe)
550                 return -EAGAIN;
551
552         ret = css_probe_device(schid);
553         switch (ret) {
554         case 0:
555                 break;
556         case -ENXIO:
557         case -ENOMEM:
558         case -EIO:
559                 /* These should abort looping */
560                 break;
561         default:
562                 ret = 0;
563         }
564
565         return ret;
566 }
567
568 /* Work function used to reprobe all unregistered subchannels. */
569 static void reprobe_all(struct work_struct *unused)
570 {
571         int ret;
572
573         CIO_MSG_EVENT(4, "reprobe start\n");
574
575         need_reprobe = 0;
576         /* Make sure initial subchannel scan is done. */
577         wait_event(ccw_device_init_wq,
578                    atomic_read(&ccw_device_init_count) == 0);
579         ret = for_each_subchannel_staged(NULL, reprobe_subchannel, NULL);
580
581         CIO_MSG_EVENT(4, "reprobe done (rc=%d, need_reprobe=%d)\n", ret,
582                       need_reprobe);
583 }
584
585 static DECLARE_WORK(css_reprobe_work, reprobe_all);
586
587 /* Schedule reprobing of all unregistered subchannels. */
588 void css_schedule_reprobe(void)
589 {
590         need_reprobe = 1;
591         queue_work(slow_path_wq, &css_reprobe_work);
592 }
593
594 EXPORT_SYMBOL_GPL(css_schedule_reprobe);
595
596 /*
597  * Called from the machine check handler for subchannel report words.
598  */
599 void css_process_crw(int rsid1, int rsid2)
600 {
601         struct subchannel_id mchk_schid;
602
603         CIO_CRW_EVENT(2, "source is subchannel %04X, subsystem id %x\n",
604                       rsid1, rsid2);
605         init_subchannel_id(&mchk_schid);
606         mchk_schid.sch_no = rsid1;
607         if (rsid2 != 0)
608                 mchk_schid.ssid = (rsid2 >> 8) & 3;
609
610         /* 
611          * Since we are always presented with IPI in the CRW, we have to
612          * use stsch() to find out if the subchannel in question has come
613          * or gone.
614          */
615         css_evaluate_subchannel(mchk_schid, 0);
616 }
617
618 static int __init
619 __init_channel_subsystem(struct subchannel_id schid, void *data)
620 {
621         struct subchannel *sch;
622         int ret;
623
624         if (cio_is_console(schid))
625                 sch = cio_get_console_subchannel();
626         else {
627                 sch = css_alloc_subchannel(schid);
628                 if (IS_ERR(sch))
629                         ret = PTR_ERR(sch);
630                 else
631                         ret = 0;
632                 switch (ret) {
633                 case 0:
634                         break;
635                 case -ENOMEM:
636                         panic("Out of memory in init_channel_subsystem\n");
637                 /* -ENXIO: no more subchannels. */
638                 case -ENXIO:
639                         return ret;
640                 /* -EIO: this subchannel set not supported. */
641                 case -EIO:
642                         return ret;
643                 default:
644                         return 0;
645                 }
646         }
647         /*
648          * We register ALL valid subchannels in ioinfo, even those
649          * that have been present before init_channel_subsystem.
650          * These subchannels can't have been registered yet (kmalloc
651          * not working) so we do it now. This is true e.g. for the
652          * console subchannel.
653          */
654         css_register_subchannel(sch);
655         return 0;
656 }
657
658 static void __init
659 css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
660 {
661         if (css_characteristics_avail && css_general_characteristics.mcss) {
662                 css->global_pgid.pgid_high.ext_cssid.version = 0x80;
663                 css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid;
664         } else {
665 #ifdef CONFIG_SMP
666                 css->global_pgid.pgid_high.cpu_addr = hard_smp_processor_id();
667 #else
668                 css->global_pgid.pgid_high.cpu_addr = 0;
669 #endif
670         }
671         css->global_pgid.cpu_id = ((cpuid_t *) __LC_CPUID)->ident;
672         css->global_pgid.cpu_model = ((cpuid_t *) __LC_CPUID)->machine;
673         css->global_pgid.tod_high = tod_high;
674
675 }
676
677 static void
678 channel_subsystem_release(struct device *dev)
679 {
680         struct channel_subsystem *css;
681
682         css = to_css(dev);
683         mutex_destroy(&css->mutex);
684         kfree(css);
685 }
686
687 static ssize_t
688 css_cm_enable_show(struct device *dev, struct device_attribute *attr,
689                    char *buf)
690 {
691         struct channel_subsystem *css = to_css(dev);
692         int ret;
693
694         if (!css)
695                 return 0;
696         mutex_lock(&css->mutex);
697         ret = sprintf(buf, "%x\n", css->cm_enabled);
698         mutex_unlock(&css->mutex);
699         return ret;
700 }
701
702 static ssize_t
703 css_cm_enable_store(struct device *dev, struct device_attribute *attr,
704                     const char *buf, size_t count)
705 {
706         struct channel_subsystem *css = to_css(dev);
707         int ret;
708         unsigned long val;
709
710         ret = strict_strtoul(buf, 16, &val);
711         if (ret)
712                 return ret;
713         mutex_lock(&css->mutex);
714         switch (val) {
715         case 0:
716                 ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
717                 break;
718         case 1:
719                 ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
720                 break;
721         default:
722                 ret = -EINVAL;
723         }
724         mutex_unlock(&css->mutex);
725         return ret < 0 ? ret : count;
726 }
727
728 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
729
730 static int __init setup_css(int nr)
731 {
732         u32 tod_high;
733         int ret;
734         struct channel_subsystem *css;
735
736         css = channel_subsystems[nr];
737         memset(css, 0, sizeof(struct channel_subsystem));
738         css->pseudo_subchannel =
739                 kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
740         if (!css->pseudo_subchannel)
741                 return -ENOMEM;
742         css->pseudo_subchannel->dev.parent = &css->device;
743         css->pseudo_subchannel->dev.release = css_subchannel_release;
744         sprintf(css->pseudo_subchannel->dev.bus_id, "defunct");
745         ret = cio_create_sch_lock(css->pseudo_subchannel);
746         if (ret) {
747                 kfree(css->pseudo_subchannel);
748                 return ret;
749         }
750         mutex_init(&css->mutex);
751         css->valid = 1;
752         css->cssid = nr;
753         sprintf(css->device.bus_id, "css%x", nr);
754         css->device.release = channel_subsystem_release;
755         tod_high = (u32) (get_clock() >> 32);
756         css_generate_pgid(css, tod_high);
757         return 0;
758 }
759
760 static int css_reboot_event(struct notifier_block *this,
761                             unsigned long event,
762                             void *ptr)
763 {
764         int ret, i;
765
766         ret = NOTIFY_DONE;
767         for (i = 0; i <= __MAX_CSSID; i++) {
768                 struct channel_subsystem *css;
769
770                 css = channel_subsystems[i];
771                 mutex_lock(&css->mutex);
772                 if (css->cm_enabled)
773                         if (chsc_secm(css, 0))
774                                 ret = NOTIFY_BAD;
775                 mutex_unlock(&css->mutex);
776         }
777
778         return ret;
779 }
780
781 static struct notifier_block css_reboot_notifier = {
782         .notifier_call = css_reboot_event,
783 };
784
785 /*
786  * Now that the driver core is running, we can setup our channel subsystem.
787  * The struct subchannel's are created during probing (except for the
788  * static console subchannel).
789  */
790 static int __init
791 init_channel_subsystem (void)
792 {
793         int ret, i;
794
795         ret = chsc_determine_css_characteristics();
796         if (ret == -ENOMEM)
797                 goto out; /* No need to continue. */
798         if (ret == 0)
799                 css_characteristics_avail = 1;
800
801         ret = chsc_alloc_sei_area();
802         if (ret)
803                 goto out;
804
805         ret = slow_subchannel_init();
806         if (ret)
807                 goto out;
808
809         if ((ret = bus_register(&css_bus_type)))
810                 goto out;
811
812         /* Try to enable MSS. */
813         ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
814         switch (ret) {
815         case 0: /* Success. */
816                 max_ssid = __MAX_SSID;
817                 break;
818         case -ENOMEM:
819                 goto out_bus;
820         default:
821                 max_ssid = 0;
822         }
823         /* Setup css structure. */
824         for (i = 0; i <= __MAX_CSSID; i++) {
825                 struct channel_subsystem *css;
826
827                 css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
828                 if (!css) {
829                         ret = -ENOMEM;
830                         goto out_unregister;
831                 }
832                 channel_subsystems[i] = css;
833                 ret = setup_css(i);
834                 if (ret)
835                         goto out_free;
836                 ret = device_register(&css->device);
837                 if (ret)
838                         goto out_free_all;
839                 if (css_characteristics_avail &&
840                     css_chsc_characteristics.secm) {
841                         ret = device_create_file(&css->device,
842                                                  &dev_attr_cm_enable);
843                         if (ret)
844                                 goto out_device;
845                 }
846                 ret = device_register(&css->pseudo_subchannel->dev);
847                 if (ret)
848                         goto out_file;
849         }
850         ret = register_reboot_notifier(&css_reboot_notifier);
851         if (ret)
852                 goto out_pseudo;
853         css_init_done = 1;
854
855         ctl_set_bit(6, 28);
856
857         for_each_subchannel(__init_channel_subsystem, NULL);
858         return 0;
859 out_pseudo:
860         device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev);
861 out_file:
862         device_remove_file(&channel_subsystems[i]->device,
863                            &dev_attr_cm_enable);
864 out_device:
865         device_unregister(&channel_subsystems[i]->device);
866 out_free_all:
867         kfree(channel_subsystems[i]->pseudo_subchannel->lock);
868         kfree(channel_subsystems[i]->pseudo_subchannel);
869 out_free:
870         kfree(channel_subsystems[i]);
871 out_unregister:
872         while (i > 0) {
873                 struct channel_subsystem *css;
874
875                 i--;
876                 css = channel_subsystems[i];
877                 device_unregister(&css->pseudo_subchannel->dev);
878                 if (css_characteristics_avail && css_chsc_characteristics.secm)
879                         device_remove_file(&css->device,
880                                            &dev_attr_cm_enable);
881                 device_unregister(&css->device);
882         }
883 out_bus:
884         bus_unregister(&css_bus_type);
885 out:
886         chsc_free_sei_area();
887         kfree(slow_subchannel_set);
888         printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n",
889                ret);
890         return ret;
891 }
892
893 int sch_is_pseudo_sch(struct subchannel *sch)
894 {
895         return sch == to_css(sch->dev.parent)->pseudo_subchannel;
896 }
897
898 /*
899  * find a driver for a subchannel. They identify by the subchannel
900  * type with the exception that the console subchannel driver has its own
901  * subchannel type although the device is an i/o subchannel
902  */
903 static int
904 css_bus_match (struct device *dev, struct device_driver *drv)
905 {
906         struct subchannel *sch = to_subchannel(dev);
907         struct css_driver *driver = to_cssdriver(drv);
908
909         if (sch->st == driver->subchannel_type)
910                 return 1;
911
912         return 0;
913 }
914
915 static int css_probe(struct device *dev)
916 {
917         struct subchannel *sch;
918         int ret;
919
920         sch = to_subchannel(dev);
921         sch->driver = to_cssdriver(dev->driver);
922         ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
923         if (ret)
924                 sch->driver = NULL;
925         return ret;
926 }
927
928 static int css_remove(struct device *dev)
929 {
930         struct subchannel *sch;
931         int ret;
932
933         sch = to_subchannel(dev);
934         ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
935         sch->driver = NULL;
936         return ret;
937 }
938
939 static void css_shutdown(struct device *dev)
940 {
941         struct subchannel *sch;
942
943         sch = to_subchannel(dev);
944         if (sch->driver && sch->driver->shutdown)
945                 sch->driver->shutdown(sch);
946 }
947
948 struct bus_type css_bus_type = {
949         .name     = "css",
950         .match    = css_bus_match,
951         .probe    = css_probe,
952         .remove   = css_remove,
953         .shutdown = css_shutdown,
954 };
955
956 /**
957  * css_driver_register - register a css driver
958  * @cdrv: css driver to register
959  *
960  * This is mainly a wrapper around driver_register that sets name
961  * and bus_type in the embedded struct device_driver correctly.
962  */
963 int css_driver_register(struct css_driver *cdrv)
964 {
965         cdrv->drv.name = cdrv->name;
966         cdrv->drv.bus = &css_bus_type;
967         cdrv->drv.owner = cdrv->owner;
968         return driver_register(&cdrv->drv);
969 }
970 EXPORT_SYMBOL_GPL(css_driver_register);
971
972 /**
973  * css_driver_unregister - unregister a css driver
974  * @cdrv: css driver to unregister
975  *
976  * This is a wrapper around driver_unregister.
977  */
978 void css_driver_unregister(struct css_driver *cdrv)
979 {
980         driver_unregister(&cdrv->drv);
981 }
982 EXPORT_SYMBOL_GPL(css_driver_unregister);
983
984 subsys_initcall(init_channel_subsystem);
985
986 MODULE_LICENSE("GPL");
987 EXPORT_SYMBOL(css_bus_type);
988 EXPORT_SYMBOL_GPL(css_characteristics_avail);