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
);