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