2 * driver for channel subsystem
4 * Copyright IBM Corp. 2002, 2010
6 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
7 * Cornelia Huck (cornelia.huck@de.ibm.com)
12 #define KMSG_COMPONENT "cio"
13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15 #include <linux/export.h>
16 #include <linux/init.h>
17 #include <linux/device.h>
18 #include <linux/slab.h>
19 #include <linux/errno.h>
20 #include <linux/list.h>
21 #include <linux/reboot.h>
22 #include <linux/suspend.h>
23 #include <linux/proc_fs.h>
29 #include "cio_debug.h"
36 int css_init_done = 0;
40 struct channel_subsystem *channel_subsystems[MAX_CSS_IDX + 1];
41 static struct bus_type css_bus_type;
44 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
46 struct subchannel_id schid;
49 init_subchannel_id(&schid);
52 ret = fn(schid, data);
55 } while (schid.sch_no++ < __MAX_SUBCHANNEL);
57 } while (schid.ssid++ < max_ssid);
64 int (*fn_known_sch)(struct subchannel *, void *);
65 int (*fn_unknown_sch)(struct subchannel_id, void *);
68 static int call_fn_known_sch(struct device *dev, void *data)
70 struct subchannel *sch = to_subchannel(dev);
71 struct cb_data *cb = data;
75 idset_sch_del(cb->set, sch->schid);
77 rc = cb->fn_known_sch(sch, cb->data);
81 static int call_fn_unknown_sch(struct subchannel_id schid, void *data)
83 struct cb_data *cb = data;
86 if (idset_sch_contains(cb->set, schid))
87 rc = cb->fn_unknown_sch(schid, cb->data);
91 static int call_fn_all_sch(struct subchannel_id schid, void *data)
93 struct cb_data *cb = data;
94 struct subchannel *sch;
97 sch = get_subchannel_by_schid(schid);
100 rc = cb->fn_known_sch(sch, cb->data);
101 put_device(&sch->dev);
103 if (cb->fn_unknown_sch)
104 rc = cb->fn_unknown_sch(schid, cb->data);
110 int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
111 int (*fn_unknown)(struct subchannel_id,
118 cb.fn_known_sch = fn_known;
119 cb.fn_unknown_sch = fn_unknown;
121 if (fn_known && !fn_unknown) {
122 /* Skip idset allocation in case of known-only loop. */
124 return bus_for_each_dev(&css_bus_type, NULL, &cb,
128 cb.set = idset_sch_new();
130 /* fall back to brute force scanning in case of oom */
131 return for_each_subchannel(call_fn_all_sch, &cb);
135 /* Process registered subchannels. */
136 rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch);
139 /* Process unregistered subchannels. */
141 rc = for_each_subchannel(call_fn_unknown_sch, &cb);
148 static void css_sch_todo(struct work_struct *work);
150 static int css_sch_create_locks(struct subchannel *sch)
152 sch->lock = kmalloc(sizeof(*sch->lock), GFP_KERNEL);
156 spin_lock_init(sch->lock);
157 mutex_init(&sch->reg_mutex);
162 static void css_subchannel_release(struct device *dev)
164 struct subchannel *sch = to_subchannel(dev);
166 sch->config.intparm = 0;
167 cio_commit_config(sch);
172 struct subchannel *css_alloc_subchannel(struct subchannel_id schid)
174 struct subchannel *sch;
177 sch = kzalloc(sizeof(*sch), GFP_KERNEL | GFP_DMA);
179 return ERR_PTR(-ENOMEM);
181 ret = cio_validate_subchannel(sch, schid);
185 ret = css_sch_create_locks(sch);
189 INIT_WORK(&sch->todo_work, css_sch_todo);
190 sch->dev.release = &css_subchannel_release;
191 device_initialize(&sch->dev);
199 static int css_sch_device_register(struct subchannel *sch)
203 mutex_lock(&sch->reg_mutex);
204 dev_set_name(&sch->dev, "0.%x.%04x", sch->schid.ssid,
206 ret = device_add(&sch->dev);
207 mutex_unlock(&sch->reg_mutex);
212 * css_sch_device_unregister - unregister a subchannel
213 * @sch: subchannel to be unregistered
215 void css_sch_device_unregister(struct subchannel *sch)
217 mutex_lock(&sch->reg_mutex);
218 if (device_is_registered(&sch->dev))
219 device_unregister(&sch->dev);
220 mutex_unlock(&sch->reg_mutex);
222 EXPORT_SYMBOL_GPL(css_sch_device_unregister);
224 static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
229 memset(ssd, 0, sizeof(struct chsc_ssd_info));
230 ssd->path_mask = pmcw->pim;
231 for (i = 0; i < 8; i++) {
233 if (pmcw->pim & mask) {
234 chp_id_init(&ssd->chpid[i]);
235 ssd->chpid[i].id = pmcw->chpid[i];
240 static void ssd_register_chpids(struct chsc_ssd_info *ssd)
245 for (i = 0; i < 8; i++) {
247 if (ssd->path_mask & mask)
248 if (!chp_is_registered(ssd->chpid[i]))
249 chp_new(ssd->chpid[i]);
253 void css_update_ssd_info(struct subchannel *sch)
257 ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
259 ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
261 ssd_register_chpids(&sch->ssd_info);
264 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
267 struct subchannel *sch = to_subchannel(dev);
269 return sprintf(buf, "%01x\n", sch->st);
272 static DEVICE_ATTR(type, 0444, type_show, NULL);
274 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
277 struct subchannel *sch = to_subchannel(dev);
279 return sprintf(buf, "css:t%01X\n", sch->st);
282 static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
284 static struct attribute *subch_attrs[] = {
286 &dev_attr_modalias.attr,
290 static struct attribute_group subch_attr_group = {
291 .attrs = subch_attrs,
294 static const struct attribute_group *default_subch_attr_groups[] = {
299 static ssize_t chpids_show(struct device *dev,
300 struct device_attribute *attr,
303 struct subchannel *sch = to_subchannel(dev);
304 struct chsc_ssd_info *ssd = &sch->ssd_info;
309 for (chp = 0; chp < 8; chp++) {
311 if (ssd->path_mask & mask)
312 ret += sprintf(buf + ret, "%02x ", ssd->chpid[chp].id);
314 ret += sprintf(buf + ret, "00 ");
316 ret += sprintf(buf + ret, "\n");
319 static DEVICE_ATTR(chpids, 0444, chpids_show, NULL);
321 static ssize_t pimpampom_show(struct device *dev,
322 struct device_attribute *attr,
325 struct subchannel *sch = to_subchannel(dev);
326 struct pmcw *pmcw = &sch->schib.pmcw;
328 return sprintf(buf, "%02x %02x %02x\n",
329 pmcw->pim, pmcw->pam, pmcw->pom);
331 static DEVICE_ATTR(pimpampom, 0444, pimpampom_show, NULL);
333 static ssize_t dev_busid_show(struct device *dev,
334 struct device_attribute *attr,
337 struct subchannel *sch = to_subchannel(dev);
338 struct pmcw *pmcw = &sch->schib.pmcw;
340 if ((pmcw->st == SUBCHANNEL_TYPE_IO && pmcw->dnv) ||
341 (pmcw->st == SUBCHANNEL_TYPE_MSG && pmcw->w))
342 return sysfs_emit(buf, "0.%x.%04x\n", sch->schid.ssid,
345 return sysfs_emit(buf, "none\n");
347 static DEVICE_ATTR_RO(dev_busid);
349 static struct attribute *io_subchannel_type_attrs[] = {
350 &dev_attr_chpids.attr,
351 &dev_attr_pimpampom.attr,
352 &dev_attr_dev_busid.attr,
355 ATTRIBUTE_GROUPS(io_subchannel_type);
357 static const struct device_type io_subchannel_type = {
358 .groups = io_subchannel_type_groups,
361 int css_register_subchannel(struct subchannel *sch)
365 /* Initialize the subchannel structure */
366 sch->dev.parent = &channel_subsystems[0]->device;
367 sch->dev.bus = &css_bus_type;
368 sch->dev.groups = default_subch_attr_groups;
370 if (sch->st == SUBCHANNEL_TYPE_IO)
371 sch->dev.type = &io_subchannel_type;
374 * We don't want to generate uevents for I/O subchannels that don't
375 * have a working ccw device behind them since they will be
376 * unregistered before they can be used anyway, so we delay the add
377 * uevent until after device recognition was successful.
378 * Note that we suppress the uevent for all subchannel types;
379 * the subchannel driver can decide itself when it wants to inform
380 * userspace of its existence.
382 dev_set_uevent_suppress(&sch->dev, 1);
383 css_update_ssd_info(sch);
384 /* make it known to the system */
385 ret = css_sch_device_register(sch);
387 CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
388 sch->schid.ssid, sch->schid.sch_no, ret);
393 * No driver matched. Generate the uevent now so that
394 * a fitting driver module may be loaded based on the
397 dev_set_uevent_suppress(&sch->dev, 0);
398 kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
403 static int css_probe_device(struct subchannel_id schid)
405 struct subchannel *sch;
408 sch = css_alloc_subchannel(schid);
412 ret = css_register_subchannel(sch);
414 put_device(&sch->dev);
420 check_subchannel(struct device * dev, void * data)
422 struct subchannel *sch;
423 struct subchannel_id *schid = data;
425 sch = to_subchannel(dev);
426 return schid_equal(&sch->schid, schid);
430 get_subchannel_by_schid(struct subchannel_id schid)
434 dev = bus_find_device(&css_bus_type, NULL,
435 &schid, check_subchannel);
437 return dev ? to_subchannel(dev) : NULL;
441 * css_sch_is_valid() - check if a subchannel is valid
442 * @schib: subchannel information block for the subchannel
444 int css_sch_is_valid(struct schib *schib)
446 if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv)
448 if ((schib->pmcw.st == SUBCHANNEL_TYPE_MSG) && !schib->pmcw.w)
452 EXPORT_SYMBOL_GPL(css_sch_is_valid);
454 static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
459 /* Will be done on the slow path. */
462 if (stsch(schid, &schib)) {
463 /* Subchannel is not provided. */
466 if (!css_sch_is_valid(&schib)) {
467 /* Unusable - ignore. */
470 CIO_MSG_EVENT(4, "event: sch 0.%x.%04x, new\n", schid.ssid,
473 return css_probe_device(schid);
476 static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
481 if (sch->driver->sch_event)
482 ret = sch->driver->sch_event(sch, slow);
485 "Got subchannel machine check but "
486 "no sch_event handler provided.\n");
488 if (ret != 0 && ret != -EAGAIN) {
489 CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n",
490 sch->schid.ssid, sch->schid.sch_no, ret);
495 static void css_evaluate_subchannel(struct subchannel_id schid, int slow)
497 struct subchannel *sch;
500 sch = get_subchannel_by_schid(schid);
502 ret = css_evaluate_known_subchannel(sch, slow);
503 put_device(&sch->dev);
505 ret = css_evaluate_new_subchannel(schid, slow);
507 css_schedule_eval(schid);
511 * css_sched_sch_todo - schedule a subchannel operation
515 * Schedule the operation identified by @todo to be performed on the slow path
516 * workqueue. Do nothing if another operation with higher priority is already
517 * scheduled. Needs to be called with subchannel lock held.
519 void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo)
521 CIO_MSG_EVENT(4, "sch_todo: sched sch=0.%x.%04x todo=%d\n",
522 sch->schid.ssid, sch->schid.sch_no, todo);
523 if (sch->todo >= todo)
525 /* Get workqueue ref. */
526 if (!get_device(&sch->dev))
529 if (!queue_work(cio_work_q, &sch->todo_work)) {
530 /* Already queued, release workqueue ref. */
531 put_device(&sch->dev);
534 EXPORT_SYMBOL_GPL(css_sched_sch_todo);
536 static void css_sch_todo(struct work_struct *work)
538 struct subchannel *sch;
542 sch = container_of(work, struct subchannel, todo_work);
544 spin_lock_irq(sch->lock);
546 CIO_MSG_EVENT(4, "sch_todo: sch=0.%x.%04x, todo=%d\n", sch->schid.ssid,
547 sch->schid.sch_no, todo);
548 sch->todo = SCH_TODO_NOTHING;
549 spin_unlock_irq(sch->lock);
552 case SCH_TODO_NOTHING:
555 ret = css_evaluate_known_subchannel(sch, 1);
556 if (ret == -EAGAIN) {
557 spin_lock_irq(sch->lock);
558 css_sched_sch_todo(sch, todo);
559 spin_unlock_irq(sch->lock);
563 css_sch_device_unregister(sch);
566 /* Release workqueue ref. */
567 put_device(&sch->dev);
570 static struct idset *slow_subchannel_set;
571 static spinlock_t slow_subchannel_lock;
572 static wait_queue_head_t css_eval_wq;
573 static atomic_t css_eval_scheduled;
575 static int __init slow_subchannel_init(void)
577 spin_lock_init(&slow_subchannel_lock);
578 atomic_set(&css_eval_scheduled, 0);
579 init_waitqueue_head(&css_eval_wq);
580 slow_subchannel_set = idset_sch_new();
581 if (!slow_subchannel_set) {
582 CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
588 static int slow_eval_known_fn(struct subchannel *sch, void *data)
593 spin_lock_irq(&slow_subchannel_lock);
594 eval = idset_sch_contains(slow_subchannel_set, sch->schid);
595 idset_sch_del(slow_subchannel_set, sch->schid);
596 spin_unlock_irq(&slow_subchannel_lock);
598 rc = css_evaluate_known_subchannel(sch, 1);
600 css_schedule_eval(sch->schid);
602 * The loop might take long time for platforms with lots of
603 * known devices. Allow scheduling here.
610 static int slow_eval_unknown_fn(struct subchannel_id schid, void *data)
615 spin_lock_irq(&slow_subchannel_lock);
616 eval = idset_sch_contains(slow_subchannel_set, schid);
617 idset_sch_del(slow_subchannel_set, schid);
618 spin_unlock_irq(&slow_subchannel_lock);
620 rc = css_evaluate_new_subchannel(schid, 1);
623 css_schedule_eval(schid);
629 /* These should abort looping */
630 spin_lock_irq(&slow_subchannel_lock);
631 idset_sch_del_subseq(slow_subchannel_set, schid);
632 spin_unlock_irq(&slow_subchannel_lock);
637 /* Allow scheduling here since the containing loop might
644 static void css_slow_path_func(struct work_struct *unused)
648 CIO_TRACE_EVENT(4, "slowpath");
649 for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn,
651 spin_lock_irqsave(&slow_subchannel_lock, flags);
652 if (idset_is_empty(slow_subchannel_set)) {
653 atomic_set(&css_eval_scheduled, 0);
654 wake_up(&css_eval_wq);
656 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
659 static DECLARE_DELAYED_WORK(slow_path_work, css_slow_path_func);
660 struct workqueue_struct *cio_work_q;
662 void css_schedule_eval(struct subchannel_id schid)
666 spin_lock_irqsave(&slow_subchannel_lock, flags);
667 idset_sch_add(slow_subchannel_set, schid);
668 atomic_set(&css_eval_scheduled, 1);
669 queue_delayed_work(cio_work_q, &slow_path_work, 0);
670 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
673 void css_schedule_eval_all(void)
677 spin_lock_irqsave(&slow_subchannel_lock, flags);
678 idset_fill(slow_subchannel_set);
679 atomic_set(&css_eval_scheduled, 1);
680 queue_delayed_work(cio_work_q, &slow_path_work, 0);
681 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
684 static int __unset_registered(struct device *dev, void *data)
686 struct idset *set = data;
687 struct subchannel *sch = to_subchannel(dev);
689 idset_sch_del(set, sch->schid);
693 void css_schedule_eval_all_unreg(unsigned long delay)
696 struct idset *unreg_set;
698 /* Find unregistered subchannels. */
699 unreg_set = idset_sch_new();
702 css_schedule_eval_all();
705 idset_fill(unreg_set);
706 bus_for_each_dev(&css_bus_type, NULL, unreg_set, __unset_registered);
707 /* Apply to slow_subchannel_set. */
708 spin_lock_irqsave(&slow_subchannel_lock, flags);
709 idset_add_set(slow_subchannel_set, unreg_set);
710 atomic_set(&css_eval_scheduled, 1);
711 queue_delayed_work(cio_work_q, &slow_path_work, delay);
712 spin_unlock_irqrestore(&slow_subchannel_lock, flags);
713 idset_free(unreg_set);
716 void css_wait_for_slow_path(void)
718 flush_workqueue(cio_work_q);
721 /* Schedule reprobing of all unregistered subchannels. */
722 void css_schedule_reprobe(void)
724 /* Schedule with a delay to allow merging of subsequent calls. */
725 css_schedule_eval_all_unreg(1 * HZ);
727 EXPORT_SYMBOL_GPL(css_schedule_reprobe);
730 * Called from the machine check handler for subchannel report words.
732 static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
734 struct subchannel_id mchk_schid;
735 struct subchannel *sch;
738 css_schedule_eval_all();
741 CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, "
742 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
743 crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
744 crw0->erc, crw0->rsid);
746 CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, "
747 "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
748 crw1->slct, crw1->oflw, crw1->chn, crw1->rsc,
749 crw1->anc, crw1->erc, crw1->rsid);
750 init_subchannel_id(&mchk_schid);
751 mchk_schid.sch_no = crw0->rsid;
753 mchk_schid.ssid = (crw1->rsid >> 4) & 3;
755 if (crw0->erc == CRW_ERC_PMOD) {
756 sch = get_subchannel_by_schid(mchk_schid);
758 css_update_ssd_info(sch);
759 put_device(&sch->dev);
763 * Since we are always presented with IPI in the CRW, we have to
764 * use stsch() to find out if the subchannel in question has come
767 css_evaluate_subchannel(mchk_schid, 0);
771 css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
775 if (css_general_characteristics.mcss) {
776 css->global_pgid.pgid_high.ext_cssid.version = 0x80;
777 css->global_pgid.pgid_high.ext_cssid.cssid =
778 (css->cssid < 0) ? 0 : css->cssid;
780 css->global_pgid.pgid_high.cpu_addr = stap();
783 css->global_pgid.cpu_id = cpu_id.ident;
784 css->global_pgid.cpu_model = cpu_id.machine;
785 css->global_pgid.tod_high = tod_high;
788 static void channel_subsystem_release(struct device *dev)
790 struct channel_subsystem *css = to_css(dev);
792 mutex_destroy(&css->mutex);
796 static ssize_t real_cssid_show(struct device *dev, struct device_attribute *a,
799 struct channel_subsystem *css = to_css(dev);
804 return sprintf(buf, "%x\n", css->cssid);
806 static DEVICE_ATTR_RO(real_cssid);
808 static ssize_t cm_enable_show(struct device *dev, struct device_attribute *a,
811 struct channel_subsystem *css = to_css(dev);
814 mutex_lock(&css->mutex);
815 ret = sprintf(buf, "%x\n", css->cm_enabled);
816 mutex_unlock(&css->mutex);
820 static ssize_t cm_enable_store(struct device *dev, struct device_attribute *a,
821 const char *buf, size_t count)
823 struct channel_subsystem *css = to_css(dev);
827 ret = kstrtoul(buf, 16, &val);
830 mutex_lock(&css->mutex);
833 ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
836 ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
841 mutex_unlock(&css->mutex);
842 return ret < 0 ? ret : count;
844 static DEVICE_ATTR_RW(cm_enable);
846 static umode_t cm_enable_mode(struct kobject *kobj, struct attribute *attr,
849 return css_chsc_characteristics.secm ? attr->mode : 0;
852 static struct attribute *cssdev_attrs[] = {
853 &dev_attr_real_cssid.attr,
857 static struct attribute_group cssdev_attr_group = {
858 .attrs = cssdev_attrs,
861 static struct attribute *cssdev_cm_attrs[] = {
862 &dev_attr_cm_enable.attr,
866 static struct attribute_group cssdev_cm_attr_group = {
867 .attrs = cssdev_cm_attrs,
868 .is_visible = cm_enable_mode,
871 static const struct attribute_group *cssdev_attr_groups[] = {
873 &cssdev_cm_attr_group,
877 static int __init setup_css(int nr)
879 struct channel_subsystem *css;
882 css = kzalloc(sizeof(*css), GFP_KERNEL);
886 channel_subsystems[nr] = css;
887 dev_set_name(&css->device, "css%x", nr);
888 css->device.groups = cssdev_attr_groups;
889 css->device.release = channel_subsystem_release;
891 mutex_init(&css->mutex);
892 css->cssid = chsc_get_cssid(nr);
893 css_generate_pgid(css, (u32) (get_tod_clock() >> 32));
895 ret = device_register(&css->device);
897 put_device(&css->device);
901 css->pseudo_subchannel = kzalloc(sizeof(*css->pseudo_subchannel),
903 if (!css->pseudo_subchannel) {
904 device_unregister(&css->device);
909 css->pseudo_subchannel->dev.parent = &css->device;
910 css->pseudo_subchannel->dev.release = css_subchannel_release;
911 mutex_init(&css->pseudo_subchannel->reg_mutex);
912 ret = css_sch_create_locks(css->pseudo_subchannel);
914 kfree(css->pseudo_subchannel);
915 device_unregister(&css->device);
919 dev_set_name(&css->pseudo_subchannel->dev, "defunct");
920 ret = device_register(&css->pseudo_subchannel->dev);
922 put_device(&css->pseudo_subchannel->dev);
923 device_unregister(&css->device);
929 channel_subsystems[nr] = NULL;
933 static int css_reboot_event(struct notifier_block *this,
937 struct channel_subsystem *css;
942 mutex_lock(&css->mutex);
944 if (chsc_secm(css, 0))
946 mutex_unlock(&css->mutex);
952 static struct notifier_block css_reboot_notifier = {
953 .notifier_call = css_reboot_event,
957 * Since the css devices are neither on a bus nor have a class
958 * nor have a special device type, we cannot stop/restart channel
959 * path measurements via the normal suspend/resume callbacks, but have
962 static int css_power_event(struct notifier_block *this, unsigned long event,
965 struct channel_subsystem *css;
969 case PM_HIBERNATION_PREPARE:
970 case PM_SUSPEND_PREPARE:
973 mutex_lock(&css->mutex);
974 if (!css->cm_enabled) {
975 mutex_unlock(&css->mutex);
978 ret = __chsc_do_secm(css, 0);
979 ret = notifier_from_errno(ret);
980 mutex_unlock(&css->mutex);
983 case PM_POST_HIBERNATION:
984 case PM_POST_SUSPEND:
987 mutex_lock(&css->mutex);
988 if (!css->cm_enabled) {
989 mutex_unlock(&css->mutex);
992 ret = __chsc_do_secm(css, 1);
993 ret = notifier_from_errno(ret);
994 mutex_unlock(&css->mutex);
996 /* search for subchannels, which appeared during hibernation */
997 css_schedule_reprobe();
1005 static struct notifier_block css_power_notifier = {
1006 .notifier_call = css_power_event,
1010 * Now that the driver core is running, we can setup our channel subsystem.
1011 * The struct subchannel's are created during probing.
1013 static int __init css_bus_init(void)
1021 chsc_determine_css_characteristics();
1022 /* Try to enable MSS. */
1023 ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
1027 max_ssid = __MAX_SSID;
1029 ret = slow_subchannel_init();
1033 ret = crw_register_handler(CRW_RSC_SCH, css_process_crw);
1037 if ((ret = bus_register(&css_bus_type)))
1040 /* Setup css structure. */
1041 for (i = 0; i <= MAX_CSS_IDX; i++) {
1044 goto out_unregister;
1046 ret = register_reboot_notifier(&css_reboot_notifier);
1048 goto out_unregister;
1049 ret = register_pm_notifier(&css_power_notifier);
1051 unregister_reboot_notifier(&css_reboot_notifier);
1052 goto out_unregister;
1056 /* Enable default isc for I/O subchannels. */
1057 isc_register(IO_SCH_ISC);
1062 struct channel_subsystem *css = channel_subsystems[i];
1063 device_unregister(&css->pseudo_subchannel->dev);
1064 device_unregister(&css->device);
1066 bus_unregister(&css_bus_type);
1068 crw_unregister_handler(CRW_RSC_SCH);
1069 idset_free(slow_subchannel_set);
1070 chsc_init_cleanup();
1071 pr_alert("The CSS device driver initialization failed with "
1076 static void __init css_bus_cleanup(void)
1078 struct channel_subsystem *css;
1081 device_unregister(&css->pseudo_subchannel->dev);
1082 device_unregister(&css->device);
1084 bus_unregister(&css_bus_type);
1085 crw_unregister_handler(CRW_RSC_SCH);
1086 idset_free(slow_subchannel_set);
1087 chsc_init_cleanup();
1088 isc_unregister(IO_SCH_ISC);
1091 static int __init channel_subsystem_init(void)
1095 ret = css_bus_init();
1098 cio_work_q = create_singlethread_workqueue("cio");
1103 ret = io_subchannel_init();
1109 destroy_workqueue(cio_work_q);
1114 subsys_initcall(channel_subsystem_init);
1116 static int css_settle(struct device_driver *drv, void *unused)
1118 struct css_driver *cssdrv = to_cssdriver(drv);
1121 return cssdrv->settle();
1125 int css_complete_work(void)
1129 /* Wait for the evaluation of subchannels to finish. */
1130 ret = wait_event_interruptible(css_eval_wq,
1131 atomic_read(&css_eval_scheduled) == 0);
1134 flush_workqueue(cio_work_q);
1135 /* Wait for the subchannel type specific initialization to finish */
1136 return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
1141 * Wait for the initialization of devices to finish, to make sure we are
1142 * done with our setup if the search for the root device starts.
1144 static int __init channel_subsystem_init_sync(void)
1146 /* Register subchannels which are already in use. */
1147 cio_register_early_subchannels();
1148 /* Start initial subchannel evaluation. */
1149 css_schedule_eval_all();
1150 css_complete_work();
1153 subsys_initcall_sync(channel_subsystem_init_sync);
1155 void channel_subsystem_reinit(void)
1157 struct channel_path *chp;
1158 struct chp_id chpid;
1160 chsc_enable_facility(CHSC_SDA_OC_MSS);
1161 chp_id_for_each(&chpid) {
1162 chp = chpid_to_chp(chpid);
1164 chp_update_desc(chp);
1169 #ifdef CONFIG_PROC_FS
1170 static ssize_t cio_settle_write(struct file *file, const char __user *buf,
1171 size_t count, loff_t *ppos)
1175 /* Handle pending CRW's. */
1176 crw_wait_for_channel_report();
1177 ret = css_complete_work();
1179 return ret ? ret : count;
1182 static const struct file_operations cio_settle_proc_fops = {
1183 .open = nonseekable_open,
1184 .write = cio_settle_write,
1185 .llseek = no_llseek,
1188 static int __init cio_settle_init(void)
1190 struct proc_dir_entry *entry;
1192 entry = proc_create("cio_settle", S_IWUSR, NULL,
1193 &cio_settle_proc_fops);
1198 device_initcall(cio_settle_init);
1199 #endif /*CONFIG_PROC_FS*/
1201 int sch_is_pseudo_sch(struct subchannel *sch)
1203 if (!sch->dev.parent)
1205 return sch == to_css(sch->dev.parent)->pseudo_subchannel;
1208 static int css_bus_match(struct device *dev, struct device_driver *drv)
1210 struct subchannel *sch = to_subchannel(dev);
1211 struct css_driver *driver = to_cssdriver(drv);
1212 struct css_device_id *id;
1214 for (id = driver->subchannel_type; id->match_flags; id++) {
1215 if (sch->st == id->type)
1222 static int css_probe(struct device *dev)
1224 struct subchannel *sch;
1227 sch = to_subchannel(dev);
1228 sch->driver = to_cssdriver(dev->driver);
1229 ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
1235 static int css_remove(struct device *dev)
1237 struct subchannel *sch;
1240 sch = to_subchannel(dev);
1241 ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
1246 static void css_shutdown(struct device *dev)
1248 struct subchannel *sch;
1250 sch = to_subchannel(dev);
1251 if (sch->driver && sch->driver->shutdown)
1252 sch->driver->shutdown(sch);
1255 static int css_uevent(struct device *dev, struct kobj_uevent_env *env)
1257 struct subchannel *sch = to_subchannel(dev);
1260 ret = add_uevent_var(env, "ST=%01X", sch->st);
1263 ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st);
1267 static int css_pm_prepare(struct device *dev)
1269 struct subchannel *sch = to_subchannel(dev);
1270 struct css_driver *drv;
1272 if (mutex_is_locked(&sch->reg_mutex))
1274 if (!sch->dev.driver)
1276 drv = to_cssdriver(sch->dev.driver);
1277 /* Notify drivers that they may not register children. */
1278 return drv->prepare ? drv->prepare(sch) : 0;
1281 static void css_pm_complete(struct device *dev)
1283 struct subchannel *sch = to_subchannel(dev);
1284 struct css_driver *drv;
1286 if (!sch->dev.driver)
1288 drv = to_cssdriver(sch->dev.driver);
1293 static int css_pm_freeze(struct device *dev)
1295 struct subchannel *sch = to_subchannel(dev);
1296 struct css_driver *drv;
1298 if (!sch->dev.driver)
1300 drv = to_cssdriver(sch->dev.driver);
1301 return drv->freeze ? drv->freeze(sch) : 0;
1304 static int css_pm_thaw(struct device *dev)
1306 struct subchannel *sch = to_subchannel(dev);
1307 struct css_driver *drv;
1309 if (!sch->dev.driver)
1311 drv = to_cssdriver(sch->dev.driver);
1312 return drv->thaw ? drv->thaw(sch) : 0;
1315 static int css_pm_restore(struct device *dev)
1317 struct subchannel *sch = to_subchannel(dev);
1318 struct css_driver *drv;
1320 css_update_ssd_info(sch);
1321 if (!sch->dev.driver)
1323 drv = to_cssdriver(sch->dev.driver);
1324 return drv->restore ? drv->restore(sch) : 0;
1327 static const struct dev_pm_ops css_pm_ops = {
1328 .prepare = css_pm_prepare,
1329 .complete = css_pm_complete,
1330 .freeze = css_pm_freeze,
1331 .thaw = css_pm_thaw,
1332 .restore = css_pm_restore,
1335 static struct bus_type css_bus_type = {
1337 .match = css_bus_match,
1339 .remove = css_remove,
1340 .shutdown = css_shutdown,
1341 .uevent = css_uevent,
1346 * css_driver_register - register a css driver
1347 * @cdrv: css driver to register
1349 * This is mainly a wrapper around driver_register that sets name
1350 * and bus_type in the embedded struct device_driver correctly.
1352 int css_driver_register(struct css_driver *cdrv)
1354 cdrv->drv.bus = &css_bus_type;
1355 return driver_register(&cdrv->drv);
1357 EXPORT_SYMBOL_GPL(css_driver_register);
1360 * css_driver_unregister - unregister a css driver
1361 * @cdrv: css driver to unregister
1363 * This is a wrapper around driver_unregister.
1365 void css_driver_unregister(struct css_driver *cdrv)
1367 driver_unregister(&cdrv->drv);
1369 EXPORT_SYMBOL_GPL(css_driver_unregister);