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 = to_ccwgroupdev(dev);
39 gdrv = to_ccwgroupdrv(drv);
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 if (device_is_registered(&gdev->dev)) {
79 __ccwgroup_remove_symlinks(gdev);
80 device_unregister(dev);
82 mutex_unlock(&gdev->reg_mutex);
86 ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
88 struct ccwgroup_device *gdev;
91 gdev = to_ccwgroupdev(dev);
93 if (gdev->state != CCWGROUP_OFFLINE)
96 /* Note that we cannot unregister the device from one of its
97 * attribute methods, so we have to use this roundabout approach.
99 rc = device_schedule_callback(dev, ccwgroup_ungroup_callback);
105 static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
108 ccwgroup_release (struct device *dev)
110 struct ccwgroup_device *gdev;
113 gdev = to_ccwgroupdev(dev);
115 for (i = 0; i < gdev->count; i++) {
116 dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
117 put_device(&gdev->cdev[i]->dev);
123 __ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
128 for (i = 0; i < gdev->count; i++) {
129 rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
132 for (--i; i >= 0; i--)
133 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
138 for (i = 0; i < gdev->count; i++) {
139 sprintf(str, "cdev%d", i);
140 rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
143 for (--i; i >= 0; i--) {
144 sprintf(str, "cdev%d", i);
145 sysfs_remove_link(&gdev->dev.kobj, str);
147 for (i = 0; i < gdev->count; i++)
148 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
156 static int __get_next_bus_id(const char **buf, char *bus_id)
161 start = (char *)*buf;
162 end = strchr(start, ',');
164 /* Last entry. Strip trailing newline, if applicable. */
165 end = strchr(start, '\n');
168 len = strlen(start) + 1;
170 len = end - start + 1;
173 if (len < BUS_ID_SIZE) {
174 strlcpy(bus_id, start, len);
182 static int __is_valid_bus_id(char bus_id[BUS_ID_SIZE])
184 int cssid, ssid, devno;
186 /* Must be of form %x.%x.%04x */
187 if (sscanf(bus_id, "%x.%1x.%04x", &cssid, &ssid, &devno) != 3)
193 * ccwgroup_create_from_string() - create and register a ccw group device
194 * @root: parent device for the new device
195 * @creator_id: identifier of creating driver
196 * @cdrv: ccw driver of slave devices
197 * @num_devices: number of slave devices
198 * @buf: buffer containing comma separated bus ids of slave devices
200 * Create and register a new ccw group device as a child of @root. Slave
201 * devices are obtained from the list of bus ids given in @buf and must all
204 * %0 on success and an error code on failure.
208 int ccwgroup_create_from_string(struct device *root, unsigned int creator_id,
209 struct ccw_driver *cdrv, int num_devices,
212 struct ccwgroup_device *gdev;
214 char tmp_bus_id[BUS_ID_SIZE];
215 const char *curr_buf;
217 gdev = kzalloc(sizeof(*gdev) + num_devices * sizeof(gdev->cdev[0]),
222 atomic_set(&gdev->onoff, 0);
223 mutex_init(&gdev->reg_mutex);
224 mutex_lock(&gdev->reg_mutex);
226 for (i = 0; i < num_devices && curr_buf; i++) {
227 rc = __get_next_bus_id(&curr_buf, tmp_bus_id);
230 if (!__is_valid_bus_id(tmp_bus_id)) {
234 gdev->cdev[i] = get_ccwdev_by_busid(cdrv, tmp_bus_id);
236 * All devices have to be of the same type in
237 * order to be grouped.
240 || gdev->cdev[i]->id.driver_info !=
241 gdev->cdev[0]->id.driver_info) {
245 /* Don't allow a device to belong to more than one group. */
246 if (dev_get_drvdata(&gdev->cdev[i]->dev)) {
250 dev_set_drvdata(&gdev->cdev[i]->dev, gdev);
252 /* Check for sufficient number of bus ids. */
253 if (i < num_devices && !curr_buf) {
257 /* Check for trailing stuff. */
258 if (i == num_devices && strlen(curr_buf) > 0) {
262 gdev->creator_id = creator_id;
263 gdev->count = num_devices;
264 gdev->dev.bus = &ccwgroup_bus_type;
265 gdev->dev.parent = root;
266 gdev->dev.release = ccwgroup_release;
268 snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
269 gdev->cdev[0]->dev.bus_id);
271 rc = device_register(&gdev->dev);
274 get_device(&gdev->dev);
275 rc = device_create_file(&gdev->dev, &dev_attr_ungroup);
278 device_unregister(&gdev->dev);
282 rc = __ccwgroup_create_symlinks(gdev);
284 mutex_unlock(&gdev->reg_mutex);
285 put_device(&gdev->dev);
288 device_remove_file(&gdev->dev, &dev_attr_ungroup);
289 device_unregister(&gdev->dev);
291 for (i = 0; i < num_devices; i++)
293 if (dev_get_drvdata(&gdev->cdev[i]->dev) == gdev)
294 dev_set_drvdata(&gdev->cdev[i]->dev, NULL);
295 put_device(&gdev->cdev[i]->dev);
297 mutex_unlock(&gdev->reg_mutex);
298 put_device(&gdev->dev);
301 EXPORT_SYMBOL(ccwgroup_create_from_string);
306 return bus_register (&ccwgroup_bus_type);
310 cleanup_ccwgroup (void)
312 bus_unregister (&ccwgroup_bus_type);
315 module_init(init_ccwgroup);
316 module_exit(cleanup_ccwgroup);
318 /************************** driver stuff ******************************/
321 ccwgroup_set_online(struct ccwgroup_device *gdev)
323 struct ccwgroup_driver *gdrv;
326 if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
328 if (gdev->state == CCWGROUP_ONLINE) {
332 if (!gdev->dev.driver) {
336 gdrv = to_ccwgroupdrv (gdev->dev.driver);
337 if ((ret = gdrv->set_online ? gdrv->set_online(gdev) : 0))
340 gdev->state = CCWGROUP_ONLINE;
342 atomic_set(&gdev->onoff, 0);
347 ccwgroup_set_offline(struct ccwgroup_device *gdev)
349 struct ccwgroup_driver *gdrv;
352 if (atomic_cmpxchg(&gdev->onoff, 0, 1) != 0)
354 if (gdev->state == CCWGROUP_OFFLINE) {
358 if (!gdev->dev.driver) {
362 gdrv = to_ccwgroupdrv (gdev->dev.driver);
363 if ((ret = gdrv->set_offline ? gdrv->set_offline(gdev) : 0))
366 gdev->state = CCWGROUP_OFFLINE;
368 atomic_set(&gdev->onoff, 0);
373 ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
375 struct ccwgroup_device *gdev;
376 struct ccwgroup_driver *gdrv;
380 gdev = to_ccwgroupdev(dev);
384 gdrv = to_ccwgroupdrv (gdev->dev.driver);
385 if (!try_module_get(gdrv->owner))
388 value = simple_strtoul(buf, NULL, 0);
391 ccwgroup_set_online(gdev);
393 ccwgroup_set_offline(gdev);
396 module_put(gdrv->owner);
401 ccwgroup_online_show (struct device *dev, struct device_attribute *attr, char *buf)
405 online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
407 return sprintf(buf, online ? "1\n" : "0\n");
410 static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
413 ccwgroup_probe (struct device *dev)
415 struct ccwgroup_device *gdev;
416 struct ccwgroup_driver *gdrv;
420 gdev = to_ccwgroupdev(dev);
421 gdrv = to_ccwgroupdrv(dev->driver);
423 if ((ret = device_create_file(dev, &dev_attr_online)))
426 ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
428 device_remove_file(dev, &dev_attr_online);
434 ccwgroup_remove (struct device *dev)
436 struct ccwgroup_device *gdev;
437 struct ccwgroup_driver *gdrv;
439 gdev = to_ccwgroupdev(dev);
440 gdrv = to_ccwgroupdrv(dev->driver);
442 device_remove_file(dev, &dev_attr_online);
444 if (gdrv && gdrv->remove)
449 static void ccwgroup_shutdown(struct device *dev)
451 struct ccwgroup_device *gdev;
452 struct ccwgroup_driver *gdrv;
454 gdev = to_ccwgroupdev(dev);
455 gdrv = to_ccwgroupdrv(dev->driver);
456 if (gdrv && gdrv->shutdown)
457 gdrv->shutdown(gdev);
460 static struct bus_type ccwgroup_bus_type = {
462 .match = ccwgroup_bus_match,
463 .uevent = ccwgroup_uevent,
464 .probe = ccwgroup_probe,
465 .remove = ccwgroup_remove,
466 .shutdown = ccwgroup_shutdown,
470 * ccwgroup_driver_register() - register a ccw group driver
471 * @cdriver: driver to be registered
473 * This function is mainly a wrapper around driver_register().
475 int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
477 /* register our new driver with the core */
478 cdriver->driver.bus = &ccwgroup_bus_type;
479 cdriver->driver.name = cdriver->name;
480 cdriver->driver.owner = cdriver->owner;
482 return driver_register(&cdriver->driver);
486 __ccwgroup_match_all(struct device *dev, void *data)
492 * ccwgroup_driver_unregister() - deregister a ccw group driver
493 * @cdriver: driver to be deregistered
495 * This function is mainly a wrapper around driver_unregister().
497 void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
501 /* We don't want ccwgroup devices to live longer than their driver. */
502 get_driver(&cdriver->driver);
503 while ((dev = driver_find_device(&cdriver->driver, NULL, NULL,
504 __ccwgroup_match_all))) {
505 struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
507 mutex_lock(&gdev->reg_mutex);
508 __ccwgroup_remove_symlinks(gdev);
509 device_unregister(dev);
510 mutex_unlock(&gdev->reg_mutex);
513 put_driver(&cdriver->driver);
514 driver_unregister(&cdriver->driver);
518 * ccwgroup_probe_ccwdev() - probe function for slave devices
519 * @cdev: ccw device to be probed
521 * This is a dummy probe function for ccw devices that are slave devices in
522 * a ccw group device.
526 int ccwgroup_probe_ccwdev(struct ccw_device *cdev)
531 static struct ccwgroup_device *
532 __ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
534 struct ccwgroup_device *gdev;
536 gdev = dev_get_drvdata(&cdev->dev);
538 if (get_device(&gdev->dev)) {
539 mutex_lock(&gdev->reg_mutex);
540 if (device_is_registered(&gdev->dev))
542 mutex_unlock(&gdev->reg_mutex);
543 put_device(&gdev->dev);
551 * ccwgroup_remove_ccwdev() - remove function for slave devices
552 * @cdev: ccw device to be removed
554 * This is a remove function for ccw devices that are slave devices in a ccw
555 * group device. It sets the ccw device offline and also deregisters the
556 * embedding ccw group device.
558 void ccwgroup_remove_ccwdev(struct ccw_device *cdev)
560 struct ccwgroup_device *gdev;
562 /* Ignore offlining errors, device is gone anyway. */
563 ccw_device_set_offline(cdev);
564 /* If one of its devices is gone, the whole group is done for. */
565 gdev = __ccwgroup_get_gdev_by_cdev(cdev);
567 __ccwgroup_remove_symlinks(gdev);
568 device_unregister(&gdev->dev);
569 mutex_unlock(&gdev->reg_mutex);
570 put_device(&gdev->dev);
574 MODULE_LICENSE("GPL");
575 EXPORT_SYMBOL(ccwgroup_driver_register);
576 EXPORT_SYMBOL(ccwgroup_driver_unregister);
577 EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
578 EXPORT_SYMBOL(ccwgroup_remove_ccwdev);