2 * drivers/s390/cio/ccwgroup.c
3 * bus driver for ccwgroup
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/errno.h>
12 #include <linux/slab.h>
13 #include <linux/list.h>
14 #include <linux/device.h>
15 #include <linux/init.h>
16 #include <linux/ctype.h>
17 #include <linux/dcache.h>
19 #include <asm/semaphore.h>
20 #include <asm/ccwdev.h>
21 #include <asm/ccwgroup.h>
23 /* In Linux 2.4, we had a channel device layer called "chandev"
24 * that did all sorts of obscure stuff for networking devices.
25 * This is another driver that serves as a replacement for just
26 * one of its functions, namely the translation of single subchannels
27 * to devices that use multiple subchannels.
30 /* a device matches a driver if all its slave devices match the same
31 * entry of the driver */
33 ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
35 struct ccwgroup_device *gdev;
36 struct ccwgroup_driver *gdrv;
38 gdev = container_of(dev, struct ccwgroup_device, dev);
39 gdrv = container_of(drv, struct ccwgroup_driver, driver);
41 if (gdev->creator_id == gdrv->driver_id)
47 ccwgroup_uevent (struct device *dev, struct kobj_uevent_env *env)
53 static struct bus_type ccwgroup_bus_type;
56 __ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
61 for (i = 0; i < gdev->count; i++) {
62 sprintf(str, "cdev%d", i);
63 sysfs_remove_link(&gdev->dev.kobj, str);
64 sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
70 * Provide an 'ungroup' attribute so the user can remove group devices no
71 * longer needed or accidentially created. Saves memory :)
73 static void ccwgroup_ungroup_callback(struct device *dev)
75 struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
77 mutex_lock(&gdev->reg_mutex);
78 __ccwgroup_remove_symlinks(gdev);
79 device_unregister(dev);
80 mutex_unlock(&gdev->reg_mutex);
84 ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
86 struct ccwgroup_device *gdev;
89 gdev = to_ccwgroupdev(dev);
91 if (gdev->state != CCWGROUP_OFFLINE)
94 /* Note that we cannot unregister the device from one of its
95 * attribute methods, so we have to use this roundabout approach.
97 rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
103 static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
106 ccwgroup_release (struct device *dev)
108 struct ccwgroup_device *gdev;
111 gdev = to_ccwgroupdev(dev);
113 for (i = 0; i < gdev->count; i++) {
114 gdev->cdev[i]->dev.driver_data = NULL;
115 put_device(&gdev->cdev[i]->dev);
121 __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
126 for (i = 0; i < gdev->count; i++) {
127 rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
130 for (--i; i >= 0; i--)
131 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
136 for (i = 0; i < gdev->count; i++) {
137 sprintf(str, "cdev%d", i);
138 rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
141 for (--i; i >= 0; i--) {
142 sprintf(str, "cdev%d", i);
143 sysfs_remove_link(&gdev->dev.kobj, str);
145 for (i = 0; i < gdev->count; i++)
146 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
155 * try to add a new ccwgroup device for one driver
156 * argc and argv[] are a list of bus_id's of devices
157 * belonging to the driver.
160 ccwgroup_create(struct device *root,
161 unsigned int creator_id,
162 struct ccw_driver *cdrv,
163 int argc, char *argv[])
165 struct ccwgroup_device *gdev;
169 if (argc > 256) /* disallow dumb users */
172 gdev = kzalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
176 atomic_set(&gdev->onoff, 0);
177 mutex_init(&gdev->reg_mutex);
178 mutex_lock(&gdev->reg_mutex);
179 for (i = 0; i < argc; i++) {
180 gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]);
182 /* all devices have to be of the same type in
183 * order to be grouped */
185 || gdev->cdev[i]->id.driver_info !=
186 gdev->cdev[0]->id.driver_info) {
190 /* Don't allow a device to belong to more than one group. */
191 if (gdev->cdev[i]->dev.driver_data) {
195 gdev->cdev[i]->dev.driver_data = gdev;
198 gdev->creator_id = creator_id;
200 gdev->dev.bus = &ccwgroup_bus_type;
201 gdev->dev.parent = root;
202 gdev->dev.release = ccwgroup_release;
204 snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
205 gdev->cdev[0]->dev.bus_id);
207 rc = device_register(&gdev->dev);
210 get_device(&gdev->dev);
211 rc = device_create_file(&gdev->dev, &dev_attr_ungroup);
214 device_unregister(&gdev->dev);
218 rc = __ccwgroup_create_symlinks(gdev);
220 mutex_unlock(&gdev->reg_mutex);
221 put_device(&gdev->dev);
224 device_remove_file(&gdev->dev, &dev_attr_ungroup);
225 device_unregister(&gdev->dev);
227 for (i = 0; i < argc; i++)
229 if (gdev->cdev[i]->dev.driver_data == gdev)
230 gdev->cdev[i]->dev.driver_data = NULL;
231 put_device(&gdev->cdev[i]->dev);
233 mutex_unlock(&gdev->reg_mutex);
234 put_device(&gdev->dev);
241 return bus_register (&ccwgroup_bus_type);
245 cleanup_ccwgroup (void)
247 bus_unregister (&ccwgroup_bus_type);
250 module_init(init_ccwgroup);
251 module_exit(cleanup_ccwgroup);
253 /************************** driver stuff ******************************/
256 ccwgroup_set_online(struct ccwgroup_device *gdev)
258 struct ccwgroup_driver *gdrv;
261 if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
263 if (gdev->state == CCWGROUP_ONLINE) {
267 if (!gdev->dev.driver) {
271 gdrv = to_ccwgroupdrv (gdev->dev.driver);
272 if ((ret = gdrv->set_online ? gdrv->set_online(gdev) : 0))
275 gdev->state = CCWGROUP_ONLINE;
277 atomic_set(&gdev->onoff, 0);
282 ccwgroup_set_offline(struct ccwgroup_device *gdev)
284 struct ccwgroup_driver *gdrv;
287 if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
289 if (gdev->state == CCWGROUP_OFFLINE) {
293 if (!gdev->dev.driver) {
297 gdrv = to_ccwgroupdrv (gdev->dev.driver);
298 if ((ret = gdrv->set_offline ? gdrv->set_offline(gdev) : 0))
301 gdev->state = CCWGROUP_OFFLINE;
303 atomic_set(&gdev->onoff, 0);
308 ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
310 struct ccwgroup_device *gdev;
311 struct ccwgroup_driver *gdrv;
315 gdev = to_ccwgroupdev(dev);
319 gdrv = to_ccwgroupdrv (gdev->dev.driver);
320 if (!try_module_get(gdrv->owner))
323 value = simple_strtoul(buf, NULL, 0);
326 ccwgroup_set_online(gdev);
328 ccwgroup_set_offline(gdev);
331 module_put(gdrv->owner);
336 ccwgroup_online_show (struct device *dev, struct device_attribute *attr, char *buf)
340 online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
342 return sprintf(buf, online ? "1\n" : "0\n");
345 static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
348 ccwgroup_probe (struct device *dev)
350 struct ccwgroup_device *gdev;
351 struct ccwgroup_driver *gdrv;
355 gdev = to_ccwgroupdev(dev);
356 gdrv = to_ccwgroupdrv(dev->driver);
358 if ((ret = device_create_file(dev, &dev_attr_online)))
361 ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
363 device_remove_file(dev, &dev_attr_online);
369 ccwgroup_remove (struct device *dev)
371 struct ccwgroup_device *gdev;
372 struct ccwgroup_driver *gdrv;
374 gdev = to_ccwgroupdev(dev);
375 gdrv = to_ccwgroupdrv(dev->driver);
377 device_remove_file(dev, &dev_attr_online);
379 if (gdrv && gdrv->remove)
384 static struct bus_type ccwgroup_bus_type = {
386 .match = ccwgroup_bus_match,
387 .uevent = ccwgroup_uevent,
388 .probe = ccwgroup_probe,
389 .remove = ccwgroup_remove,
393 ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
395 /* register our new driver with the core */
396 cdriver->driver.bus = &ccwgroup_bus_type;
397 cdriver->driver.name = cdriver->name;
399 return driver_register(&cdriver->driver);
403 __ccwgroup_match_all(struct device *dev, void *data)
409 ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
413 /* We don't want ccwgroup devices to live longer than their driver. */
414 get_driver(&cdriver->driver);
415 while ((dev = driver_find_device(&cdriver->driver, NULL, NULL,
416 __ccwgroup_match_all))) {
417 struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
419 mutex_lock(&gdev->reg_mutex);
420 __ccwgroup_remove_symlinks(gdev);
421 device_unregister(dev);
422 mutex_unlock(&gdev->reg_mutex);
425 put_driver(&cdriver->driver);
426 driver_unregister(&cdriver->driver);
430 ccwgroup_probe_ccwdev(struct ccw_device *cdev)
435 static struct ccwgroup_device *
436 __ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
438 struct ccwgroup_device *gdev;
440 if (cdev->dev.driver_data) {
441 gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
442 if (get_device(&gdev->dev)) {
443 mutex_lock(&gdev->reg_mutex);
444 if (device_is_registered(&gdev->dev))
446 mutex_unlock(&gdev->reg_mutex);
447 put_device(&gdev->dev);
455 ccwgroup_remove_ccwdev(struct ccw_device *cdev)
457 struct ccwgroup_device *gdev;
459 /* Ignore offlining errors, device is gone anyway. */
460 ccw_device_set_offline(cdev);
461 /* If one of its devices is gone, the whole group is done for. */
462 gdev = __ccwgroup_get_gdev_by_cdev(cdev);
464 __ccwgroup_remove_symlinks(gdev);
465 device_unregister(&gdev->dev);
466 mutex_unlock(&gdev->reg_mutex);
467 put_device(&gdev->dev);
471 MODULE_LICENSE("GPL");
472 EXPORT_SYMBOL(ccwgroup_driver_register);
473 EXPORT_SYMBOL(ccwgroup_driver_unregister);
474 EXPORT_SYMBOL(ccwgroup_create);
475 EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
476 EXPORT_SYMBOL(ccwgroup_remove_ccwdev);