Branch data Line data Source code
1 : : /*
2 : : * bus.c - bus driver management
3 : : *
4 : : * Copyright (c) 2002-3 Patrick Mochel
5 : : * Copyright (c) 2002-3 Open Source Development Labs
6 : : * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
7 : : * Copyright (c) 2007 Novell Inc.
8 : : *
9 : : * This file is released under the GPLv2
10 : : *
11 : : */
12 : :
13 : : #include <linux/device.h>
14 : : #include <linux/module.h>
15 : : #include <linux/errno.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/init.h>
18 : : #include <linux/string.h>
19 : : #include <linux/mutex.h>
20 : : #include <linux/sysfs.h>
21 : : #include "base.h"
22 : : #include "power/power.h"
23 : :
24 : : /* /sys/devices/system */
25 : : static struct kset *system_kset;
26 : :
27 : : #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
28 : :
29 : : /*
30 : : * sysfs bindings for drivers
31 : : */
32 : :
33 : : #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
34 : :
35 : :
36 : : static int __must_check bus_rescan_devices_helper(struct device *dev,
37 : : void *data);
38 : :
39 : : static struct bus_type *bus_get(struct bus_type *bus)
40 : : {
41 [ + - ][ # # ]: 129 : if (bus) {
[ + + ][ # # ]
[ # # ][ # # ]
[ # # ]
42 : 7 : kset_get(&bus->p->subsys);
43 : : return bus;
44 : : }
45 : : return NULL;
46 : : }
47 : :
48 : : static void bus_put(struct bus_type *bus)
49 : : {
50 [ + - # # ]: 135 : if (bus)
[ # # + - ]
[ # # # #
# # # # #
# ]
51 : 7 : kset_put(&bus->p->subsys);
52 : : }
53 : :
54 : 0 : static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr,
55 : : char *buf)
56 : : {
57 : : struct driver_attribute *drv_attr = to_drv_attr(attr);
58 : : struct driver_private *drv_priv = to_driver(kobj);
59 : : ssize_t ret = -EIO;
60 : :
61 [ # # ]: 0 : if (drv_attr->show)
62 : 0 : ret = drv_attr->show(drv_priv->driver, buf);
63 : 0 : return ret;
64 : : }
65 : :
66 : 0 : static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
67 : : const char *buf, size_t count)
68 : : {
69 : : struct driver_attribute *drv_attr = to_drv_attr(attr);
70 : : struct driver_private *drv_priv = to_driver(kobj);
71 : : ssize_t ret = -EIO;
72 : :
73 [ # # ]: 0 : if (drv_attr->store)
74 : 0 : ret = drv_attr->store(drv_priv->driver, buf, count);
75 : 0 : return ret;
76 : : }
77 : :
78 : : static const struct sysfs_ops driver_sysfs_ops = {
79 : : .show = drv_attr_show,
80 : : .store = drv_attr_store,
81 : : };
82 : :
83 : 0 : static void driver_release(struct kobject *kobj)
84 : : {
85 : : struct driver_private *drv_priv = to_driver(kobj);
86 : :
87 : : pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
88 : 0 : kfree(drv_priv);
89 : 0 : }
90 : :
91 : : static struct kobj_type driver_ktype = {
92 : : .sysfs_ops = &driver_sysfs_ops,
93 : : .release = driver_release,
94 : : };
95 : :
96 : : /*
97 : : * sysfs bindings for buses
98 : : */
99 : 0 : static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
100 : : char *buf)
101 : : {
102 : : struct bus_attribute *bus_attr = to_bus_attr(attr);
103 : : struct subsys_private *subsys_priv = to_subsys_private(kobj);
104 : : ssize_t ret = 0;
105 : :
106 [ # # ]: 0 : if (bus_attr->show)
107 : 0 : ret = bus_attr->show(subsys_priv->bus, buf);
108 : 0 : return ret;
109 : : }
110 : :
111 : 0 : static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
112 : : const char *buf, size_t count)
113 : : {
114 : : struct bus_attribute *bus_attr = to_bus_attr(attr);
115 : : struct subsys_private *subsys_priv = to_subsys_private(kobj);
116 : : ssize_t ret = 0;
117 : :
118 [ # # ]: 0 : if (bus_attr->store)
119 : 0 : ret = bus_attr->store(subsys_priv->bus, buf, count);
120 : 0 : return ret;
121 : : }
122 : :
123 : : static const struct sysfs_ops bus_sysfs_ops = {
124 : : .show = bus_attr_show,
125 : : .store = bus_attr_store,
126 : : };
127 : :
128 : 0 : int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
129 : : {
130 : : int error;
131 [ # # ]: 0 : if (bus_get(bus)) {
132 : 0 : error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
133 : : bus_put(bus);
134 : : } else
135 : : error = -EINVAL;
136 : 0 : return error;
137 : : }
138 : : EXPORT_SYMBOL_GPL(bus_create_file);
139 : :
140 : 0 : void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
141 : : {
142 [ # # ]: 0 : if (bus_get(bus)) {
143 : 0 : sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
144 : : bus_put(bus);
145 : : }
146 : 0 : }
147 : : EXPORT_SYMBOL_GPL(bus_remove_file);
148 : :
149 : 0 : static void bus_release(struct kobject *kobj)
150 : : {
151 : 0 : struct subsys_private *priv =
152 : : container_of(kobj, typeof(*priv), subsys.kobj);
153 : 0 : struct bus_type *bus = priv->bus;
154 : :
155 : 0 : kfree(priv);
156 : 0 : bus->p = NULL;
157 : 0 : }
158 : :
159 : : static struct kobj_type bus_ktype = {
160 : : .sysfs_ops = &bus_sysfs_ops,
161 : : .release = bus_release,
162 : : };
163 : :
164 : 0 : static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
165 : : {
166 : : struct kobj_type *ktype = get_ktype(kobj);
167 : :
168 [ # # ]: 0 : if (ktype == &bus_ktype)
169 : : return 1;
170 : 0 : return 0;
171 : : }
172 : :
173 : : static const struct kset_uevent_ops bus_uevent_ops = {
174 : : .filter = bus_uevent_filter,
175 : : };
176 : :
177 : : static struct kset *bus_kset;
178 : :
179 : : /* Manually detach a device from its associated driver. */
180 : 0 : static ssize_t unbind_store(struct device_driver *drv, const char *buf,
181 : : size_t count)
182 : : {
183 : 0 : struct bus_type *bus = bus_get(drv->bus);
184 : : struct device *dev;
185 : : int err = -ENODEV;
186 : :
187 : : dev = bus_find_device_by_name(bus, NULL, buf);
188 [ # # ][ # # ]: 0 : if (dev && dev->driver == drv) {
189 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
190 : : device_lock(dev->parent);
191 : 0 : device_release_driver(dev);
192 [ # # ]: 0 : if (dev->parent)
193 : : device_unlock(dev->parent);
194 : 0 : err = count;
195 : : }
196 : 0 : put_device(dev);
197 : : bus_put(bus);
198 : 0 : return err;
199 : : }
200 : : static DRIVER_ATTR_WO(unbind);
201 : :
202 : : /*
203 : : * Manually attach a device to a driver.
204 : : * Note: the driver must want to bind to the device,
205 : : * it is not possible to override the driver's id table.
206 : : */
207 : 0 : static ssize_t bind_store(struct device_driver *drv, const char *buf,
208 : : size_t count)
209 : : {
210 : 0 : struct bus_type *bus = bus_get(drv->bus);
211 : : struct device *dev;
212 : : int err = -ENODEV;
213 : :
214 : : dev = bus_find_device_by_name(bus, NULL, buf);
215 [ # # ][ # # ]: 0 : if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
[ # # ]
216 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
217 : : device_lock(dev->parent);
218 : : device_lock(dev);
219 : 0 : err = driver_probe_device(drv, dev);
220 : : device_unlock(dev);
221 [ # # ]: 0 : if (dev->parent)
222 : : device_unlock(dev->parent);
223 : :
224 [ # # ]: 0 : if (err > 0) {
225 : : /* success */
226 : 0 : err = count;
227 [ # # ]: 0 : } else if (err == 0) {
228 : : /* driver didn't accept device */
229 : : err = -ENODEV;
230 : : }
231 : : }
232 : 0 : put_device(dev);
233 : : bus_put(bus);
234 : 0 : return err;
235 : : }
236 : : static DRIVER_ATTR_WO(bind);
237 : :
238 : 0 : static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
239 : : {
240 : 0 : return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
241 : : }
242 : :
243 : 0 : static ssize_t store_drivers_autoprobe(struct bus_type *bus,
244 : : const char *buf, size_t count)
245 : : {
246 [ # # ]: 0 : if (buf[0] == '0')
247 : 0 : bus->p->drivers_autoprobe = 0;
248 : : else
249 : 0 : bus->p->drivers_autoprobe = 1;
250 : 0 : return count;
251 : : }
252 : :
253 : 0 : static ssize_t store_drivers_probe(struct bus_type *bus,
254 : : const char *buf, size_t count)
255 : : {
256 : : struct device *dev;
257 : :
258 : : dev = bus_find_device_by_name(bus, NULL, buf);
259 [ # # ]: 0 : if (!dev)
260 : : return -ENODEV;
261 [ # # ]: 0 : if (bus_rescan_devices_helper(dev, NULL) != 0)
262 : : return -EINVAL;
263 : 0 : return count;
264 : : }
265 : :
266 : : static struct device *next_device(struct klist_iter *i)
267 : : {
268 : 8 : struct klist_node *n = klist_next(i);
269 : : struct device *dev = NULL;
270 : : struct device_private *dev_prv;
271 : :
272 [ # # # # : 8 : if (n) {
+ + # # ]
273 : : dev_prv = to_device_private_bus(n);
274 : 6 : dev = dev_prv->device;
275 : : }
276 : : return dev;
277 : : }
278 : :
279 : : /**
280 : : * bus_for_each_dev - device iterator.
281 : : * @bus: bus type.
282 : : * @start: device to start iterating from.
283 : : * @data: data for the callback.
284 : : * @fn: function to be called for each device.
285 : : *
286 : : * Iterate over @bus's list of devices, and call @fn for each,
287 : : * passing it @data. If @start is not NULL, we use that device to
288 : : * begin iterating from.
289 : : *
290 : : * We check the return of @fn each time. If it returns anything
291 : : * other than 0, we break out and return that value.
292 : : *
293 : : * NOTE: The device that returns a non-zero value is not retained
294 : : * in any way, nor is its refcount incremented. If the caller needs
295 : : * to retain this data, it should do so, and increment the reference
296 : : * count in the supplied callback.
297 : : */
298 : 0 : int bus_for_each_dev(struct bus_type *bus, struct device *start,
299 : : void *data, int (*fn)(struct device *, void *))
300 : : {
301 : : struct klist_iter i;
302 : : struct device *dev;
303 : : int error = 0;
304 : :
305 [ # # ][ # # ]: 0 : if (!bus || !bus->p)
306 : : return -EINVAL;
307 : :
308 [ # # ]: 0 : klist_iter_init_node(&bus->p->klist_devices, &i,
309 : 0 : (start ? &start->p->knode_bus : NULL));
310 [ # # ][ # # ]: 0 : while ((dev = next_device(&i)) && !error)
311 : 0 : error = fn(dev, data);
312 : 0 : klist_iter_exit(&i);
313 : 0 : return error;
314 : : }
315 : : EXPORT_SYMBOL_GPL(bus_for_each_dev);
316 : :
317 : : /**
318 : : * bus_find_device - device iterator for locating a particular device.
319 : : * @bus: bus type
320 : : * @start: Device to begin with
321 : : * @data: Data to pass to match function
322 : : * @match: Callback function to check device
323 : : *
324 : : * This is similar to the bus_for_each_dev() function above, but it
325 : : * returns a reference to a device that is 'found' for later use, as
326 : : * determined by the @match callback.
327 : : *
328 : : * The callback should return 0 if the device doesn't match and non-zero
329 : : * if it does. If the callback returns non-zero, this function will
330 : : * return to the caller and not iterate over any more devices.
331 : : */
332 : 0 : struct device *bus_find_device(struct bus_type *bus,
333 : : struct device *start, void *data,
334 : : int (*match)(struct device *dev, void *data))
335 : : {
336 : : struct klist_iter i;
337 : : struct device *dev;
338 : :
339 [ + - ][ + - ]: 8 : if (!bus || !bus->p)
340 : : return NULL;
341 : :
342 [ + + ]: 8 : klist_iter_init_node(&bus->p->klist_devices, &i,
343 : 6 : (start ? &start->p->knode_bus : NULL));
344 [ + + ]: 16 : while ((dev = next_device(&i)))
345 [ - + ][ - + ]: 14 : if (match(dev, data) && get_device(dev))
346 : : break;
347 : 8 : klist_iter_exit(&i);
348 : 8 : return dev;
349 : : }
350 : : EXPORT_SYMBOL_GPL(bus_find_device);
351 : :
352 : 0 : static int match_name(struct device *dev, void *data)
353 : : {
354 : : const char *name = data;
355 : :
356 : 0 : return sysfs_streq(name, dev_name(dev));
357 : : }
358 : :
359 : : /**
360 : : * bus_find_device_by_name - device iterator for locating a particular device of a specific name
361 : : * @bus: bus type
362 : : * @start: Device to begin with
363 : : * @name: name of the device to match
364 : : *
365 : : * This is similar to the bus_find_device() function above, but it handles
366 : : * searching by a name automatically, no need to write another strcmp matching
367 : : * function.
368 : : */
369 : 0 : struct device *bus_find_device_by_name(struct bus_type *bus,
370 : : struct device *start, const char *name)
371 : : {
372 : 0 : return bus_find_device(bus, start, (void *)name, match_name);
373 : : }
374 : : EXPORT_SYMBOL_GPL(bus_find_device_by_name);
375 : :
376 : : /**
377 : : * subsys_find_device_by_id - find a device with a specific enumeration number
378 : : * @subsys: subsystem
379 : : * @id: index 'id' in struct device
380 : : * @hint: device to check first
381 : : *
382 : : * Check the hint's next object and if it is a match return it directly,
383 : : * otherwise, fall back to a full list search. Either way a reference for
384 : : * the returned object is taken.
385 : : */
386 : 0 : struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id,
387 : : struct device *hint)
388 : : {
389 : : struct klist_iter i;
390 : : struct device *dev;
391 : :
392 [ # # ]: 0 : if (!subsys)
393 : : return NULL;
394 : :
395 [ # # ]: 0 : if (hint) {
396 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus);
397 : : dev = next_device(&i);
398 [ # # ][ # # ]: 0 : if (dev && dev->id == id && get_device(dev)) {
[ # # ]
399 : 0 : klist_iter_exit(&i);
400 : 0 : return dev;
401 : : }
402 : 0 : klist_iter_exit(&i);
403 : : }
404 : :
405 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &i, NULL);
406 [ # # ]: 0 : while ((dev = next_device(&i))) {
407 [ # # ][ # # ]: 0 : if (dev->id == id && get_device(dev)) {
408 : 0 : klist_iter_exit(&i);
409 : 0 : return dev;
410 : : }
411 : : }
412 : 0 : klist_iter_exit(&i);
413 : 0 : return NULL;
414 : : }
415 : : EXPORT_SYMBOL_GPL(subsys_find_device_by_id);
416 : :
417 : : static struct device_driver *next_driver(struct klist_iter *i)
418 : : {
419 : 24 : struct klist_node *n = klist_next(i);
420 : : struct driver_private *drv_priv;
421 : :
422 [ + + ]: 24 : if (n) {
423 : : drv_priv = container_of(n, struct driver_private, knode_bus);
424 : 20 : return drv_priv->driver;
425 : : }
426 : : return NULL;
427 : : }
428 : :
429 : : /**
430 : : * bus_for_each_drv - driver iterator
431 : : * @bus: bus we're dealing with.
432 : : * @start: driver to start iterating on.
433 : : * @data: data to pass to the callback.
434 : : * @fn: function to call for each driver.
435 : : *
436 : : * This is nearly identical to the device iterator above.
437 : : * We iterate over each driver that belongs to @bus, and call
438 : : * @fn for each. If @fn returns anything but 0, we break out
439 : : * and return it. If @start is not NULL, we use it as the head
440 : : * of the list.
441 : : *
442 : : * NOTE: we don't return the driver that returns a non-zero
443 : : * value, nor do we leave the reference count incremented for that
444 : : * driver. If the caller needs to know that info, it must set it
445 : : * in the callback. It must also be sure to increment the refcount
446 : : * so it doesn't disappear before returning to the caller.
447 : : */
448 : 0 : int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
449 : : void *data, int (*fn)(struct device_driver *, void *))
450 : : {
451 : : struct klist_iter i;
452 : : struct device_driver *drv;
453 : : int error = 0;
454 : :
455 [ + - ]: 6 : if (!bus)
456 : : return -EINVAL;
457 : :
458 [ - + ]: 6 : klist_iter_init_node(&bus->p->klist_drivers, &i,
459 : 0 : start ? &start->p->knode_bus : NULL);
460 [ + + ][ + + ]: 30 : while ((drv = next_driver(&i)) && !error)
461 : 18 : error = fn(drv, data);
462 : 6 : klist_iter_exit(&i);
463 : 6 : return error;
464 : : }
465 : : EXPORT_SYMBOL_GPL(bus_for_each_drv);
466 : :
467 : 6 : static int device_add_attrs(struct bus_type *bus, struct device *dev)
468 : : {
469 : : int error = 0;
470 : : int i;
471 : :
472 [ - + ]: 6 : if (!bus->dev_attrs)
473 : : return 0;
474 : :
475 [ # # ]: 0 : for (i = 0; bus->dev_attrs[i].attr.name; i++) {
476 : 0 : error = device_create_file(dev, &bus->dev_attrs[i]);
477 [ # # ]: 0 : if (error) {
478 [ # # ]: 6 : while (--i >= 0)
479 : 0 : device_remove_file(dev, &bus->dev_attrs[i]);
480 : : break;
481 : : }
482 : : }
483 : : return error;
484 : : }
485 : :
486 : 6 : static void device_remove_attrs(struct bus_type *bus, struct device *dev)
487 : : {
488 : : int i;
489 : :
490 [ - + ]: 6 : if (bus->dev_attrs) {
491 [ # # ]: 0 : for (i = 0; bus->dev_attrs[i].attr.name; i++)
492 : 0 : device_remove_file(dev, &bus->dev_attrs[i]);
493 : : }
494 : 0 : }
495 : :
496 : : /**
497 : : * bus_add_device - add device to bus
498 : : * @dev: device being added
499 : : *
500 : : * - Add device's bus attributes.
501 : : * - Create links to device's bus.
502 : : * - Add the device to its bus's list of devices.
503 : : */
504 : 0 : int bus_add_device(struct device *dev)
505 : : {
506 : 128 : struct bus_type *bus = bus_get(dev->bus);
507 : : int error = 0;
508 : :
509 [ + + ]: 128 : if (bus) {
510 : : pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
511 : 6 : error = device_add_attrs(bus, dev);
512 [ + - ]: 6 : if (error)
513 : : goto out_put;
514 : 6 : error = device_add_groups(dev, bus->dev_groups);
515 [ + - ]: 6 : if (error)
516 : : goto out_groups;
517 : 6 : error = sysfs_create_link(&bus->p->devices_kset->kobj,
518 : : &dev->kobj, dev_name(dev));
519 [ + - ]: 6 : if (error)
520 : : goto out_id;
521 : 6 : error = sysfs_create_link(&dev->kobj,
522 : 6 : &dev->bus->p->subsys.kobj, "subsystem");
523 [ + - ]: 6 : if (error)
524 : : goto out_subsys;
525 : 6 : klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
526 : : }
527 : : return 0;
528 : :
529 : : out_subsys:
530 : 0 : sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
531 : : out_groups:
532 : 0 : device_remove_groups(dev, bus->dev_groups);
533 : : out_id:
534 : 0 : device_remove_attrs(bus, dev);
535 : : out_put:
536 : 0 : bus_put(dev->bus);
537 : 0 : return error;
538 : : }
539 : :
540 : : /**
541 : : * bus_probe_device - probe drivers for a new device
542 : : * @dev: device to probe
543 : : *
544 : : * - Automatically probe for a driver if the bus allows it.
545 : : */
546 : 0 : void bus_probe_device(struct device *dev)
547 : : {
548 : 128 : struct bus_type *bus = dev->bus;
549 : : struct subsys_interface *sif;
550 : : int ret;
551 : :
552 [ + + ]: 128 : if (!bus)
553 : 128 : return;
554 : :
555 [ + - ]: 6 : if (bus->p->drivers_autoprobe) {
556 : 6 : ret = device_attach(dev);
557 [ - + ]: 6 : WARN_ON(ret < 0);
558 : : }
559 : :
560 : 6 : mutex_lock(&bus->p->mutex);
561 [ - + ]: 134 : list_for_each_entry(sif, &bus->p->interfaces, node)
562 [ # # ]: 0 : if (sif->add_dev)
563 : 0 : sif->add_dev(dev, sif);
564 : 6 : mutex_unlock(&bus->p->mutex);
565 : : }
566 : :
567 : : /**
568 : : * bus_remove_device - remove device from bus
569 : : * @dev: device to be removed
570 : : *
571 : : * - Remove device from all interfaces.
572 : : * - Remove symlink from bus' directory.
573 : : * - Delete device from bus's list.
574 : : * - Detach from its driver.
575 : : * - Drop reference taken in bus_add_device().
576 : : */
577 : 0 : void bus_remove_device(struct device *dev)
578 : : {
579 : 16 : struct bus_type *bus = dev->bus;
580 : : struct subsys_interface *sif;
581 : :
582 [ + + ]: 16 : if (!bus)
583 : 16 : return;
584 : :
585 : 6 : mutex_lock(&bus->p->mutex);
586 [ - + ]: 6 : list_for_each_entry(sif, &bus->p->interfaces, node)
587 [ # # ]: 0 : if (sif->remove_dev)
588 : 0 : sif->remove_dev(dev, sif);
589 : 6 : mutex_unlock(&bus->p->mutex);
590 : :
591 : 6 : sysfs_remove_link(&dev->kobj, "subsystem");
592 : 6 : sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
593 : : dev_name(dev));
594 : 6 : device_remove_attrs(dev->bus, dev);
595 : 6 : device_remove_groups(dev, dev->bus->dev_groups);
596 [ + - ]: 6 : if (klist_node_attached(&dev->p->knode_bus))
597 : 6 : klist_del(&dev->p->knode_bus);
598 : :
599 : : pr_debug("bus: '%s': remove device %s\n",
600 : : dev->bus->name, dev_name(dev));
601 : 6 : device_release_driver(dev);
602 : 6 : bus_put(dev->bus);
603 : : }
604 : :
605 : 0 : static int __must_check add_bind_files(struct device_driver *drv)
606 : : {
607 : : int ret;
608 : :
609 : 0 : ret = driver_create_file(drv, &driver_attr_unbind);
610 [ # # ]: 0 : if (ret == 0) {
611 : 0 : ret = driver_create_file(drv, &driver_attr_bind);
612 [ # # ]: 0 : if (ret)
613 : 0 : driver_remove_file(drv, &driver_attr_unbind);
614 : : }
615 : 0 : return ret;
616 : : }
617 : :
618 : 0 : static void remove_bind_files(struct device_driver *drv)
619 : : {
620 : 0 : driver_remove_file(drv, &driver_attr_bind);
621 : 0 : driver_remove_file(drv, &driver_attr_unbind);
622 : 0 : }
623 : :
624 : : static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
625 : : static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
626 : : show_drivers_autoprobe, store_drivers_autoprobe);
627 : :
628 : 0 : static int add_probe_files(struct bus_type *bus)
629 : : {
630 : : int retval;
631 : :
632 : 0 : retval = bus_create_file(bus, &bus_attr_drivers_probe);
633 [ # # ]: 0 : if (retval)
634 : : goto out;
635 : :
636 : 0 : retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
637 [ # # ]: 0 : if (retval)
638 : 0 : bus_remove_file(bus, &bus_attr_drivers_probe);
639 : : out:
640 : 0 : return retval;
641 : : }
642 : :
643 : 0 : static void remove_probe_files(struct bus_type *bus)
644 : : {
645 : 0 : bus_remove_file(bus, &bus_attr_drivers_autoprobe);
646 : 0 : bus_remove_file(bus, &bus_attr_drivers_probe);
647 : 0 : }
648 : :
649 : 0 : static ssize_t uevent_store(struct device_driver *drv, const char *buf,
650 : : size_t count)
651 : : {
652 : : enum kobject_action action;
653 : :
654 [ # # ]: 0 : if (kobject_action_type(buf, count, &action) == 0)
655 : 0 : kobject_uevent(&drv->p->kobj, action);
656 : 0 : return count;
657 : : }
658 : : static DRIVER_ATTR_WO(uevent);
659 : :
660 : : /**
661 : : * bus_add_driver - Add a driver to the bus.
662 : : * @drv: driver.
663 : : */
664 : 0 : int bus_add_driver(struct device_driver *drv)
665 : : {
666 : : struct bus_type *bus;
667 : : struct driver_private *priv;
668 : : int error = 0;
669 : :
670 : 0 : bus = bus_get(drv->bus);
671 [ # # ]: 0 : if (!bus)
672 : : return -EINVAL;
673 : :
674 : : pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
675 : :
676 : : priv = kzalloc(sizeof(*priv), GFP_KERNEL);
677 [ # # ]: 0 : if (!priv) {
678 : : error = -ENOMEM;
679 : : goto out_put_bus;
680 : : }
681 : 0 : klist_init(&priv->klist_devices, NULL, NULL);
682 : 0 : priv->driver = drv;
683 : 0 : drv->p = priv;
684 : 0 : priv->kobj.kset = bus->p->drivers_kset;
685 : 0 : error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
686 : : "%s", drv->name);
687 [ # # ]: 0 : if (error)
688 : : goto out_unregister;
689 : :
690 : 0 : klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
691 [ # # ]: 0 : if (drv->bus->p->drivers_autoprobe) {
692 : 0 : error = driver_attach(drv);
693 [ # # ]: 0 : if (error)
694 : : goto out_unregister;
695 : : }
696 : 0 : module_add_driver(drv->owner, drv);
697 : :
698 : 0 : error = driver_create_file(drv, &driver_attr_uevent);
699 [ # # ]: 0 : if (error) {
700 : 0 : printk(KERN_ERR "%s: uevent attr (%s) failed\n",
701 : : __func__, drv->name);
702 : : }
703 : 0 : error = driver_add_groups(drv, bus->drv_groups);
704 [ # # ]: 0 : if (error) {
705 : : /* How the hell do we get out of this pickle? Give up */
706 : 0 : printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",
707 : : __func__, drv->name);
708 : : }
709 : :
710 [ # # ]: 0 : if (!drv->suppress_bind_attrs) {
711 : 0 : error = add_bind_files(drv);
712 [ # # ]: 0 : if (error) {
713 : : /* Ditto */
714 : 0 : printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
715 : : __func__, drv->name);
716 : : }
717 : : }
718 : :
719 : : return 0;
720 : :
721 : : out_unregister:
722 : 0 : kobject_put(&priv->kobj);
723 : 0 : kfree(drv->p);
724 : 0 : drv->p = NULL;
725 : : out_put_bus:
726 : : bus_put(bus);
727 : 0 : return error;
728 : : }
729 : :
730 : : /**
731 : : * bus_remove_driver - delete driver from bus's knowledge.
732 : : * @drv: driver.
733 : : *
734 : : * Detach the driver from the devices it controls, and remove
735 : : * it from its bus's list of drivers. Finally, we drop the reference
736 : : * to the bus we took in bus_add_driver().
737 : : */
738 : 0 : void bus_remove_driver(struct device_driver *drv)
739 : : {
740 [ # # ]: 0 : if (!drv->bus)
741 : 0 : return;
742 : :
743 [ # # ]: 0 : if (!drv->suppress_bind_attrs)
744 : 0 : remove_bind_files(drv);
745 : 0 : driver_remove_groups(drv, drv->bus->drv_groups);
746 : 0 : driver_remove_file(drv, &driver_attr_uevent);
747 : 0 : klist_remove(&drv->p->knode_bus);
748 : : pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
749 : 0 : driver_detach(drv);
750 : 0 : module_remove_driver(drv);
751 : 0 : kobject_put(&drv->p->kobj);
752 : 0 : bus_put(drv->bus);
753 : : }
754 : :
755 : : /* Helper for bus_rescan_devices's iter */
756 : 0 : static int __must_check bus_rescan_devices_helper(struct device *dev,
757 : : void *data)
758 : : {
759 : : int ret = 0;
760 : :
761 [ # # ]: 0 : if (!dev->driver) {
762 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
763 : : device_lock(dev->parent);
764 : 0 : ret = device_attach(dev);
765 [ # # ]: 0 : if (dev->parent)
766 : : device_unlock(dev->parent);
767 : : }
768 : 0 : return ret < 0 ? ret : 0;
769 : : }
770 : :
771 : : /**
772 : : * bus_rescan_devices - rescan devices on the bus for possible drivers
773 : : * @bus: the bus to scan.
774 : : *
775 : : * This function will look for devices on the bus with no driver
776 : : * attached and rescan it against existing drivers to see if it matches
777 : : * any by calling device_attach() for the unbound devices.
778 : : */
779 : 0 : int bus_rescan_devices(struct bus_type *bus)
780 : : {
781 : 0 : return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
782 : : }
783 : : EXPORT_SYMBOL_GPL(bus_rescan_devices);
784 : :
785 : : /**
786 : : * device_reprobe - remove driver for a device and probe for a new driver
787 : : * @dev: the device to reprobe
788 : : *
789 : : * This function detaches the attached driver (if any) for the given
790 : : * device and restarts the driver probing process. It is intended
791 : : * to use if probing criteria changed during a devices lifetime and
792 : : * driver attachment should change accordingly.
793 : : */
794 : 0 : int device_reprobe(struct device *dev)
795 : : {
796 [ # # ]: 0 : if (dev->driver) {
797 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
798 : : device_lock(dev->parent);
799 : 0 : device_release_driver(dev);
800 [ # # ]: 0 : if (dev->parent)
801 : : device_unlock(dev->parent);
802 : : }
803 : 0 : return bus_rescan_devices_helper(dev, NULL);
804 : : }
805 : : EXPORT_SYMBOL_GPL(device_reprobe);
806 : :
807 : : /**
808 : : * find_bus - locate bus by name.
809 : : * @name: name of bus.
810 : : *
811 : : * Call kset_find_obj() to iterate over list of buses to
812 : : * find a bus by name. Return bus if found.
813 : : *
814 : : * Note that kset_find_obj increments bus' reference count.
815 : : */
816 : : #if 0
817 : : struct bus_type *find_bus(char *name)
818 : : {
819 : : struct kobject *k = kset_find_obj(bus_kset, name);
820 : : return k ? to_bus(k) : NULL;
821 : : }
822 : : #endif /* 0 */
823 : :
824 : : static int bus_add_groups(struct bus_type *bus,
825 : : const struct attribute_group **groups)
826 : : {
827 : 0 : return sysfs_create_groups(&bus->p->subsys.kobj, groups);
828 : : }
829 : :
830 : : static void bus_remove_groups(struct bus_type *bus,
831 : : const struct attribute_group **groups)
832 : : {
833 : 0 : sysfs_remove_groups(&bus->p->subsys.kobj, groups);
834 : : }
835 : :
836 : 0 : static void klist_devices_get(struct klist_node *n)
837 : : {
838 : : struct device_private *dev_prv = to_device_private_bus(n);
839 : 6 : struct device *dev = dev_prv->device;
840 : :
841 : 6 : get_device(dev);
842 : 6 : }
843 : :
844 : 0 : static void klist_devices_put(struct klist_node *n)
845 : : {
846 : : struct device_private *dev_prv = to_device_private_bus(n);
847 : 6 : struct device *dev = dev_prv->device;
848 : :
849 : 6 : put_device(dev);
850 : 6 : }
851 : :
852 : 0 : static ssize_t bus_uevent_store(struct bus_type *bus,
853 : : const char *buf, size_t count)
854 : : {
855 : : enum kobject_action action;
856 : :
857 [ # # ]: 0 : if (kobject_action_type(buf, count, &action) == 0)
858 : 0 : kobject_uevent(&bus->p->subsys.kobj, action);
859 : 0 : return count;
860 : : }
861 : : static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
862 : :
863 : : /**
864 : : * bus_register - register a driver-core subsystem
865 : : * @bus: bus to register
866 : : *
867 : : * Once we have that, we register the bus with the kobject
868 : : * infrastructure, then register the children subsystems it has:
869 : : * the devices and drivers that belong to the subsystem.
870 : : */
871 : 0 : int bus_register(struct bus_type *bus)
872 : : {
873 : : int retval;
874 : : struct subsys_private *priv;
875 : 0 : struct lock_class_key *key = &bus->lock_key;
876 : :
877 : : priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
878 [ # # ]: 0 : if (!priv)
879 : : return -ENOMEM;
880 : :
881 : 0 : priv->bus = bus;
882 : 0 : bus->p = priv;
883 : :
884 : 0 : BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
885 : :
886 : 0 : retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
887 [ # # ]: 0 : if (retval)
888 : : goto out;
889 : :
890 : 0 : priv->subsys.kobj.kset = bus_kset;
891 : 0 : priv->subsys.kobj.ktype = &bus_ktype;
892 : 0 : priv->drivers_autoprobe = 1;
893 : :
894 : 0 : retval = kset_register(&priv->subsys);
895 [ # # ]: 0 : if (retval)
896 : : goto out;
897 : :
898 : 0 : retval = bus_create_file(bus, &bus_attr_uevent);
899 [ # # ]: 0 : if (retval)
900 : : goto bus_uevent_fail;
901 : :
902 : 0 : priv->devices_kset = kset_create_and_add("devices", NULL,
903 : : &priv->subsys.kobj);
904 [ # # ]: 0 : if (!priv->devices_kset) {
905 : : retval = -ENOMEM;
906 : : goto bus_devices_fail;
907 : : }
908 : :
909 : 0 : priv->drivers_kset = kset_create_and_add("drivers", NULL,
910 : : &priv->subsys.kobj);
911 [ # # ]: 0 : if (!priv->drivers_kset) {
912 : : retval = -ENOMEM;
913 : : goto bus_drivers_fail;
914 : : }
915 : :
916 : 0 : INIT_LIST_HEAD(&priv->interfaces);
917 : 0 : __mutex_init(&priv->mutex, "subsys mutex", key);
918 : 0 : klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
919 : 0 : klist_init(&priv->klist_drivers, NULL, NULL);
920 : :
921 : 0 : retval = add_probe_files(bus);
922 [ # # ]: 0 : if (retval)
923 : : goto bus_probe_files_fail;
924 : :
925 : 0 : retval = bus_add_groups(bus, bus->bus_groups);
926 [ # # ]: 0 : if (retval)
927 : : goto bus_groups_fail;
928 : :
929 : : pr_debug("bus: '%s': registered\n", bus->name);
930 : : return 0;
931 : :
932 : : bus_groups_fail:
933 : 0 : remove_probe_files(bus);
934 : : bus_probe_files_fail:
935 : 0 : kset_unregister(bus->p->drivers_kset);
936 : : bus_drivers_fail:
937 : 0 : kset_unregister(bus->p->devices_kset);
938 : : bus_devices_fail:
939 : 0 : bus_remove_file(bus, &bus_attr_uevent);
940 : : bus_uevent_fail:
941 : 0 : kset_unregister(&bus->p->subsys);
942 : : out:
943 : 0 : kfree(bus->p);
944 : 0 : bus->p = NULL;
945 : 0 : return retval;
946 : : }
947 : : EXPORT_SYMBOL_GPL(bus_register);
948 : :
949 : : /**
950 : : * bus_unregister - remove a bus from the system
951 : : * @bus: bus.
952 : : *
953 : : * Unregister the child subsystems and the bus itself.
954 : : * Finally, we call bus_put() to release the refcount
955 : : */
956 : 0 : void bus_unregister(struct bus_type *bus)
957 : : {
958 : : pr_debug("bus: '%s': unregistering\n", bus->name);
959 [ # # ]: 0 : if (bus->dev_root)
960 : 0 : device_unregister(bus->dev_root);
961 : 0 : bus_remove_groups(bus, bus->bus_groups);
962 : 0 : remove_probe_files(bus);
963 : 0 : kset_unregister(bus->p->drivers_kset);
964 : 0 : kset_unregister(bus->p->devices_kset);
965 : 0 : bus_remove_file(bus, &bus_attr_uevent);
966 : 0 : kset_unregister(&bus->p->subsys);
967 : 0 : }
968 : : EXPORT_SYMBOL_GPL(bus_unregister);
969 : :
970 : 0 : int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
971 : : {
972 : 0 : return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
973 : : }
974 : : EXPORT_SYMBOL_GPL(bus_register_notifier);
975 : :
976 : 0 : int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
977 : : {
978 : 0 : return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
979 : : }
980 : : EXPORT_SYMBOL_GPL(bus_unregister_notifier);
981 : :
982 : 0 : struct kset *bus_get_kset(struct bus_type *bus)
983 : : {
984 : 0 : return &bus->p->subsys;
985 : : }
986 : : EXPORT_SYMBOL_GPL(bus_get_kset);
987 : :
988 : 0 : struct klist *bus_get_device_klist(struct bus_type *bus)
989 : : {
990 : 0 : return &bus->p->klist_devices;
991 : : }
992 : : EXPORT_SYMBOL_GPL(bus_get_device_klist);
993 : :
994 : : /*
995 : : * Yes, this forcibly breaks the klist abstraction temporarily. It
996 : : * just wants to sort the klist, not change reference counts and
997 : : * take/drop locks rapidly in the process. It does all this while
998 : : * holding the lock for the list, so objects can't otherwise be
999 : : * added/removed while we're swizzling.
1000 : : */
1001 : 0 : static void device_insertion_sort_klist(struct device *a, struct list_head *list,
1002 : : int (*compare)(const struct device *a,
1003 : : const struct device *b))
1004 : : {
1005 : : struct list_head *pos;
1006 : : struct klist_node *n;
1007 : : struct device_private *dev_prv;
1008 : : struct device *b;
1009 : :
1010 [ # # ]: 0 : list_for_each(pos, list) {
1011 : : n = container_of(pos, struct klist_node, n_node);
1012 : : dev_prv = to_device_private_bus(n);
1013 : 0 : b = dev_prv->device;
1014 [ # # ]: 0 : if (compare(a, b) <= 0) {
1015 : 0 : list_move_tail(&a->p->knode_bus.n_node,
1016 : 0 : &b->p->knode_bus.n_node);
1017 : 0 : return;
1018 : : }
1019 : : }
1020 : 0 : list_move_tail(&a->p->knode_bus.n_node, list);
1021 : : }
1022 : :
1023 : 0 : void bus_sort_breadthfirst(struct bus_type *bus,
1024 : : int (*compare)(const struct device *a,
1025 : : const struct device *b))
1026 : : {
1027 : 0 : LIST_HEAD(sorted_devices);
1028 : : struct list_head *pos, *tmp;
1029 : : struct klist_node *n;
1030 : : struct device_private *dev_prv;
1031 : : struct device *dev;
1032 : : struct klist *device_klist;
1033 : :
1034 : : device_klist = bus_get_device_klist(bus);
1035 : :
1036 : : spin_lock(&device_klist->k_lock);
1037 [ # # ]: 0 : list_for_each_safe(pos, tmp, &device_klist->k_list) {
1038 : : n = container_of(pos, struct klist_node, n_node);
1039 : : dev_prv = to_device_private_bus(n);
1040 : 0 : dev = dev_prv->device;
1041 : 0 : device_insertion_sort_klist(dev, &sorted_devices, compare);
1042 : : }
1043 : : list_splice(&sorted_devices, &device_klist->k_list);
1044 : : spin_unlock(&device_klist->k_lock);
1045 : 0 : }
1046 : : EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
1047 : :
1048 : : /**
1049 : : * subsys_dev_iter_init - initialize subsys device iterator
1050 : : * @iter: subsys iterator to initialize
1051 : : * @subsys: the subsys we wanna iterate over
1052 : : * @start: the device to start iterating from, if any
1053 : : * @type: device_type of the devices to iterate over, NULL for all
1054 : : *
1055 : : * Initialize subsys iterator @iter such that it iterates over devices
1056 : : * of @subsys. If @start is set, the list iteration will start there,
1057 : : * otherwise if it is NULL, the iteration starts at the beginning of
1058 : : * the list.
1059 : : */
1060 : 0 : void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
1061 : : struct device *start, const struct device_type *type)
1062 : : {
1063 : : struct klist_node *start_knode = NULL;
1064 : :
1065 [ # # ]: 0 : if (start)
1066 : 0 : start_knode = &start->p->knode_bus;
1067 : 2 : klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode);
1068 : 2 : iter->type = type;
1069 : 0 : }
1070 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_init);
1071 : :
1072 : : /**
1073 : : * subsys_dev_iter_next - iterate to the next device
1074 : : * @iter: subsys iterator to proceed
1075 : : *
1076 : : * Proceed @iter to the next device and return it. Returns NULL if
1077 : : * iteration is complete.
1078 : : *
1079 : : * The returned device is referenced and won't be released till
1080 : : * iterator is proceed to the next device or exited. The caller is
1081 : : * free to do whatever it wants to do with the device including
1082 : : * calling back into subsys code.
1083 : : */
1084 : 12 : struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)
1085 : : {
1086 : : struct klist_node *knode;
1087 : : struct device *dev;
1088 : :
1089 : : for (;;) {
1090 : 12 : knode = klist_next(&iter->ki);
1091 [ + + ]: 12 : if (!knode)
1092 : : return NULL;
1093 : 10 : dev = container_of(knode, struct device_private, knode_bus)->device;
1094 [ - + ][ # # ]: 10 : if (!iter->type || iter->type == dev->type)
1095 : : return dev;
1096 : : }
1097 : : }
1098 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_next);
1099 : :
1100 : : /**
1101 : : * subsys_dev_iter_exit - finish iteration
1102 : : * @iter: subsys iterator to finish
1103 : : *
1104 : : * Finish an iteration. Always call this function after iteration is
1105 : : * complete whether the iteration ran till the end or not.
1106 : : */
1107 : 0 : void subsys_dev_iter_exit(struct subsys_dev_iter *iter)
1108 : : {
1109 : 2 : klist_iter_exit(&iter->ki);
1110 : 0 : }
1111 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_exit);
1112 : :
1113 : 0 : int subsys_interface_register(struct subsys_interface *sif)
1114 : : {
1115 : : struct bus_type *subsys;
1116 : : struct subsys_dev_iter iter;
1117 : : struct device *dev;
1118 : :
1119 [ + - ][ + - ]: 1 : if (!sif || !sif->subsys)
1120 : : return -ENODEV;
1121 : :
1122 : : subsys = bus_get(sif->subsys);
1123 [ + - ]: 1 : if (!subsys)
1124 : : return -EINVAL;
1125 : :
1126 : 1 : mutex_lock(&subsys->p->mutex);
1127 : 1 : list_add_tail(&sif->node, &subsys->p->interfaces);
1128 [ + - ]: 1 : if (sif->add_dev) {
1129 : : subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1130 [ + + ]: 6 : while ((dev = subsys_dev_iter_next(&iter)))
1131 : 5 : sif->add_dev(dev, sif);
1132 : : subsys_dev_iter_exit(&iter);
1133 : : }
1134 : 1 : mutex_unlock(&subsys->p->mutex);
1135 : :
1136 : 1 : return 0;
1137 : : }
1138 : : EXPORT_SYMBOL_GPL(subsys_interface_register);
1139 : :
1140 : 0 : void subsys_interface_unregister(struct subsys_interface *sif)
1141 : : {
1142 : : struct bus_type *subsys;
1143 : : struct subsys_dev_iter iter;
1144 : : struct device *dev;
1145 : :
1146 [ + - ][ + - ]: 1 : if (!sif || !sif->subsys)
1147 : 0 : return;
1148 : :
1149 : : subsys = sif->subsys;
1150 : :
1151 : 1 : mutex_lock(&subsys->p->mutex);
1152 : 1 : list_del_init(&sif->node);
1153 [ + - ]: 1 : if (sif->remove_dev) {
1154 : : subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1155 [ + + ]: 6 : while ((dev = subsys_dev_iter_next(&iter)))
1156 : 5 : sif->remove_dev(dev, sif);
1157 : : subsys_dev_iter_exit(&iter);
1158 : : }
1159 : 1 : mutex_unlock(&subsys->p->mutex);
1160 : :
1161 : : bus_put(subsys);
1162 : : }
1163 : : EXPORT_SYMBOL_GPL(subsys_interface_unregister);
1164 : :
1165 : 0 : static void system_root_device_release(struct device *dev)
1166 : : {
1167 : 0 : kfree(dev);
1168 : 0 : }
1169 : :
1170 : 0 : static int subsys_register(struct bus_type *subsys,
1171 : : const struct attribute_group **groups,
1172 : : struct kobject *parent_of_root)
1173 : : {
1174 : : struct device *dev;
1175 : : int err;
1176 : :
1177 : 0 : err = bus_register(subsys);
1178 [ # # ]: 0 : if (err < 0)
1179 : : return err;
1180 : :
1181 : : dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1182 [ # # ]: 0 : if (!dev) {
1183 : : err = -ENOMEM;
1184 : : goto err_dev;
1185 : : }
1186 : :
1187 : 0 : err = dev_set_name(dev, "%s", subsys->name);
1188 [ # # ]: 0 : if (err < 0)
1189 : : goto err_name;
1190 : :
1191 : 0 : dev->kobj.parent = parent_of_root;
1192 : 0 : dev->groups = groups;
1193 : 0 : dev->release = system_root_device_release;
1194 : :
1195 : 0 : err = device_register(dev);
1196 [ # # ]: 0 : if (err < 0)
1197 : : goto err_dev_reg;
1198 : :
1199 : 0 : subsys->dev_root = dev;
1200 : 0 : return 0;
1201 : :
1202 : : err_dev_reg:
1203 : 0 : put_device(dev);
1204 : : dev = NULL;
1205 : : err_name:
1206 : 0 : kfree(dev);
1207 : : err_dev:
1208 : 0 : bus_unregister(subsys);
1209 : 0 : return err;
1210 : : }
1211 : :
1212 : : /**
1213 : : * subsys_system_register - register a subsystem at /sys/devices/system/
1214 : : * @subsys: system subsystem
1215 : : * @groups: default attributes for the root device
1216 : : *
1217 : : * All 'system' subsystems have a /sys/devices/system/<name> root device
1218 : : * with the name of the subsystem. The root device can carry subsystem-
1219 : : * wide attributes. All registered devices are below this single root
1220 : : * device and are named after the subsystem with a simple enumeration
1221 : : * number appended. The registered devices are not explicitely named;
1222 : : * only 'id' in the device needs to be set.
1223 : : *
1224 : : * Do not use this interface for anything new, it exists for compatibility
1225 : : * with bad ideas only. New subsystems should use plain subsystems; and
1226 : : * add the subsystem-wide attributes should be added to the subsystem
1227 : : * directory itself and not some create fake root-device placed in
1228 : : * /sys/devices/system/<name>.
1229 : : */
1230 : 0 : int subsys_system_register(struct bus_type *subsys,
1231 : : const struct attribute_group **groups)
1232 : : {
1233 : 0 : return subsys_register(subsys, groups, &system_kset->kobj);
1234 : : }
1235 : : EXPORT_SYMBOL_GPL(subsys_system_register);
1236 : :
1237 : : /**
1238 : : * subsys_virtual_register - register a subsystem at /sys/devices/virtual/
1239 : : * @subsys: virtual subsystem
1240 : : * @groups: default attributes for the root device
1241 : : *
1242 : : * All 'virtual' subsystems have a /sys/devices/system/<name> root device
1243 : : * with the name of the subystem. The root device can carry subsystem-wide
1244 : : * attributes. All registered devices are below this single root device.
1245 : : * There's no restriction on device naming. This is for kernel software
1246 : : * constructs which need sysfs interface.
1247 : : */
1248 : 0 : int subsys_virtual_register(struct bus_type *subsys,
1249 : : const struct attribute_group **groups)
1250 : : {
1251 : : struct kobject *virtual_dir;
1252 : :
1253 : 0 : virtual_dir = virtual_device_parent(NULL);
1254 [ # # ]: 0 : if (!virtual_dir)
1255 : : return -ENOMEM;
1256 : :
1257 : 0 : return subsys_register(subsys, groups, virtual_dir);
1258 : : }
1259 : : EXPORT_SYMBOL_GPL(subsys_virtual_register);
1260 : :
1261 : 0 : int __init buses_init(void)
1262 : : {
1263 : 0 : bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
1264 [ # # ]: 0 : if (!bus_kset)
1265 : : return -ENOMEM;
1266 : :
1267 : 0 : system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
1268 [ # # ]: 0 : if (!system_kset)
1269 : : return -ENOMEM;
1270 : :
1271 : 0 : return 0;
1272 : : }
|
