1
2
3
4
5
6
7
8
9
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 "base.h"
21#include "power/power.h"
22
23
24static struct kset *system_kset;
25
26#define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
27
28
29
30
31
32#define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
33
34
35static int __must_check bus_rescan_devices_helper(struct device *dev,
36 void *data);
37
38static struct bus_type *bus_get(struct bus_type *bus)
39{
40 if (bus) {
41 kset_get(&bus->p->subsys);
42 return bus;
43 }
44 return NULL;
45}
46
47static void bus_put(struct bus_type *bus)
48{
49 if (bus)
50 kset_put(&bus->p->subsys);
51}
52
53static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr,
54 char *buf)
55{
56 struct driver_attribute *drv_attr = to_drv_attr(attr);
57 struct driver_private *drv_priv = to_driver(kobj);
58 ssize_t ret = -EIO;
59
60 if (drv_attr->show)
61 ret = drv_attr->show(drv_priv->driver, buf);
62 return ret;
63}
64
65static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
66 const char *buf, size_t count)
67{
68 struct driver_attribute *drv_attr = to_drv_attr(attr);
69 struct driver_private *drv_priv = to_driver(kobj);
70 ssize_t ret = -EIO;
71
72 if (drv_attr->store)
73 ret = drv_attr->store(drv_priv->driver, buf, count);
74 return ret;
75}
76
77static const struct sysfs_ops driver_sysfs_ops = {
78 .show = drv_attr_show,
79 .store = drv_attr_store,
80};
81
82static void driver_release(struct kobject *kobj)
83{
84 struct driver_private *drv_priv = to_driver(kobj);
85
86 pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
87 kfree(drv_priv);
88}
89
90static struct kobj_type driver_ktype = {
91 .sysfs_ops = &driver_sysfs_ops,
92 .release = driver_release,
93};
94
95
96
97
98static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
99 char *buf)
100{
101 struct bus_attribute *bus_attr = to_bus_attr(attr);
102 struct subsys_private *subsys_priv = to_subsys_private(kobj);
103 ssize_t ret = 0;
104
105 if (bus_attr->show)
106 ret = bus_attr->show(subsys_priv->bus, buf);
107 return ret;
108}
109
110static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
111 const char *buf, size_t count)
112{
113 struct bus_attribute *bus_attr = to_bus_attr(attr);
114 struct subsys_private *subsys_priv = to_subsys_private(kobj);
115 ssize_t ret = 0;
116
117 if (bus_attr->store)
118 ret = bus_attr->store(subsys_priv->bus, buf, count);
119 return ret;
120}
121
122static const struct sysfs_ops bus_sysfs_ops = {
123 .show = bus_attr_show,
124 .store = bus_attr_store,
125};
126
127int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
128{
129 int error;
130 if (bus_get(bus)) {
131 error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
132 bus_put(bus);
133 } else
134 error = -EINVAL;
135 return error;
136}
137EXPORT_SYMBOL_GPL(bus_create_file);
138
139void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
140{
141 if (bus_get(bus)) {
142 sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
143 bus_put(bus);
144 }
145}
146EXPORT_SYMBOL_GPL(bus_remove_file);
147
148static struct kobj_type bus_ktype = {
149 .sysfs_ops = &bus_sysfs_ops,
150};
151
152static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
153{
154 struct kobj_type *ktype = get_ktype(kobj);
155
156 if (ktype == &bus_ktype)
157 return 1;
158 return 0;
159}
160
161static const struct kset_uevent_ops bus_uevent_ops = {
162 .filter = bus_uevent_filter,
163};
164
165static struct kset *bus_kset;
166
167
168#ifdef CONFIG_HOTPLUG
169
170static ssize_t driver_unbind(struct device_driver *drv,
171 const char *buf, size_t count)
172{
173 struct bus_type *bus = bus_get(drv->bus);
174 struct device *dev;
175 int err = -ENODEV;
176
177 dev = bus_find_device_by_name(bus, NULL, buf);
178 if (dev && dev->driver == drv) {
179 if (dev->parent)
180 device_lock(dev->parent);
181 device_release_driver(dev);
182 if (dev->parent)
183 device_unlock(dev->parent);
184 err = count;
185 }
186 put_device(dev);
187 bus_put(bus);
188 return err;
189}
190static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
191
192
193
194
195
196
197static ssize_t driver_bind(struct device_driver *drv,
198 const char *buf, size_t count)
199{
200 struct bus_type *bus = bus_get(drv->bus);
201 struct device *dev;
202 int err = -ENODEV;
203
204 dev = bus_find_device_by_name(bus, NULL, buf);
205 if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
206 if (dev->parent)
207 device_lock(dev->parent);
208 device_lock(dev);
209 err = driver_probe_device(drv, dev);
210 device_unlock(dev);
211 if (dev->parent)
212 device_unlock(dev->parent);
213
214 if (err > 0) {
215
216 err = count;
217 } else if (err == 0) {
218
219 err = -ENODEV;
220 }
221 }
222 put_device(dev);
223 bus_put(bus);
224 return err;
225}
226static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
227
228static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
229{
230 return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
231}
232
233static ssize_t store_drivers_autoprobe(struct bus_type *bus,
234 const char *buf, size_t count)
235{
236 if (buf[0] == '0')
237 bus->p->drivers_autoprobe = 0;
238 else
239 bus->p->drivers_autoprobe = 1;
240 return count;
241}
242
243static ssize_t store_drivers_probe(struct bus_type *bus,
244 const char *buf, size_t count)
245{
246 struct device *dev;
247
248 dev = bus_find_device_by_name(bus, NULL, buf);
249 if (!dev)
250 return -ENODEV;
251 if (bus_rescan_devices_helper(dev, NULL) != 0)
252 return -EINVAL;
253 return count;
254}
255#endif
256
257static struct device *next_device(struct klist_iter *i)
258{
259 struct klist_node *n = klist_next(i);
260 struct device *dev = NULL;
261 struct device_private *dev_prv;
262
263 if (n) {
264 dev_prv = to_device_private_bus(n);
265 dev = dev_prv->device;
266 }
267 return dev;
268}
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289int bus_for_each_dev(struct bus_type *bus, struct device *start,
290 void *data, int (*fn)(struct device *, void *))
291{
292 struct klist_iter i;
293 struct device *dev;
294 int error = 0;
295
296 if (!bus)
297 return -EINVAL;
298
299 klist_iter_init_node(&bus->p->klist_devices, &i,
300 (start ? &start->p->knode_bus : NULL));
301 while ((dev = next_device(&i)) && !error)
302 error = fn(dev, data);
303 klist_iter_exit(&i);
304 return error;
305}
306EXPORT_SYMBOL_GPL(bus_for_each_dev);
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323struct device *bus_find_device(struct bus_type *bus,
324 struct device *start, void *data,
325 int (*match)(struct device *dev, void *data))
326{
327 struct klist_iter i;
328 struct device *dev;
329
330 if (!bus)
331 return NULL;
332
333 klist_iter_init_node(&bus->p->klist_devices, &i,
334 (start ? &start->p->knode_bus : NULL));
335 while ((dev = next_device(&i)))
336 if (match(dev, data) && get_device(dev))
337 break;
338 klist_iter_exit(&i);
339 return dev;
340}
341EXPORT_SYMBOL_GPL(bus_find_device);
342
343static int match_name(struct device *dev, void *data)
344{
345 const char *name = data;
346
347 return sysfs_streq(name, dev_name(dev));
348}
349
350
351
352
353
354
355
356
357
358
359
360struct device *bus_find_device_by_name(struct bus_type *bus,
361 struct device *start, const char *name)
362{
363 return bus_find_device(bus, start, (void *)name, match_name);
364}
365EXPORT_SYMBOL_GPL(bus_find_device_by_name);
366
367
368
369
370
371
372
373
374
375
376
377struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id,
378 struct device *hint)
379{
380 struct klist_iter i;
381 struct device *dev;
382
383 if (!subsys)
384 return NULL;
385
386 if (hint) {
387 klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus);
388 dev = next_device(&i);
389 if (dev && dev->id == id && get_device(dev)) {
390 klist_iter_exit(&i);
391 return dev;
392 }
393 klist_iter_exit(&i);
394 }
395
396 klist_iter_init_node(&subsys->p->klist_devices, &i, NULL);
397 while ((dev = next_device(&i))) {
398 if (dev->id == id && get_device(dev)) {
399 klist_iter_exit(&i);
400 return dev;
401 }
402 }
403 klist_iter_exit(&i);
404 return NULL;
405}
406EXPORT_SYMBOL_GPL(subsys_find_device_by_id);
407
408static struct device_driver *next_driver(struct klist_iter *i)
409{
410 struct klist_node *n = klist_next(i);
411 struct driver_private *drv_priv;
412
413 if (n) {
414 drv_priv = container_of(n, struct driver_private, knode_bus);
415 return drv_priv->driver;
416 }
417 return NULL;
418}
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
440 void *data, int (*fn)(struct device_driver *, void *))
441{
442 struct klist_iter i;
443 struct device_driver *drv;
444 int error = 0;
445
446 if (!bus)
447 return -EINVAL;
448
449 klist_iter_init_node(&bus->p->klist_drivers, &i,
450 start ? &start->p->knode_bus : NULL);
451 while ((drv = next_driver(&i)) && !error)
452 error = fn(drv, data);
453 klist_iter_exit(&i);
454 return error;
455}
456EXPORT_SYMBOL_GPL(bus_for_each_drv);
457
458static int device_add_attrs(struct bus_type *bus, struct device *dev)
459{
460 int error = 0;
461 int i;
462
463 if (!bus->dev_attrs)
464 return 0;
465
466 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
467 error = device_create_file(dev, &bus->dev_attrs[i]);
468 if (error) {
469 while (--i >= 0)
470 device_remove_file(dev, &bus->dev_attrs[i]);
471 break;
472 }
473 }
474 return error;
475}
476
477static void device_remove_attrs(struct bus_type *bus, struct device *dev)
478{
479 int i;
480
481 if (bus->dev_attrs) {
482 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
483 device_remove_file(dev, &bus->dev_attrs[i]);
484 }
485}
486
487
488
489
490
491
492
493
494
495int bus_add_device(struct device *dev)
496{
497 struct bus_type *bus = bus_get(dev->bus);
498 int error = 0;
499
500 if (bus) {
501 pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
502 error = device_add_attrs(bus, dev);
503 if (error)
504 goto out_put;
505 error = sysfs_create_link(&bus->p->devices_kset->kobj,
506 &dev->kobj, dev_name(dev));
507 if (error)
508 goto out_id;
509 error = sysfs_create_link(&dev->kobj,
510 &dev->bus->p->subsys.kobj, "subsystem");
511 if (error)
512 goto out_subsys;
513 klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
514 }
515 return 0;
516
517out_subsys:
518 sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
519out_id:
520 device_remove_attrs(bus, dev);
521out_put:
522 bus_put(dev->bus);
523 return error;
524}
525
526
527
528
529
530
531
532void bus_probe_device(struct device *dev)
533{
534 struct bus_type *bus = dev->bus;
535 struct subsys_interface *sif;
536 int ret;
537
538 if (!bus)
539 return;
540
541 if (bus->p->drivers_autoprobe) {
542 ret = device_attach(dev);
543 WARN_ON(ret < 0);
544 }
545
546 mutex_lock(&bus->p->mutex);
547 list_for_each_entry(sif, &bus->p->interfaces, node)
548 if (sif->add_dev)
549 sif->add_dev(dev, sif);
550 mutex_unlock(&bus->p->mutex);
551}
552
553
554
555
556
557
558
559
560
561
562
563void bus_remove_device(struct device *dev)
564{
565 struct bus_type *bus = dev->bus;
566 struct subsys_interface *sif;
567
568 if (!bus)
569 return;
570
571 mutex_lock(&bus->p->mutex);
572 list_for_each_entry(sif, &bus->p->interfaces, node)
573 if (sif->remove_dev)
574 sif->remove_dev(dev, sif);
575 mutex_unlock(&bus->p->mutex);
576
577 sysfs_remove_link(&dev->kobj, "subsystem");
578 sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
579 dev_name(dev));
580 device_remove_attrs(dev->bus, dev);
581 if (klist_node_attached(&dev->p->knode_bus))
582 klist_del(&dev->p->knode_bus);
583
584 pr_debug("bus: '%s': remove device %s\n",
585 dev->bus->name, dev_name(dev));
586 device_release_driver(dev);
587 bus_put(dev->bus);
588}
589
590static int driver_add_attrs(struct bus_type *bus, struct device_driver *drv)
591{
592 int error = 0;
593 int i;
594
595 if (bus->drv_attrs) {
596 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
597 error = driver_create_file(drv, &bus->drv_attrs[i]);
598 if (error)
599 goto err;
600 }
601 }
602done:
603 return error;
604err:
605 while (--i >= 0)
606 driver_remove_file(drv, &bus->drv_attrs[i]);
607 goto done;
608}
609
610static void driver_remove_attrs(struct bus_type *bus,
611 struct device_driver *drv)
612{
613 int i;
614
615 if (bus->drv_attrs) {
616 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
617 driver_remove_file(drv, &bus->drv_attrs[i]);
618 }
619}
620
621#ifdef CONFIG_HOTPLUG
622
623
624
625
626static int __must_check add_bind_files(struct device_driver *drv)
627{
628 int ret;
629
630 ret = driver_create_file(drv, &driver_attr_unbind);
631 if (ret == 0) {
632 ret = driver_create_file(drv, &driver_attr_bind);
633 if (ret)
634 driver_remove_file(drv, &driver_attr_unbind);
635 }
636 return ret;
637}
638
639static void remove_bind_files(struct device_driver *drv)
640{
641 driver_remove_file(drv, &driver_attr_bind);
642 driver_remove_file(drv, &driver_attr_unbind);
643}
644
645static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
646static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
647 show_drivers_autoprobe, store_drivers_autoprobe);
648
649static int add_probe_files(struct bus_type *bus)
650{
651 int retval;
652
653 retval = bus_create_file(bus, &bus_attr_drivers_probe);
654 if (retval)
655 goto out;
656
657 retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
658 if (retval)
659 bus_remove_file(bus, &bus_attr_drivers_probe);
660out:
661 return retval;
662}
663
664static void remove_probe_files(struct bus_type *bus)
665{
666 bus_remove_file(bus, &bus_attr_drivers_autoprobe);
667 bus_remove_file(bus, &bus_attr_drivers_probe);
668}
669#else
670static inline int add_bind_files(struct device_driver *drv) { return 0; }
671static inline void remove_bind_files(struct device_driver *drv) {}
672static inline int add_probe_files(struct bus_type *bus) { return 0; }
673static inline void remove_probe_files(struct bus_type *bus) {}
674#endif
675
676static ssize_t driver_uevent_store(struct device_driver *drv,
677 const char *buf, size_t count)
678{
679 enum kobject_action action;
680
681 if (kobject_action_type(buf, count, &action) == 0)
682 kobject_uevent(&drv->p->kobj, action);
683 return count;
684}
685static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store);
686
687
688
689
690
691int bus_add_driver(struct device_driver *drv)
692{
693 struct bus_type *bus;
694 struct driver_private *priv;
695 int error = 0;
696
697 bus = bus_get(drv->bus);
698 if (!bus)
699 return -EINVAL;
700
701 pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
702
703 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
704 if (!priv) {
705 error = -ENOMEM;
706 goto out_put_bus;
707 }
708 klist_init(&priv->klist_devices, NULL, NULL);
709 priv->driver = drv;
710 drv->p = priv;
711 priv->kobj.kset = bus->p->drivers_kset;
712 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
713 "%s", drv->name);
714 if (error)
715 goto out_unregister;
716
717 if (drv->bus->p->drivers_autoprobe) {
718 error = driver_attach(drv);
719 if (error)
720 goto out_unregister;
721 }
722 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
723 module_add_driver(drv->owner, drv);
724
725 error = driver_create_file(drv, &driver_attr_uevent);
726 if (error) {
727 printk(KERN_ERR "%s: uevent attr (%s) failed\n",
728 __func__, drv->name);
729 }
730 error = driver_add_attrs(bus, drv);
731 if (error) {
732
733 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
734 __func__, drv->name);
735 }
736
737 if (!drv->suppress_bind_attrs) {
738 error = add_bind_files(drv);
739 if (error) {
740
741 printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
742 __func__, drv->name);
743 }
744 }
745
746 return 0;
747
748out_unregister:
749 kobject_put(&priv->kobj);
750 kfree(drv->p);
751 drv->p = NULL;
752out_put_bus:
753 bus_put(bus);
754 return error;
755}
756
757
758
759
760
761
762
763
764
765void bus_remove_driver(struct device_driver *drv)
766{
767 if (!drv->bus)
768 return;
769
770 if (!drv->suppress_bind_attrs)
771 remove_bind_files(drv);
772 driver_remove_attrs(drv->bus, drv);
773 driver_remove_file(drv, &driver_attr_uevent);
774 klist_remove(&drv->p->knode_bus);
775 pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
776 driver_detach(drv);
777 module_remove_driver(drv);
778 kobject_put(&drv->p->kobj);
779 bus_put(drv->bus);
780}
781
782
783static int __must_check bus_rescan_devices_helper(struct device *dev,
784 void *data)
785{
786 int ret = 0;
787
788 if (!dev->driver) {
789 if (dev->parent)
790 device_lock(dev->parent);
791 ret = device_attach(dev);
792 if (dev->parent)
793 device_unlock(dev->parent);
794 }
795 return ret < 0 ? ret : 0;
796}
797
798
799
800
801
802
803
804
805
806int bus_rescan_devices(struct bus_type *bus)
807{
808 return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
809}
810EXPORT_SYMBOL_GPL(bus_rescan_devices);
811
812
813
814
815
816
817
818
819
820
821int device_reprobe(struct device *dev)
822{
823 if (dev->driver) {
824 if (dev->parent)
825 device_lock(dev->parent);
826 device_release_driver(dev);
827 if (dev->parent)
828 device_unlock(dev->parent);
829 }
830 return bus_rescan_devices_helper(dev, NULL);
831}
832EXPORT_SYMBOL_GPL(device_reprobe);
833
834
835
836
837
838
839
840
841
842
843#if 0
844struct bus_type *find_bus(char *name)
845{
846 struct kobject *k = kset_find_obj(bus_kset, name);
847 return k ? to_bus(k) : NULL;
848}
849#endif
850
851
852
853
854
855
856
857static int bus_add_attrs(struct bus_type *bus)
858{
859 int error = 0;
860 int i;
861
862 if (bus->bus_attrs) {
863 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
864 error = bus_create_file(bus, &bus->bus_attrs[i]);
865 if (error)
866 goto err;
867 }
868 }
869done:
870 return error;
871err:
872 while (--i >= 0)
873 bus_remove_file(bus, &bus->bus_attrs[i]);
874 goto done;
875}
876
877static void bus_remove_attrs(struct bus_type *bus)
878{
879 int i;
880
881 if (bus->bus_attrs) {
882 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
883 bus_remove_file(bus, &bus->bus_attrs[i]);
884 }
885}
886
887static void klist_devices_get(struct klist_node *n)
888{
889 struct device_private *dev_prv = to_device_private_bus(n);
890 struct device *dev = dev_prv->device;
891
892 get_device(dev);
893}
894
895static void klist_devices_put(struct klist_node *n)
896{
897 struct device_private *dev_prv = to_device_private_bus(n);
898 struct device *dev = dev_prv->device;
899
900 put_device(dev);
901}
902
903static ssize_t bus_uevent_store(struct bus_type *bus,
904 const char *buf, size_t count)
905{
906 enum kobject_action action;
907
908 if (kobject_action_type(buf, count, &action) == 0)
909 kobject_uevent(&bus->p->subsys.kobj, action);
910 return count;
911}
912static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
913
914
915
916
917
918
919
920
921
922
923int __bus_register(struct bus_type *bus, struct lock_class_key *key)
924{
925 int retval;
926 struct subsys_private *priv;
927
928 priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
929 if (!priv)
930 return -ENOMEM;
931
932 priv->bus = bus;
933 bus->p = priv;
934
935 BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
936
937 retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
938 if (retval)
939 goto out;
940
941 priv->subsys.kobj.kset = bus_kset;
942 priv->subsys.kobj.ktype = &bus_ktype;
943 priv->drivers_autoprobe = 1;
944
945 retval = kset_register(&priv->subsys);
946 if (retval)
947 goto out;
948
949 retval = bus_create_file(bus, &bus_attr_uevent);
950 if (retval)
951 goto bus_uevent_fail;
952
953 priv->devices_kset = kset_create_and_add("devices", NULL,
954 &priv->subsys.kobj);
955 if (!priv->devices_kset) {
956 retval = -ENOMEM;
957 goto bus_devices_fail;
958 }
959
960 priv->drivers_kset = kset_create_and_add("drivers", NULL,
961 &priv->subsys.kobj);
962 if (!priv->drivers_kset) {
963 retval = -ENOMEM;
964 goto bus_drivers_fail;
965 }
966
967 INIT_LIST_HEAD(&priv->interfaces);
968 __mutex_init(&priv->mutex, "subsys mutex", key);
969 klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
970 klist_init(&priv->klist_drivers, NULL, NULL);
971
972 retval = add_probe_files(bus);
973 if (retval)
974 goto bus_probe_files_fail;
975
976 retval = bus_add_attrs(bus);
977 if (retval)
978 goto bus_attrs_fail;
979
980 pr_debug("bus: '%s': registered\n", bus->name);
981 return 0;
982
983bus_attrs_fail:
984 remove_probe_files(bus);
985bus_probe_files_fail:
986 kset_unregister(bus->p->drivers_kset);
987bus_drivers_fail:
988 kset_unregister(bus->p->devices_kset);
989bus_devices_fail:
990 bus_remove_file(bus, &bus_attr_uevent);
991bus_uevent_fail:
992 kset_unregister(&bus->p->subsys);
993out:
994 kfree(bus->p);
995 bus->p = NULL;
996 return retval;
997}
998EXPORT_SYMBOL_GPL(__bus_register);
999
1000
1001
1002
1003
1004
1005
1006
1007void bus_unregister(struct bus_type *bus)
1008{
1009 pr_debug("bus: '%s': unregistering\n", bus->name);
1010 if (bus->dev_root)
1011 device_unregister(bus->dev_root);
1012 bus_remove_attrs(bus);
1013 remove_probe_files(bus);
1014 kset_unregister(bus->p->drivers_kset);
1015 kset_unregister(bus->p->devices_kset);
1016 bus_remove_file(bus, &bus_attr_uevent);
1017 kset_unregister(&bus->p->subsys);
1018 kfree(bus->p);
1019 bus->p = NULL;
1020}
1021EXPORT_SYMBOL_GPL(bus_unregister);
1022
1023int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
1024{
1025 return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
1026}
1027EXPORT_SYMBOL_GPL(bus_register_notifier);
1028
1029int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
1030{
1031 return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
1032}
1033EXPORT_SYMBOL_GPL(bus_unregister_notifier);
1034
1035struct kset *bus_get_kset(struct bus_type *bus)
1036{
1037 return &bus->p->subsys;
1038}
1039EXPORT_SYMBOL_GPL(bus_get_kset);
1040
1041struct klist *bus_get_device_klist(struct bus_type *bus)
1042{
1043 return &bus->p->klist_devices;
1044}
1045EXPORT_SYMBOL_GPL(bus_get_device_klist);
1046
1047
1048
1049
1050
1051
1052
1053
1054static void device_insertion_sort_klist(struct device *a, struct list_head *list,
1055 int (*compare)(const struct device *a,
1056 const struct device *b))
1057{
1058 struct list_head *pos;
1059 struct klist_node *n;
1060 struct device_private *dev_prv;
1061 struct device *b;
1062
1063 list_for_each(pos, list) {
1064 n = container_of(pos, struct klist_node, n_node);
1065 dev_prv = to_device_private_bus(n);
1066 b = dev_prv->device;
1067 if (compare(a, b) <= 0) {
1068 list_move_tail(&a->p->knode_bus.n_node,
1069 &b->p->knode_bus.n_node);
1070 return;
1071 }
1072 }
1073 list_move_tail(&a->p->knode_bus.n_node, list);
1074}
1075
1076void bus_sort_breadthfirst(struct bus_type *bus,
1077 int (*compare)(const struct device *a,
1078 const struct device *b))
1079{
1080 LIST_HEAD(sorted_devices);
1081 struct list_head *pos, *tmp;
1082 struct klist_node *n;
1083 struct device_private *dev_prv;
1084 struct device *dev;
1085 struct klist *device_klist;
1086
1087 device_klist = bus_get_device_klist(bus);
1088
1089 spin_lock(&device_klist->k_lock);
1090 list_for_each_safe(pos, tmp, &device_klist->k_list) {
1091 n = container_of(pos, struct klist_node, n_node);
1092 dev_prv = to_device_private_bus(n);
1093 dev = dev_prv->device;
1094 device_insertion_sort_klist(dev, &sorted_devices, compare);
1095 }
1096 list_splice(&sorted_devices, &device_klist->k_list);
1097 spin_unlock(&device_klist->k_lock);
1098}
1099EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
1114 struct device *start, const struct device_type *type)
1115{
1116 struct klist_node *start_knode = NULL;
1117
1118 if (start)
1119 start_knode = &start->p->knode_bus;
1120 klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode);
1121 iter->type = type;
1122}
1123EXPORT_SYMBOL_GPL(subsys_dev_iter_init);
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)
1138{
1139 struct klist_node *knode;
1140 struct device *dev;
1141
1142 for (;;) {
1143 knode = klist_next(&iter->ki);
1144 if (!knode)
1145 return NULL;
1146 dev = container_of(knode, struct device_private, knode_bus)->device;
1147 if (!iter->type || iter->type == dev->type)
1148 return dev;
1149 }
1150}
1151EXPORT_SYMBOL_GPL(subsys_dev_iter_next);
1152
1153
1154
1155
1156
1157
1158
1159
1160void subsys_dev_iter_exit(struct subsys_dev_iter *iter)
1161{
1162 klist_iter_exit(&iter->ki);
1163}
1164EXPORT_SYMBOL_GPL(subsys_dev_iter_exit);
1165
1166int subsys_interface_register(struct subsys_interface *sif)
1167{
1168 struct bus_type *subsys;
1169 struct subsys_dev_iter iter;
1170 struct device *dev;
1171
1172 if (!sif || !sif->subsys)
1173 return -ENODEV;
1174
1175 subsys = bus_get(sif->subsys);
1176 if (!subsys)
1177 return -EINVAL;
1178
1179 mutex_lock(&subsys->p->mutex);
1180 list_add_tail(&sif->node, &subsys->p->interfaces);
1181 if (sif->add_dev) {
1182 subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1183 while ((dev = subsys_dev_iter_next(&iter)))
1184 sif->add_dev(dev, sif);
1185 subsys_dev_iter_exit(&iter);
1186 }
1187 mutex_unlock(&subsys->p->mutex);
1188
1189 return 0;
1190}
1191EXPORT_SYMBOL_GPL(subsys_interface_register);
1192
1193void subsys_interface_unregister(struct subsys_interface *sif)
1194{
1195 struct bus_type *subsys;
1196 struct subsys_dev_iter iter;
1197 struct device *dev;
1198
1199 if (!sif || !sif->subsys)
1200 return;
1201
1202 subsys = sif->subsys;
1203
1204 mutex_lock(&subsys->p->mutex);
1205 list_del_init(&sif->node);
1206 if (sif->remove_dev) {
1207 subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1208 while ((dev = subsys_dev_iter_next(&iter)))
1209 sif->remove_dev(dev, sif);
1210 subsys_dev_iter_exit(&iter);
1211 }
1212 mutex_unlock(&subsys->p->mutex);
1213
1214 bus_put(subsys);
1215}
1216EXPORT_SYMBOL_GPL(subsys_interface_unregister);
1217
1218static void system_root_device_release(struct device *dev)
1219{
1220 kfree(dev);
1221}
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240int subsys_system_register(struct bus_type *subsys,
1241 const struct attribute_group **groups)
1242{
1243 struct device *dev;
1244 int err;
1245
1246 err = bus_register(subsys);
1247 if (err < 0)
1248 return err;
1249
1250 dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1251 if (!dev) {
1252 err = -ENOMEM;
1253 goto err_dev;
1254 }
1255
1256 err = dev_set_name(dev, "%s", subsys->name);
1257 if (err < 0)
1258 goto err_name;
1259
1260 dev->kobj.parent = &system_kset->kobj;
1261 dev->groups = groups;
1262 dev->release = system_root_device_release;
1263
1264 err = device_register(dev);
1265 if (err < 0)
1266 goto err_dev_reg;
1267
1268 subsys->dev_root = dev;
1269 return 0;
1270
1271err_dev_reg:
1272 put_device(dev);
1273 dev = NULL;
1274err_name:
1275 kfree(dev);
1276err_dev:
1277 bus_unregister(subsys);
1278 return err;
1279}
1280EXPORT_SYMBOL_GPL(subsys_system_register);
1281
1282int __init buses_init(void)
1283{
1284 bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
1285 if (!bus_kset)
1286 return -ENOMEM;
1287
1288 system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
1289 if (!system_kset)
1290 return -ENOMEM;
1291
1292 return 0;
1293}
1294