blob: 91ea8e4777f340b2c47fe76ac5f68cab43e54ffa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/s390/cio/ccwgroup.c
3 * bus driver for ccwgroup
4 * $Revision: 1.29 $
5 *
6 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
7 * IBM Corporation
8 * Author(s): Arnd Bergmann (arndb@de.ibm.com)
9 * Cornelia Huck (cohuck@de.ibm.com)
10 */
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>
19
20#include <asm/semaphore.h>
21#include <asm/ccwdev.h>
22#include <asm/ccwgroup.h>
23
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.
29 */
30
31/* a device matches a driver if all its slave devices match the same
32 * entry of the driver */
33static int
34ccwgroup_bus_match (struct device * dev, struct device_driver * drv)
35{
36 struct ccwgroup_device *gdev;
37 struct ccwgroup_driver *gdrv;
38
39 gdev = container_of(dev, struct ccwgroup_device, dev);
40 gdrv = container_of(drv, struct ccwgroup_driver, driver);
41
42 if (gdev->creator_id == gdrv->driver_id)
43 return 1;
44
45 return 0;
46}
47static int
48ccwgroup_hotplug (struct device *dev, char **envp, int num_envp, char *buffer,
49 int buffer_size)
50{
51 /* TODO */
52 return 0;
53}
54
55static struct bus_type ccwgroup_bus_type = {
56 .name = "ccwgroup",
57 .match = ccwgroup_bus_match,
58 .hotplug = ccwgroup_hotplug,
59};
60
61static inline void
62__ccwgroup_remove_symlinks(struct ccwgroup_device *gdev)
63{
64 int i;
65 char str[8];
66
67 for (i = 0; i < gdev->count; i++) {
68 sprintf(str, "cdev%d", i);
69 sysfs_remove_link(&gdev->dev.kobj, str);
70 sysfs_remove_link(&gdev->cdev[i]->dev.kobj, "group_device");
71 }
72
73}
74
75/*
76 * Provide an 'ungroup' attribute so the user can remove group devices no
77 * longer needed or accidentially created. Saves memory :)
78 */
79static ssize_t
Yani Ioannou3fd3c0a2005-05-17 06:43:27 -040080ccwgroup_ungroup_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
82 struct ccwgroup_device *gdev;
83
84 gdev = to_ccwgroupdev(dev);
85
86 if (gdev->state != CCWGROUP_OFFLINE)
87 return -EINVAL;
88
89 __ccwgroup_remove_symlinks(gdev);
90 device_unregister(dev);
91
92 return count;
93}
94
95static DEVICE_ATTR(ungroup, 0200, NULL, ccwgroup_ungroup_store);
96
97static void
98ccwgroup_release (struct device *dev)
99{
100 struct ccwgroup_device *gdev;
101 int i;
102
103 gdev = to_ccwgroupdev(dev);
104
105 for (i = 0; i < gdev->count; i++) {
106 gdev->cdev[i]->dev.driver_data = NULL;
107 put_device(&gdev->cdev[i]->dev);
108 }
109 kfree(gdev);
110}
111
112static inline int
113__ccwgroup_create_symlinks(struct ccwgroup_device *gdev)
114{
115 char str[8];
116 int i, rc;
117
118 for (i = 0; i < gdev->count; i++) {
119 rc = sysfs_create_link(&gdev->cdev[i]->dev.kobj, &gdev->dev.kobj,
120 "group_device");
121 if (rc) {
122 for (--i; i >= 0; i--)
123 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
124 "group_device");
125 return rc;
126 }
127 }
128 for (i = 0; i < gdev->count; i++) {
129 sprintf(str, "cdev%d", i);
130 rc = sysfs_create_link(&gdev->dev.kobj, &gdev->cdev[i]->dev.kobj,
131 str);
132 if (rc) {
133 for (--i; i >= 0; i--) {
134 sprintf(str, "cdev%d", i);
135 sysfs_remove_link(&gdev->dev.kobj, str);
136 }
137 for (i = 0; i < gdev->count; i++)
138 sysfs_remove_link(&gdev->cdev[i]->dev.kobj,
139 "group_device");
140 return rc;
141 }
142 }
143 return 0;
144}
145
146/*
147 * try to add a new ccwgroup device for one driver
148 * argc and argv[] are a list of bus_id's of devices
149 * belonging to the driver.
150 */
151int
152ccwgroup_create(struct device *root,
153 unsigned int creator_id,
154 struct ccw_driver *cdrv,
155 int argc, char *argv[])
156{
157 struct ccwgroup_device *gdev;
158 int i;
159 int rc;
160 int del_drvdata;
161
162 if (argc > 256) /* disallow dumb users */
163 return -EINVAL;
164
165 gdev = kmalloc(sizeof(*gdev) + argc*sizeof(gdev->cdev[0]), GFP_KERNEL);
166 if (!gdev)
167 return -ENOMEM;
168
169 memset(gdev, 0, sizeof(*gdev) + argc*sizeof(gdev->cdev[0]));
170 atomic_set(&gdev->onoff, 0);
171
172 del_drvdata = 0;
173 for (i = 0; i < argc; i++) {
174 gdev->cdev[i] = get_ccwdev_by_busid(cdrv, argv[i]);
175
176 /* all devices have to be of the same type in
177 * order to be grouped */
178 if (!gdev->cdev[i]
179 || gdev->cdev[i]->id.driver_info !=
180 gdev->cdev[0]->id.driver_info) {
181 rc = -EINVAL;
182 goto free_dev;
183 }
184 /* Don't allow a device to belong to more than one group. */
185 if (gdev->cdev[i]->dev.driver_data) {
186 rc = -EINVAL;
187 goto free_dev;
188 }
189 }
190 for (i = 0; i < argc; i++)
191 gdev->cdev[i]->dev.driver_data = gdev;
192 del_drvdata = 1;
193
194 gdev->creator_id = creator_id;
195 gdev->count = argc;
196 gdev->dev = (struct device ) {
197 .bus = &ccwgroup_bus_type,
198 .parent = root,
199 .release = ccwgroup_release,
200 };
201
202 snprintf (gdev->dev.bus_id, BUS_ID_SIZE, "%s",
203 gdev->cdev[0]->dev.bus_id);
204
205 rc = device_register(&gdev->dev);
206
207 if (rc)
208 goto free_dev;
209 get_device(&gdev->dev);
210 rc = device_create_file(&gdev->dev, &dev_attr_ungroup);
211
212 if (rc) {
213 device_unregister(&gdev->dev);
214 goto error;
215 }
216
217 rc = __ccwgroup_create_symlinks(gdev);
218 if (!rc) {
219 put_device(&gdev->dev);
220 return 0;
221 }
222 device_remove_file(&gdev->dev, &dev_attr_ungroup);
223 device_unregister(&gdev->dev);
224error:
225 for (i = 0; i < argc; i++)
226 if (gdev->cdev[i]) {
227 put_device(&gdev->cdev[i]->dev);
228 gdev->cdev[i]->dev.driver_data = NULL;
229 }
230 put_device(&gdev->dev);
231 return rc;
232free_dev:
233 for (i = 0; i < argc; i++)
234 if (gdev->cdev[i]) {
235 put_device(&gdev->cdev[i]->dev);
236 if (del_drvdata)
237 gdev->cdev[i]->dev.driver_data = NULL;
238 }
239 kfree(gdev);
240 return rc;
241}
242
243static int __init
244init_ccwgroup (void)
245{
246 return bus_register (&ccwgroup_bus_type);
247}
248
249static void __exit
250cleanup_ccwgroup (void)
251{
252 bus_unregister (&ccwgroup_bus_type);
253}
254
255module_init(init_ccwgroup);
256module_exit(cleanup_ccwgroup);
257
258/************************** driver stuff ******************************/
259
260static int
261ccwgroup_set_online(struct ccwgroup_device *gdev)
262{
263 struct ccwgroup_driver *gdrv;
264 int ret;
265
266 if (atomic_compare_and_swap(0, 1, &gdev->onoff))
267 return -EAGAIN;
268 if (gdev->state == CCWGROUP_ONLINE) {
269 ret = 0;
270 goto out;
271 }
272 if (!gdev->dev.driver) {
273 ret = -EINVAL;
274 goto out;
275 }
276 gdrv = to_ccwgroupdrv (gdev->dev.driver);
277 if ((ret = gdrv->set_online(gdev)))
278 goto out;
279
280 gdev->state = CCWGROUP_ONLINE;
281 out:
282 atomic_set(&gdev->onoff, 0);
283 return ret;
284}
285
286static int
287ccwgroup_set_offline(struct ccwgroup_device *gdev)
288{
289 struct ccwgroup_driver *gdrv;
290 int ret;
291
292 if (atomic_compare_and_swap(0, 1, &gdev->onoff))
293 return -EAGAIN;
294 if (gdev->state == CCWGROUP_OFFLINE) {
295 ret = 0;
296 goto out;
297 }
298 if (!gdev->dev.driver) {
299 ret = -EINVAL;
300 goto out;
301 }
302 gdrv = to_ccwgroupdrv (gdev->dev.driver);
303 if ((ret = gdrv->set_offline(gdev)))
304 goto out;
305
306 gdev->state = CCWGROUP_OFFLINE;
307 out:
308 atomic_set(&gdev->onoff, 0);
309 return ret;
310}
311
312static ssize_t
Yani Ioannou3fd3c0a2005-05-17 06:43:27 -0400313ccwgroup_online_store (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314{
315 struct ccwgroup_device *gdev;
316 struct ccwgroup_driver *gdrv;
317 unsigned int value;
318 int ret;
319
320 gdev = to_ccwgroupdev(dev);
321 if (!dev->driver)
322 return count;
323
324 gdrv = to_ccwgroupdrv (gdev->dev.driver);
325 if (!try_module_get(gdrv->owner))
326 return -EINVAL;
327
328 value = simple_strtoul(buf, 0, 0);
329 ret = count;
330 if (value == 1)
331 ccwgroup_set_online(gdev);
332 else if (value == 0)
333 ccwgroup_set_offline(gdev);
334 else
335 ret = -EINVAL;
336 module_put(gdrv->owner);
337 return ret;
338}
339
340static ssize_t
Yani Ioannou3fd3c0a2005-05-17 06:43:27 -0400341ccwgroup_online_show (struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342{
343 int online;
344
345 online = (to_ccwgroupdev(dev)->state == CCWGROUP_ONLINE);
346
347 return sprintf(buf, online ? "1\n" : "0\n");
348}
349
350static DEVICE_ATTR(online, 0644, ccwgroup_online_show, ccwgroup_online_store);
351
352static int
353ccwgroup_probe (struct device *dev)
354{
355 struct ccwgroup_device *gdev;
356 struct ccwgroup_driver *gdrv;
357
358 int ret;
359
360 gdev = to_ccwgroupdev(dev);
361 gdrv = to_ccwgroupdrv(dev->driver);
362
363 if ((ret = device_create_file(dev, &dev_attr_online)))
364 return ret;
365
366 pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
367 ret = gdrv->probe ? gdrv->probe(gdev) : -ENODEV;
368 if (ret)
369 device_remove_file(dev, &dev_attr_online);
370
371 return ret;
372}
373
374static int
375ccwgroup_remove (struct device *dev)
376{
377 struct ccwgroup_device *gdev;
378 struct ccwgroup_driver *gdrv;
379
380 gdev = to_ccwgroupdev(dev);
381 gdrv = to_ccwgroupdrv(dev->driver);
382
383 pr_debug("%s: device %s\n", __func__, gdev->dev.bus_id);
384
385 device_remove_file(dev, &dev_attr_online);
386
387 if (gdrv && gdrv->remove)
388 gdrv->remove(gdev);
389 return 0;
390}
391
392int
393ccwgroup_driver_register (struct ccwgroup_driver *cdriver)
394{
395 /* register our new driver with the core */
396 cdriver->driver = (struct device_driver) {
397 .bus = &ccwgroup_bus_type,
398 .name = cdriver->name,
399 .probe = ccwgroup_probe,
400 .remove = ccwgroup_remove,
401 };
402
403 return driver_register(&cdriver->driver);
404}
405
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700406static int
407__ccwgroup_driver_unregister_device(struct device *dev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700409 __ccwgroup_remove_symlinks(to_ccwgroupdev(dev));
410 device_unregister(dev);
411 put_device(dev);
412 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413}
414
415void
416ccwgroup_driver_unregister (struct ccwgroup_driver *cdriver)
417{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 /* We don't want ccwgroup devices to live longer than their driver. */
419 get_driver(&cdriver->driver);
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700420 driver_for_each_device(&cdriver->driver, NULL, NULL,
421 __ccwgroup_driver_unregister_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 put_driver(&cdriver->driver);
423 driver_unregister(&cdriver->driver);
424}
425
426int
427ccwgroup_probe_ccwdev(struct ccw_device *cdev)
428{
429 return 0;
430}
431
432static inline struct ccwgroup_device *
433__ccwgroup_get_gdev_by_cdev(struct ccw_device *cdev)
434{
435 struct ccwgroup_device *gdev;
436
437 if (cdev->dev.driver_data) {
438 gdev = (struct ccwgroup_device *)cdev->dev.driver_data;
439 if (get_device(&gdev->dev)) {
Cornelia Huckb0744bd2005-06-25 14:55:27 -0700440 if (klist_node_attached(&gdev->dev.knode_bus))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 return gdev;
442 put_device(&gdev->dev);
443 }
444 return NULL;
445 }
446 return NULL;
447}
448
449void
450ccwgroup_remove_ccwdev(struct ccw_device *cdev)
451{
452 struct ccwgroup_device *gdev;
453
454 /* Ignore offlining errors, device is gone anyway. */
455 ccw_device_set_offline(cdev);
456 /* If one of its devices is gone, the whole group is done for. */
457 gdev = __ccwgroup_get_gdev_by_cdev(cdev);
458 if (gdev) {
459 __ccwgroup_remove_symlinks(gdev);
460 device_unregister(&gdev->dev);
461 put_device(&gdev->dev);
462 }
463}
464
465MODULE_LICENSE("GPL");
466EXPORT_SYMBOL(ccwgroup_driver_register);
467EXPORT_SYMBOL(ccwgroup_driver_unregister);
468EXPORT_SYMBOL(ccwgroup_create);
469EXPORT_SYMBOL(ccwgroup_probe_ccwdev);
470EXPORT_SYMBOL(ccwgroup_remove_ccwdev);