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