2 * drivers/s390/cio/css.c
3 * driver for channel subsystem
5 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
7 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
8 * Cornelia Huck (cornelia.huck@de.ibm.com)
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>
19 #include "cio_debug.h"
26 int css_init_done
= 0;
27 static int need_reprobe
= 0;
28 static int max_ssid
= 0;
30 struct channel_subsystem
*css
[__MAX_CSSID
+ 1];
32 int css_characteristics_avail
= 0;
35 for_each_subchannel(int(*fn
)(struct subchannel_id
, void *), void *data
)
37 struct subchannel_id schid
;
40 init_subchannel_id(&schid
);
44 ret
= fn(schid
, data
);
47 } while (schid
.sch_no
++ < __MAX_SUBCHANNEL
);
49 } while (schid
.ssid
++ < max_ssid
);
53 static struct subchannel
*
54 css_alloc_subchannel(struct subchannel_id schid
)
56 struct subchannel
*sch
;
59 sch
= kmalloc (sizeof (*sch
), GFP_KERNEL
| GFP_DMA
);
61 return ERR_PTR(-ENOMEM
);
62 ret
= cio_validate_subchannel (sch
, schid
);
68 if (sch
->st
!= SUBCHANNEL_TYPE_IO
) {
69 /* For now we ignore all non-io subchannels. */
71 return ERR_PTR(-EINVAL
);
75 * Set intparm to subchannel address.
76 * This is fine even on 64bit since the subchannel is always located
79 sch
->schib
.pmcw
.intparm
= (__u32
)(unsigned long)sch
;
80 ret
= cio_modify(sch
);
90 css_free_subchannel(struct subchannel
*sch
)
93 /* Reset intparm to zeroes. */
94 sch
->schib
.pmcw
.intparm
= 0;
102 css_subchannel_release(struct device
*dev
)
104 struct subchannel
*sch
;
106 sch
= to_subchannel(dev
);
107 if (!cio_is_console(sch
->schid
)) {
113 static int css_sch_device_register(struct subchannel
*sch
)
117 mutex_lock(&sch
->reg_mutex
);
118 ret
= device_register(&sch
->dev
);
119 mutex_unlock(&sch
->reg_mutex
);
123 void css_sch_device_unregister(struct subchannel
*sch
)
125 mutex_lock(&sch
->reg_mutex
);
126 device_unregister(&sch
->dev
);
127 mutex_unlock(&sch
->reg_mutex
);
130 static void ssd_from_pmcw(struct chsc_ssd_info
*ssd
, struct pmcw
*pmcw
)
135 memset(ssd
, 0, sizeof(struct chsc_ssd_info
));
136 ssd
->path_mask
= pmcw
->pim
;
137 for (i
= 0; i
< 8; i
++) {
139 if (pmcw
->pim
& mask
) {
140 chp_id_init(&ssd
->chpid
[i
]);
141 ssd
->chpid
[i
].id
= pmcw
->chpid
[i
];
146 static void ssd_register_chpids(struct chsc_ssd_info
*ssd
)
151 for (i
= 0; i
< 8; i
++) {
153 if (ssd
->path_mask
& mask
)
154 if (!chp_is_registered(ssd
->chpid
[i
]))
155 chp_new(ssd
->chpid
[i
]);
159 void css_update_ssd_info(struct subchannel
*sch
)
163 if (cio_is_console(sch
->schid
)) {
164 /* Console is initialized too early for functions requiring
165 * memory allocation. */
166 ssd_from_pmcw(&sch
->ssd_info
, &sch
->schib
.pmcw
);
168 ret
= chsc_get_ssd_info(sch
->schid
, &sch
->ssd_info
);
170 ssd_from_pmcw(&sch
->ssd_info
, &sch
->schib
.pmcw
);
171 ssd_register_chpids(&sch
->ssd_info
);
175 static int css_register_subchannel(struct subchannel
*sch
)
179 /* Initialize the subchannel structure */
180 sch
->dev
.parent
= &css
[0]->device
;
181 sch
->dev
.bus
= &css_bus_type
;
182 sch
->dev
.release
= &css_subchannel_release
;
183 sch
->dev
.groups
= subch_attr_groups
;
184 css_update_ssd_info(sch
);
185 /* make it known to the system */
186 ret
= css_sch_device_register(sch
);
188 CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
189 sch
->schid
.ssid
, sch
->schid
.sch_no
, ret
);
195 static int css_probe_device(struct subchannel_id schid
)
198 struct subchannel
*sch
;
200 sch
= css_alloc_subchannel(schid
);
203 ret
= css_register_subchannel(sch
);
205 css_free_subchannel(sch
);
210 check_subchannel(struct device
* dev
, void * data
)
212 struct subchannel
*sch
;
213 struct subchannel_id
*schid
= data
;
215 sch
= to_subchannel(dev
);
216 return schid_equal(&sch
->schid
, schid
);
220 get_subchannel_by_schid(struct subchannel_id schid
)
224 dev
= bus_find_device(&css_bus_type
, NULL
,
225 &schid
, check_subchannel
);
227 return dev
? to_subchannel(dev
) : NULL
;
230 static int css_get_subchannel_status(struct subchannel
*sch
)
234 if (stsch(sch
->schid
, &schib
) || !schib
.pmcw
.dnv
)
236 if (sch
->schib
.pmcw
.dnv
&& (schib
.pmcw
.dev
!= sch
->schib
.pmcw
.dev
))
237 return CIO_REVALIDATE
;
243 static int css_evaluate_known_subchannel(struct subchannel
*sch
, int slow
)
245 int event
, ret
, disc
;
247 enum { NONE
, UNREGISTER
, UNREGISTER_PROBE
, REPROBE
} action
;
249 spin_lock_irqsave(sch
->lock
, flags
);
250 disc
= device_is_disconnected(sch
);
252 /* Disconnected devices are evaluated directly only.*/
253 spin_unlock_irqrestore(sch
->lock
, flags
);
256 /* No interrupt after machine check - kill pending timers. */
257 device_kill_pending_timer(sch
);
258 if (!disc
&& !slow
) {
259 /* Non-disconnected devices are evaluated on the slow path. */
260 spin_unlock_irqrestore(sch
->lock
, flags
);
263 event
= css_get_subchannel_status(sch
);
264 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n",
265 sch
->schid
.ssid
, sch
->schid
.sch_no
, event
,
266 disc
? "disconnected" : "normal",
267 slow
? "slow" : "fast");
268 /* Analyze subchannel status. */
273 /* Check if paths have become available. */
279 /* Prevent unwanted effects when opening lock. */
280 cio_disable_subchannel(sch
);
281 device_set_disconnected(sch
);
282 /* Ask driver what to do with device. */
284 if (sch
->driver
&& sch
->driver
->notify
) {
285 spin_unlock_irqrestore(sch
->lock
, flags
);
286 ret
= sch
->driver
->notify(&sch
->dev
, event
);
287 spin_lock_irqsave(sch
->lock
, flags
);
293 /* Device will be removed, so no notify necessary. */
295 /* Reprobe because immediate unregister might block. */
298 action
= UNREGISTER_PROBE
;
302 /* Get device operational again. */
306 /* Perform action. */
310 case UNREGISTER_PROBE
:
311 /* Unregister device (will use subchannel lock). */
312 spin_unlock_irqrestore(sch
->lock
, flags
);
313 css_sch_device_unregister(sch
);
314 spin_lock_irqsave(sch
->lock
, flags
);
316 /* Reset intparm to zeroes. */
317 sch
->schib
.pmcw
.intparm
= 0;
321 device_trigger_reprobe(sch
);
326 spin_unlock_irqrestore(sch
->lock
, flags
);
327 /* Probe if necessary. */
328 if (action
== UNREGISTER_PROBE
)
329 ret
= css_probe_device(sch
->schid
);
334 static int css_evaluate_new_subchannel(struct subchannel_id schid
, int slow
)
339 /* Will be done on the slow path. */
342 if (stsch_err(schid
, &schib
) || !schib
.pmcw
.dnv
) {
343 /* Unusable - ignore. */
346 CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, "
347 "slow path.\n", schid
.ssid
, schid
.sch_no
, CIO_OPER
);
349 return css_probe_device(schid
);
352 static void css_evaluate_subchannel(struct subchannel_id schid
, int slow
)
354 struct subchannel
*sch
;
357 sch
= get_subchannel_by_schid(schid
);
359 ret
= css_evaluate_known_subchannel(sch
, slow
);
360 put_device(&sch
->dev
);
362 ret
= css_evaluate_new_subchannel(schid
, slow
);
364 css_schedule_eval(schid
);
367 static struct idset
*slow_subchannel_set
;
368 static spinlock_t slow_subchannel_lock
;
370 static int __init
slow_subchannel_init(void)
372 spin_lock_init(&slow_subchannel_lock
);
373 slow_subchannel_set
= idset_sch_new();
374 if (!slow_subchannel_set
) {
375 CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
381 static void css_slow_path_func(struct work_struct
*unused
)
383 struct subchannel_id schid
;
385 CIO_TRACE_EVENT(4, "slowpath");
386 spin_lock_irq(&slow_subchannel_lock
);
387 init_subchannel_id(&schid
);
388 while (idset_sch_get_first(slow_subchannel_set
, &schid
)) {
389 idset_sch_del(slow_subchannel_set
, schid
);
390 spin_unlock_irq(&slow_subchannel_lock
);
391 css_evaluate_subchannel(schid
, 1);
392 spin_lock_irq(&slow_subchannel_lock
);
394 spin_unlock_irq(&slow_subchannel_lock
);
397 static DECLARE_WORK(slow_path_work
, css_slow_path_func
);
398 struct workqueue_struct
*slow_path_wq
;
400 void css_schedule_eval(struct subchannel_id schid
)
404 spin_lock_irqsave(&slow_subchannel_lock
, flags
);
405 idset_sch_add(slow_subchannel_set
, schid
);
406 queue_work(slow_path_wq
, &slow_path_work
);
407 spin_unlock_irqrestore(&slow_subchannel_lock
, flags
);
410 void css_schedule_eval_all(void)
414 spin_lock_irqsave(&slow_subchannel_lock
, flags
);
415 idset_fill(slow_subchannel_set
);
416 queue_work(slow_path_wq
, &slow_path_work
);
417 spin_unlock_irqrestore(&slow_subchannel_lock
, flags
);
420 /* Reprobe subchannel if unregistered. */
421 static int reprobe_subchannel(struct subchannel_id schid
, void *data
)
423 struct subchannel
*sch
;
426 CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n",
427 schid
.ssid
, schid
.sch_no
);
431 sch
= get_subchannel_by_schid(schid
);
434 put_device(&sch
->dev
);
438 ret
= css_probe_device(schid
);
444 /* These should abort looping */
453 /* Work function used to reprobe all unregistered subchannels. */
454 static void reprobe_all(struct work_struct
*unused
)
458 CIO_MSG_EVENT(2, "reprobe start\n");
461 /* Make sure initial subchannel scan is done. */
462 wait_event(ccw_device_init_wq
,
463 atomic_read(&ccw_device_init_count
) == 0);
464 ret
= for_each_subchannel(reprobe_subchannel
, NULL
);
466 CIO_MSG_EVENT(2, "reprobe done (rc=%d, need_reprobe=%d)\n", ret
,
470 static DECLARE_WORK(css_reprobe_work
, reprobe_all
);
472 /* Schedule reprobing of all unregistered subchannels. */
473 void css_schedule_reprobe(void)
476 queue_work(ccw_device_work
, &css_reprobe_work
);
479 EXPORT_SYMBOL_GPL(css_schedule_reprobe
);
482 * Called from the machine check handler for subchannel report words.
484 void css_process_crw(int rsid1
, int rsid2
)
486 struct subchannel_id mchk_schid
;
488 CIO_CRW_EVENT(2, "source is subchannel %04X, subsystem id %x\n",
490 init_subchannel_id(&mchk_schid
);
491 mchk_schid
.sch_no
= rsid1
;
493 mchk_schid
.ssid
= (rsid2
>> 8) & 3;
496 * Since we are always presented with IPI in the CRW, we have to
497 * use stsch() to find out if the subchannel in question has come
500 css_evaluate_subchannel(mchk_schid
, 0);
504 __init_channel_subsystem(struct subchannel_id schid
, void *data
)
506 struct subchannel
*sch
;
509 if (cio_is_console(schid
))
510 sch
= cio_get_console_subchannel();
512 sch
= css_alloc_subchannel(schid
);
521 panic("Out of memory in init_channel_subsystem\n");
522 /* -ENXIO: no more subchannels. */
525 /* -EIO: this subchannel set not supported. */
533 * We register ALL valid subchannels in ioinfo, even those
534 * that have been present before init_channel_subsystem.
535 * These subchannels can't have been registered yet (kmalloc
536 * not working) so we do it now. This is true e.g. for the
537 * console subchannel.
539 css_register_subchannel(sch
);
544 css_generate_pgid(struct channel_subsystem
*css
, u32 tod_high
)
546 if (css_characteristics_avail
&& css_general_characteristics
.mcss
) {
547 css
->global_pgid
.pgid_high
.ext_cssid
.version
= 0x80;
548 css
->global_pgid
.pgid_high
.ext_cssid
.cssid
= css
->cssid
;
551 css
->global_pgid
.pgid_high
.cpu_addr
= hard_smp_processor_id();
553 css
->global_pgid
.pgid_high
.cpu_addr
= 0;
556 css
->global_pgid
.cpu_id
= ((cpuid_t
*) __LC_CPUID
)->ident
;
557 css
->global_pgid
.cpu_model
= ((cpuid_t
*) __LC_CPUID
)->machine
;
558 css
->global_pgid
.tod_high
= tod_high
;
563 channel_subsystem_release(struct device
*dev
)
565 struct channel_subsystem
*css
;
568 mutex_destroy(&css
->mutex
);
573 css_cm_enable_show(struct device
*dev
, struct device_attribute
*attr
,
576 struct channel_subsystem
*css
= to_css(dev
);
580 return sprintf(buf
, "%x\n", css
->cm_enabled
);
584 css_cm_enable_store(struct device
*dev
, struct device_attribute
*attr
,
585 const char *buf
, size_t count
)
587 struct channel_subsystem
*css
= to_css(dev
);
592 ret
= css
->cm_enabled
? chsc_secm(css
, 0) : 0;
595 ret
= css
->cm_enabled
? 0 : chsc_secm(css
, 1);
600 return ret
< 0 ? ret
: count
;
603 static DEVICE_ATTR(cm_enable
, 0644, css_cm_enable_show
, css_cm_enable_store
);
605 static int __init
setup_css(int nr
)
610 memset(css
[nr
], 0, sizeof(struct channel_subsystem
));
611 css
[nr
]->pseudo_subchannel
=
612 kzalloc(sizeof(*css
[nr
]->pseudo_subchannel
), GFP_KERNEL
);
613 if (!css
[nr
]->pseudo_subchannel
)
615 css
[nr
]->pseudo_subchannel
->dev
.parent
= &css
[nr
]->device
;
616 css
[nr
]->pseudo_subchannel
->dev
.release
= css_subchannel_release
;
617 sprintf(css
[nr
]->pseudo_subchannel
->dev
.bus_id
, "defunct");
618 ret
= cio_create_sch_lock(css
[nr
]->pseudo_subchannel
);
620 kfree(css
[nr
]->pseudo_subchannel
);
623 mutex_init(&css
[nr
]->mutex
);
626 sprintf(css
[nr
]->device
.bus_id
, "css%x", nr
);
627 css
[nr
]->device
.release
= channel_subsystem_release
;
628 tod_high
= (u32
) (get_clock() >> 32);
629 css_generate_pgid(css
[nr
], tod_high
);
634 * Now that the driver core is running, we can setup our channel subsystem.
635 * The struct subchannel's are created during probing (except for the
636 * static console subchannel).
639 init_channel_subsystem (void)
643 ret
= chsc_determine_css_characteristics();
645 goto out
; /* No need to continue. */
647 css_characteristics_avail
= 1;
649 ret
= chsc_alloc_sei_area();
653 ret
= slow_subchannel_init();
657 if ((ret
= bus_register(&css_bus_type
)))
660 /* Try to enable MSS. */
661 ret
= chsc_enable_facility(CHSC_SDA_OC_MSS
);
663 case 0: /* Success. */
664 max_ssid
= __MAX_SSID
;
671 /* Setup css structure. */
672 for (i
= 0; i
<= __MAX_CSSID
; i
++) {
673 css
[i
] = kmalloc(sizeof(struct channel_subsystem
), GFP_KERNEL
);
681 ret
= device_register(&css
[i
]->device
);
684 if (css_characteristics_avail
&&
685 css_chsc_characteristics
.secm
) {
686 ret
= device_create_file(&css
[i
]->device
,
687 &dev_attr_cm_enable
);
691 ret
= device_register(&css
[i
]->pseudo_subchannel
->dev
);
699 for_each_subchannel(__init_channel_subsystem
, NULL
);
702 device_remove_file(&css
[i
]->device
, &dev_attr_cm_enable
);
704 device_unregister(&css
[i
]->device
);
706 kfree(css
[i
]->pseudo_subchannel
->lock
);
707 kfree(css
[i
]->pseudo_subchannel
);
713 device_unregister(&css
[i
]->pseudo_subchannel
->dev
);
714 if (css_characteristics_avail
&& css_chsc_characteristics
.secm
)
715 device_remove_file(&css
[i
]->device
,
716 &dev_attr_cm_enable
);
717 device_unregister(&css
[i
]->device
);
720 bus_unregister(&css_bus_type
);
722 chsc_free_sei_area();
723 kfree(slow_subchannel_set
);
724 printk(KERN_WARNING
"cio: failed to initialize css driver (%d)!\n",
729 int sch_is_pseudo_sch(struct subchannel
*sch
)
731 return sch
== to_css(sch
->dev
.parent
)->pseudo_subchannel
;
735 * find a driver for a subchannel. They identify by the subchannel
736 * type with the exception that the console subchannel driver has its own
737 * subchannel type although the device is an i/o subchannel
740 css_bus_match (struct device
*dev
, struct device_driver
*drv
)
742 struct subchannel
*sch
= container_of (dev
, struct subchannel
, dev
);
743 struct css_driver
*driver
= container_of (drv
, struct css_driver
, drv
);
745 if (sch
->st
== driver
->subchannel_type
)
752 css_probe (struct device
*dev
)
754 struct subchannel
*sch
;
756 sch
= to_subchannel(dev
);
757 sch
->driver
= container_of (dev
->driver
, struct css_driver
, drv
);
758 return (sch
->driver
->probe
? sch
->driver
->probe(sch
) : 0);
762 css_remove (struct device
*dev
)
764 struct subchannel
*sch
;
766 sch
= to_subchannel(dev
);
767 return (sch
->driver
->remove
? sch
->driver
->remove(sch
) : 0);
771 css_shutdown (struct device
*dev
)
773 struct subchannel
*sch
;
775 sch
= to_subchannel(dev
);
776 if (sch
->driver
->shutdown
)
777 sch
->driver
->shutdown(sch
);
780 struct bus_type css_bus_type
= {
782 .match
= css_bus_match
,
784 .remove
= css_remove
,
785 .shutdown
= css_shutdown
,
788 subsys_initcall(init_channel_subsystem
);
790 MODULE_LICENSE("GPL");
791 EXPORT_SYMBOL(css_bus_type
);
792 EXPORT_SYMBOL_GPL(css_characteristics_avail
);