2 * drivers/s390/cio/ccwgroup.c
3 * bus driver for ccwgroup
6 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
8 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
9 * Cornelia Huck (cornelia.huck@de.ibm.com)
11 #include <linux/module.h>
12 #include <linux/errno.h>
13 #include <linux/slab.h>
14 #include <linux/list.h>
15 #include <linux/device.h>
16 #include <linux/init.h>
17 #include <linux/ctype.h>
18 #include <linux/dcache.h>
20 #include <asm/semaphore.h>
21 #include <asm/ccwdev.h>
22 #include <asm/ccwgroup.h>
24 /* In Linux 2.4, we had a channel device layer called "chandev"
25 * that did all sorts of obscure stuff for networking devices.
26 * This is another driver that serves as a replacement for just
27 * one of its functions, namely the translation of single subchannels
28 * to devices that use multiple subchannels.
31 /* a device matches a driver if all its slave devices match the same
32 * entry of the driver */
34 ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
36 struct ccwgroup_device *gdev;
37 struct ccwgroup_driver *gdrv;
39 gdev = container_of(dev, struct ccwgroup_device, dev);
40 gdrv = container_of(drv, struct ccwgroup_driver, driver);
42 if (gdev->creator_id == gdrv->driver_id)
48 ccwgroup_uevent (struct device *dev, char **envp, int num_envp, char *buffer,
55 static struct bus_type ccwgroup_bus_type;
58 __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
63 for (i = 0; i < gdev->count; i++) {
64 sprintf(str, "cdev%d", i);
65 sysfs_remove_link(&gdev->dev.kobj, str);
66 sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
72 * Provide an 'ungroup' attribute so the user can remove group devices no
73 * longer needed or accidentially created. Saves memory :)
76 ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
78 struct ccwgroup_device *gdev;
80 gdev = to_ccwgroupdev(dev);
82 if (gdev->state != CCWGROUP_OFFLINE)
85 __ccwgroup_remove_symlinks(gdev);
86 device_unregister(dev);
91 static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
94 ccwgroup_release (struct device *dev)
96 struct ccwgroup_device *gdev;
99 gdev = to_ccwgroupdev(dev);
101 for (i = 0; i < gdev->count; i++) {
102 gdev->cdev[i]->dev.driver_data = NULL;
103 put_device(&gdev->cdev[i]->dev);
109 __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
114 for (i = 0; i < gdev->count; i++) {
115 rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
118 for (--i; i >= 0; i--)
119 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
124 for (i = 0; i < gdev->count; i++) {
125 sprintf(str, "cdev%d", i);
126 rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
129 for (--i; i >= 0; i--) {
130 sprintf(str, "cdev%d", i);
131 sysfs_remove_link(&gdev->dev.kobj, str);
133 for (i = 0; i < gdev->count; i++)
134 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
143 * try to add a new ccwgroup device for one driver
144 * argc and argv[] are a list of bus_id's of devices
145 * belonging to the driver.
148 ccwgroup_create(struct device *root,
149 unsigned int creator_id,
150 struct ccw_driver *cdrv,
151 int argc, char *argv[])
153 struct ccwgroup_device *gdev;
158 if (argc > 256) /* disallow dumb users */
161 gdev = kmalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
165 memset(gdev, 0, sizeof(*gdev) + argc*sizeof(gdev->cdev[0]));
166 atomic_set(&gdev->onoff, 0);
169 for (i = 0; i < argc; i++) {
170 gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]);
172 /* all devices have to be of the same type in
173 * order to be grouped */
175 || gdev->cdev[i]->id.driver_info !=
176 gdev->cdev[0]->id.driver_info) {
180 /* Don't allow a device to belong to more than one group. */
181 if (gdev->cdev[i]->dev.driver_data) {
186 for (i = 0; i < argc; i++)
187 gdev->cdev[i]->dev.driver_data = gdev;
190 gdev->creator_id = creator_id;
192 gdev->dev = (struct device ) {
193 .bus = &ccwgroup_bus_type,
195 .release = ccwgroup_release,
198 snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
199 gdev->cdev[0]->dev.bus_id);
201 rc = device_register(&gdev->dev);
205 get_device(&gdev->dev);
206 rc = device_create_file(&gdev->dev, &dev_attr_ungroup);
209 device_unregister(&gdev->dev);
213 rc = __ccwgroup_create_symlinks(gdev);
215 put_device(&gdev->dev);
218 device_remove_file(&gdev->dev, &dev_attr_ungroup);
219 device_unregister(&gdev->dev);
221 for (i = 0; i < argc; i++)
223 put_device(&gdev->cdev[i]->dev);
224 gdev->cdev[i]->dev.driver_data = NULL;
226 put_device(&gdev->dev);
229 for (i = 0; i < argc; i++)
231 put_device(&gdev->cdev[i]->dev);
233 gdev->cdev[i]->dev.driver_data = NULL;
242 return bus_register (&ccwgroup_bus_type);
246 cleanup_ccwgroup (void)
248 bus_unregister (&ccwgroup_bus_type);
251 module_init(init_ccwgroup);
252 module_exit(cleanup_ccwgroup);
254 /************************** driver stuff ******************************/
257 ccwgroup_set_online(struct ccwgroup_device *gdev)
259 struct ccwgroup_driver *gdrv;
262 if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
264 if (gdev->state == CCWGROUP_ONLINE) {
268 if (!gdev->dev.driver) {
272 gdrv = to_ccwgroupdrv (gdev->dev.driver);
273 if ((ret = gdrv->set_online ? gdrv->set_online(gdev) : 0))
276 gdev->state = CCWGROUP_ONLINE;
278 atomic_set(&gdev->onoff, 0);
283 ccwgroup_set_offline(struct ccwgroup_device *gdev)
285 struct ccwgroup_driver *gdrv;
288 if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
290 if (gdev->state == CCWGROUP_OFFLINE) {
294 if (!gdev->dev.driver) {
298 gdrv = to_ccwgroupdrv (gdev->dev.driver);
299 if ((ret = gdrv->set_offline ? gdrv->set_offline(gdev) : 0))
302 gdev->state = CCWGROUP_OFFLINE;
304 atomic_set(&gdev->onoff, 0);
309 ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
311 struct ccwgroup_device *gdev;
312 struct ccwgroup_driver *gdrv;
316 gdev = to_ccwgroupdev(dev);
320 gdrv = to_ccwgroupdrv (gdev->dev.driver);
321 if (!try_module_get(gdrv->owner))
324 value = simple_strtoul(buf, 0, 0);
327 ccwgroup_set_online(gdev);
329 ccwgroup_set_offline(gdev);
332 module_put(gdrv->owner);
337 ccwgroup_online_show (struct device *dev, struct device_attribute *attr, char *buf)
341 online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
343 return sprintf(buf, online ? "1\n" : "0\n");
346 static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
349 ccwgroup_probe (struct device *dev)
351 struct ccwgroup_device *gdev;
352 struct ccwgroup_driver *gdrv;
356 gdev = to_ccwgroupdev(dev);
357 gdrv = to_ccwgroupdrv(dev->driver);
359 if ((ret = device_create_file(dev, &dev_attr_online)))
362 pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
363 ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
365 device_remove_file(dev, &dev_attr_online);
371 ccwgroup_remove (struct device *dev)
373 struct ccwgroup_device *gdev;
374 struct ccwgroup_driver *gdrv;
376 gdev = to_ccwgroupdev(dev);
377 gdrv = to_ccwgroupdrv(dev->driver);
379 pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
381 device_remove_file(dev, &dev_attr_online);
383 if (gdrv && gdrv->remove)
388 static struct bus_type ccwgroup_bus_type = {
390 .match = ccwgroup_bus_match,
391 .uevent = ccwgroup_uevent,
392 .probe = ccwgroup_probe,
393 .remove = ccwgroup_remove,
397 ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
399 /* register our new driver with the core */
400 cdriver->driver = (struct device_driver) {
401 .bus = &ccwgroup_bus_type,
402 .name = cdriver->name,
405 return driver_register(&cdriver->driver);
409 __ccwgroup_driver_unregister_device(struct device *dev, void *data)
411 __ccwgroup_remove_symlinks(to_ccwgroupdev(dev));
412 device_unregister(dev);
418 ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
420 /* We don't want ccwgroup devices to live longer than their driver. */
421 get_driver(&cdriver->driver);
422 driver_for_each_device(&cdriver->driver, NULL, NULL,
423 __ccwgroup_driver_unregister_device);
424 put_driver(&cdriver->driver);
425 driver_unregister(&cdriver->driver);
429 ccwgroup_probe_ccwdev(struct ccw_device *cdev)
434 static inline struct ccwgroup_device *
435 __ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
437 struct ccwgroup_device *gdev;
439 if (cdev->dev.driver_data) {
440 gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
441 if (get_device(&gdev->dev)) {
442 if (device_is_registered(&gdev->dev))
444 put_device(&gdev->dev);
452 ccwgroup_remove_ccwdev(struct ccw_device *cdev)
454 struct ccwgroup_device *gdev;
456 /* Ignore offlining errors, device is gone anyway. */
457 ccw_device_set_offline(cdev);
458 /* If one of its devices is gone, the whole group is done for. */
459 gdev = __ccwgroup_get_gdev_by_cdev(cdev);
461 __ccwgroup_remove_symlinks(gdev);
462 device_unregister(&gdev->dev);
463 put_device(&gdev->dev);
467 MODULE_LICENSE("GPL");
468 EXPORT_SYMBOL(ccwgroup_driver_register);
469 EXPORT_SYMBOL(ccwgroup_driver_unregister);
470 EXPORT_SYMBOL(ccwgroup_create);
471 EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
472 EXPORT_SYMBOL(ccwgroup_remove_ccwdev);