Pull bugzilla-5653 into release branch
[linux-2.6] / drivers / base / bus.c
1 /*
2  * bus.c - bus driver management
3  *
4  * Copyright (c) 2002-3 Patrick Mochel
5  * Copyright (c) 2002-3 Open Source Development Labs
6  *
7  * This file is released under the GPLv2
8  *
9  */
10
11 #include <linux/config.h>
12 #include <linux/device.h>
13 #include <linux/module.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/string.h>
17 #include "base.h"
18 #include "power/power.h"
19
20 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
21 #define to_bus(obj) container_of(obj, struct bus_type, subsys.kset.kobj)
22
23 /*
24  * sysfs bindings for drivers
25  */
26
27 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
28 #define to_driver(obj) container_of(obj, struct device_driver, kobj)
29
30
31 static ssize_t
32 drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
33 {
34         struct driver_attribute * drv_attr = to_drv_attr(attr);
35         struct device_driver * drv = to_driver(kobj);
36         ssize_t ret = -EIO;
37
38         if (drv_attr->show)
39                 ret = drv_attr->show(drv, buf);
40         return ret;
41 }
42
43 static ssize_t
44 drv_attr_store(struct kobject * kobj, struct attribute * attr,
45                const char * buf, size_t count)
46 {
47         struct driver_attribute * drv_attr = to_drv_attr(attr);
48         struct device_driver * drv = to_driver(kobj);
49         ssize_t ret = -EIO;
50
51         if (drv_attr->store)
52                 ret = drv_attr->store(drv, buf, count);
53         return ret;
54 }
55
56 static struct sysfs_ops driver_sysfs_ops = {
57         .show   = drv_attr_show,
58         .store  = drv_attr_store,
59 };
60
61
62 static void driver_release(struct kobject * kobj)
63 {
64         struct device_driver * drv = to_driver(kobj);
65         complete(&drv->unloaded);
66 }
67
68 static struct kobj_type ktype_driver = {
69         .sysfs_ops      = &driver_sysfs_ops,
70         .release        = driver_release,
71 };
72
73
74 /*
75  * sysfs bindings for buses
76  */
77
78
79 static ssize_t
80 bus_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
81 {
82         struct bus_attribute * bus_attr = to_bus_attr(attr);
83         struct bus_type * bus = to_bus(kobj);
84         ssize_t ret = 0;
85
86         if (bus_attr->show)
87                 ret = bus_attr->show(bus, buf);
88         return ret;
89 }
90
91 static ssize_t
92 bus_attr_store(struct kobject * kobj, struct attribute * attr,
93                const char * buf, size_t count)
94 {
95         struct bus_attribute * bus_attr = to_bus_attr(attr);
96         struct bus_type * bus = to_bus(kobj);
97         ssize_t ret = 0;
98
99         if (bus_attr->store)
100                 ret = bus_attr->store(bus, buf, count);
101         return ret;
102 }
103
104 static struct sysfs_ops bus_sysfs_ops = {
105         .show   = bus_attr_show,
106         .store  = bus_attr_store,
107 };
108
109 int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
110 {
111         int error;
112         if (get_bus(bus)) {
113                 error = sysfs_create_file(&bus->subsys.kset.kobj, &attr->attr);
114                 put_bus(bus);
115         } else
116                 error = -EINVAL;
117         return error;
118 }
119
120 void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr)
121 {
122         if (get_bus(bus)) {
123                 sysfs_remove_file(&bus->subsys.kset.kobj, &attr->attr);
124                 put_bus(bus);
125         }
126 }
127
128 static struct kobj_type ktype_bus = {
129         .sysfs_ops      = &bus_sysfs_ops,
130
131 };
132
133 decl_subsys(bus, &ktype_bus, NULL);
134
135
136 #ifdef CONFIG_HOTPLUG
137
138 /* Manually detach a device from its associated driver. */
139 static int driver_helper(struct device *dev, void *data)
140 {
141         const char *name = data;
142
143         if (strcmp(name, dev->bus_id) == 0)
144                 return 1;
145         return 0;
146 }
147
148 static ssize_t driver_unbind(struct device_driver *drv,
149                              const char *buf, size_t count)
150 {
151         struct bus_type *bus = get_bus(drv->bus);
152         struct device *dev;
153         int err = -ENODEV;
154
155         dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
156         if (dev && dev->driver == drv) {
157                 if (dev->parent)        /* Needed for USB */
158                         down(&dev->parent->sem);
159                 device_release_driver(dev);
160                 if (dev->parent)
161                         up(&dev->parent->sem);
162                 err = count;
163         }
164         put_device(dev);
165         put_bus(bus);
166         return err;
167 }
168 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
169
170 /*
171  * Manually attach a device to a driver.
172  * Note: the driver must want to bind to the device,
173  * it is not possible to override the driver's id table.
174  */
175 static ssize_t driver_bind(struct device_driver *drv,
176                            const char *buf, size_t count)
177 {
178         struct bus_type *bus = get_bus(drv->bus);
179         struct device *dev;
180         int err = -ENODEV;
181
182         dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
183         if (dev && dev->driver == NULL) {
184                 if (dev->parent)        /* Needed for USB */
185                         down(&dev->parent->sem);
186                 down(&dev->sem);
187                 err = driver_probe_device(drv, dev);
188                 up(&dev->sem);
189                 if (dev->parent)
190                         up(&dev->parent->sem);
191
192                 if (err > 0)            /* success */
193                         err = count;
194                 else if (err == 0)      /* driver didn't accept device */
195                         err = -ENODEV;
196         }
197         put_device(dev);
198         put_bus(bus);
199         return err;
200 }
201 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
202
203 #endif
204
205 static struct device * next_device(struct klist_iter * i)
206 {
207         struct klist_node * n = klist_next(i);
208         return n ? container_of(n, struct device, knode_bus) : NULL;
209 }
210
211 /**
212  *      bus_for_each_dev - device iterator.
213  *      @bus:   bus type.
214  *      @start: device to start iterating from.
215  *      @data:  data for the callback.
216  *      @fn:    function to be called for each device.
217  *
218  *      Iterate over @bus's list of devices, and call @fn for each,
219  *      passing it @data. If @start is not NULL, we use that device to
220  *      begin iterating from.
221  *
222  *      We check the return of @fn each time. If it returns anything
223  *      other than 0, we break out and return that value.
224  *
225  *      NOTE: The device that returns a non-zero value is not retained
226  *      in any way, nor is its refcount incremented. If the caller needs
227  *      to retain this data, it should do, and increment the reference
228  *      count in the supplied callback.
229  */
230
231 int bus_for_each_dev(struct bus_type * bus, struct device * start,
232                      void * data, int (*fn)(struct device *, void *))
233 {
234         struct klist_iter i;
235         struct device * dev;
236         int error = 0;
237
238         if (!bus)
239                 return -EINVAL;
240
241         klist_iter_init_node(&bus->klist_devices, &i,
242                              (start ? &start->knode_bus : NULL));
243         while ((dev = next_device(&i)) && !error)
244                 error = fn(dev, data);
245         klist_iter_exit(&i);
246         return error;
247 }
248
249 /**
250  * bus_find_device - device iterator for locating a particular device.
251  * @bus: bus type
252  * @start: Device to begin with
253  * @data: Data to pass to match function
254  * @match: Callback function to check device
255  *
256  * This is similar to the bus_for_each_dev() function above, but it
257  * returns a reference to a device that is 'found' for later use, as
258  * determined by the @match callback.
259  *
260  * The callback should return 0 if the device doesn't match and non-zero
261  * if it does.  If the callback returns non-zero, this function will
262  * return to the caller and not iterate over any more devices.
263  */
264 struct device * bus_find_device(struct bus_type *bus,
265                                 struct device *start, void *data,
266                                 int (*match)(struct device *, void *))
267 {
268         struct klist_iter i;
269         struct device *dev;
270
271         if (!bus)
272                 return NULL;
273
274         klist_iter_init_node(&bus->klist_devices, &i,
275                              (start ? &start->knode_bus : NULL));
276         while ((dev = next_device(&i)))
277                 if (match(dev, data) && get_device(dev))
278                         break;
279         klist_iter_exit(&i);
280         return dev;
281 }
282
283
284 static struct device_driver * next_driver(struct klist_iter * i)
285 {
286         struct klist_node * n = klist_next(i);
287         return n ? container_of(n, struct device_driver, knode_bus) : NULL;
288 }
289
290 /**
291  *      bus_for_each_drv - driver iterator
292  *      @bus:   bus we're dealing with.
293  *      @start: driver to start iterating on.
294  *      @data:  data to pass to the callback.
295  *      @fn:    function to call for each driver.
296  *
297  *      This is nearly identical to the device iterator above.
298  *      We iterate over each driver that belongs to @bus, and call
299  *      @fn for each. If @fn returns anything but 0, we break out
300  *      and return it. If @start is not NULL, we use it as the head
301  *      of the list.
302  *
303  *      NOTE: we don't return the driver that returns a non-zero
304  *      value, nor do we leave the reference count incremented for that
305  *      driver. If the caller needs to know that info, it must set it
306  *      in the callback. It must also be sure to increment the refcount
307  *      so it doesn't disappear before returning to the caller.
308  */
309
310 int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
311                      void * data, int (*fn)(struct device_driver *, void *))
312 {
313         struct klist_iter i;
314         struct device_driver * drv;
315         int error = 0;
316
317         if (!bus)
318                 return -EINVAL;
319
320         klist_iter_init_node(&bus->klist_drivers, &i,
321                              start ? &start->knode_bus : NULL);
322         while ((drv = next_driver(&i)) && !error)
323                 error = fn(drv, data);
324         klist_iter_exit(&i);
325         return error;
326 }
327
328 static int device_add_attrs(struct bus_type * bus, struct device * dev)
329 {
330         int error = 0;
331         int i;
332
333         if (bus->dev_attrs) {
334                 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
335                         error = device_create_file(dev,&bus->dev_attrs[i]);
336                         if (error)
337                                 goto Err;
338                 }
339         }
340  Done:
341         return error;
342  Err:
343         while (--i >= 0)
344                 device_remove_file(dev,&bus->dev_attrs[i]);
345         goto Done;
346 }
347
348
349 static void device_remove_attrs(struct bus_type * bus, struct device * dev)
350 {
351         int i;
352
353         if (bus->dev_attrs) {
354                 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
355                         device_remove_file(dev,&bus->dev_attrs[i]);
356         }
357 }
358
359
360 /**
361  *      bus_add_device - add device to bus
362  *      @dev:   device being added
363  *
364  *      - Add the device to its bus's list of devices.
365  *      - Try to attach to driver.
366  *      - Create link to device's physical location.
367  */
368 int bus_add_device(struct device * dev)
369 {
370         struct bus_type * bus = get_bus(dev->bus);
371         int error = 0;
372
373         if (bus) {
374                 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
375                 device_attach(dev);
376                 klist_add_tail(&dev->knode_bus, &bus->klist_devices);
377                 error = device_add_attrs(bus, dev);
378                 if (!error) {
379                         sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
380                         sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus");
381                 }
382         }
383         return error;
384 }
385
386 /**
387  *      bus_remove_device - remove device from bus
388  *      @dev:   device to be removed
389  *
390  *      - Remove symlink from bus's directory.
391  *      - Delete device from bus's list.
392  *      - Detach from its driver.
393  *      - Drop reference taken in bus_add_device().
394  */
395 void bus_remove_device(struct device * dev)
396 {
397         if (dev->bus) {
398                 sysfs_remove_link(&dev->kobj, "bus");
399                 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
400                 device_remove_attrs(dev->bus, dev);
401                 klist_remove(&dev->knode_bus);
402                 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
403                 device_release_driver(dev);
404                 put_bus(dev->bus);
405         }
406 }
407
408 static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv)
409 {
410         int error = 0;
411         int i;
412
413         if (bus->drv_attrs) {
414                 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
415                         error = driver_create_file(drv, &bus->drv_attrs[i]);
416                         if (error)
417                                 goto Err;
418                 }
419         }
420  Done:
421         return error;
422  Err:
423         while (--i >= 0)
424                 driver_remove_file(drv, &bus->drv_attrs[i]);
425         goto Done;
426 }
427
428
429 static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv)
430 {
431         int i;
432
433         if (bus->drv_attrs) {
434                 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
435                         driver_remove_file(drv, &bus->drv_attrs[i]);
436         }
437 }
438
439 #ifdef CONFIG_HOTPLUG
440 /*
441  * Thanks to drivers making their tables __devinit, we can't allow manual
442  * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
443  */
444 static void add_bind_files(struct device_driver *drv)
445 {
446         driver_create_file(drv, &driver_attr_unbind);
447         driver_create_file(drv, &driver_attr_bind);
448 }
449
450 static void remove_bind_files(struct device_driver *drv)
451 {
452         driver_remove_file(drv, &driver_attr_bind);
453         driver_remove_file(drv, &driver_attr_unbind);
454 }
455 #else
456 static inline void add_bind_files(struct device_driver *drv) {}
457 static inline void remove_bind_files(struct device_driver *drv) {}
458 #endif
459
460 /**
461  *      bus_add_driver - Add a driver to the bus.
462  *      @drv:   driver.
463  *
464  */
465 int bus_add_driver(struct device_driver * drv)
466 {
467         struct bus_type * bus = get_bus(drv->bus);
468         int error = 0;
469
470         if (bus) {
471                 pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
472                 error = kobject_set_name(&drv->kobj, "%s", drv->name);
473                 if (error) {
474                         put_bus(bus);
475                         return error;
476                 }
477                 drv->kobj.kset = &bus->drivers;
478                 if ((error = kobject_register(&drv->kobj))) {
479                         put_bus(bus);
480                         return error;
481                 }
482
483                 driver_attach(drv);
484                 klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
485                 module_add_driver(drv->owner, drv);
486
487                 driver_add_attrs(bus, drv);
488                 add_bind_files(drv);
489         }
490         return error;
491 }
492
493
494 /**
495  *      bus_remove_driver - delete driver from bus's knowledge.
496  *      @drv:   driver.
497  *
498  *      Detach the driver from the devices it controls, and remove
499  *      it from its bus's list of drivers. Finally, we drop the reference
500  *      to the bus we took in bus_add_driver().
501  */
502
503 void bus_remove_driver(struct device_driver * drv)
504 {
505         if (drv->bus) {
506                 remove_bind_files(drv);
507                 driver_remove_attrs(drv->bus, drv);
508                 klist_remove(&drv->knode_bus);
509                 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
510                 driver_detach(drv);
511                 module_remove_driver(drv);
512                 kobject_unregister(&drv->kobj);
513                 put_bus(drv->bus);
514         }
515 }
516
517
518 /* Helper for bus_rescan_devices's iter */
519 static int bus_rescan_devices_helper(struct device *dev, void *data)
520 {
521         if (!dev->driver) {
522                 if (dev->parent)        /* Needed for USB */
523                         down(&dev->parent->sem);
524                 device_attach(dev);
525                 if (dev->parent)
526                         up(&dev->parent->sem);
527         }
528         return 0;
529 }
530
531 /**
532  * bus_rescan_devices - rescan devices on the bus for possible drivers
533  * @bus: the bus to scan.
534  *
535  * This function will look for devices on the bus with no driver
536  * attached and rescan it against existing drivers to see if it matches
537  * any by calling device_attach() for the unbound devices.
538  */
539 void bus_rescan_devices(struct bus_type * bus)
540 {
541         bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
542 }
543
544 /**
545  * device_reprobe - remove driver for a device and probe for a new driver
546  * @dev: the device to reprobe
547  *
548  * This function detaches the attached driver (if any) for the given
549  * device and restarts the driver probing process.  It is intended
550  * to use if probing criteria changed during a devices lifetime and
551  * driver attachment should change accordingly.
552  */
553 void device_reprobe(struct device *dev)
554 {
555         if (dev->driver) {
556                 if (dev->parent)        /* Needed for USB */
557                         down(&dev->parent->sem);
558                 device_release_driver(dev);
559                 if (dev->parent)
560                         up(&dev->parent->sem);
561         }
562
563         bus_rescan_devices_helper(dev, NULL);
564 }
565 EXPORT_SYMBOL_GPL(device_reprobe);
566
567 struct bus_type * get_bus(struct bus_type * bus)
568 {
569         return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL;
570 }
571
572 void put_bus(struct bus_type * bus)
573 {
574         subsys_put(&bus->subsys);
575 }
576
577
578 /**
579  *      find_bus - locate bus by name.
580  *      @name:  name of bus.
581  *
582  *      Call kset_find_obj() to iterate over list of buses to
583  *      find a bus by name. Return bus if found.
584  *
585  *      Note that kset_find_obj increments bus' reference count.
586  */
587
588 struct bus_type * find_bus(char * name)
589 {
590         struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
591         return k ? to_bus(k) : NULL;
592 }
593
594
595 /**
596  *      bus_add_attrs - Add default attributes for this bus.
597  *      @bus:   Bus that has just been registered.
598  */
599
600 static int bus_add_attrs(struct bus_type * bus)
601 {
602         int error = 0;
603         int i;
604
605         if (bus->bus_attrs) {
606                 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
607                         if ((error = bus_create_file(bus,&bus->bus_attrs[i])))
608                                 goto Err;
609                 }
610         }
611  Done:
612         return error;
613  Err:
614         while (--i >= 0)
615                 bus_remove_file(bus,&bus->bus_attrs[i]);
616         goto Done;
617 }
618
619 static void bus_remove_attrs(struct bus_type * bus)
620 {
621         int i;
622
623         if (bus->bus_attrs) {
624                 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
625                         bus_remove_file(bus,&bus->bus_attrs[i]);
626         }
627 }
628
629 static void klist_devices_get(struct klist_node *n)
630 {
631         struct device *dev = container_of(n, struct device, knode_bus);
632
633         get_device(dev);
634 }
635
636 static void klist_devices_put(struct klist_node *n)
637 {
638         struct device *dev = container_of(n, struct device, knode_bus);
639
640         put_device(dev);
641 }
642
643 static void klist_drivers_get(struct klist_node *n)
644 {
645         struct device_driver *drv = container_of(n, struct device_driver,
646                                                  knode_bus);
647
648         get_driver(drv);
649 }
650
651 static void klist_drivers_put(struct klist_node *n)
652 {
653         struct device_driver *drv = container_of(n, struct device_driver,
654                                                  knode_bus);
655
656         put_driver(drv);
657 }
658
659 /**
660  *      bus_register - register a bus with the system.
661  *      @bus:   bus.
662  *
663  *      Once we have that, we registered the bus with the kobject
664  *      infrastructure, then register the children subsystems it has:
665  *      the devices and drivers that belong to the bus.
666  */
667 int bus_register(struct bus_type * bus)
668 {
669         int retval;
670
671         retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
672         if (retval)
673                 goto out;
674
675         subsys_set_kset(bus, bus_subsys);
676         retval = subsystem_register(&bus->subsys);
677         if (retval)
678                 goto out;
679
680         kobject_set_name(&bus->devices.kobj, "devices");
681         bus->devices.subsys = &bus->subsys;
682         retval = kset_register(&bus->devices);
683         if (retval)
684                 goto bus_devices_fail;
685
686         kobject_set_name(&bus->drivers.kobj, "drivers");
687         bus->drivers.subsys = &bus->subsys;
688         bus->drivers.ktype = &ktype_driver;
689         retval = kset_register(&bus->drivers);
690         if (retval)
691                 goto bus_drivers_fail;
692
693         klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
694         klist_init(&bus->klist_drivers, klist_drivers_get, klist_drivers_put);
695         bus_add_attrs(bus);
696
697         pr_debug("bus type '%s' registered\n", bus->name);
698         return 0;
699
700 bus_drivers_fail:
701         kset_unregister(&bus->devices);
702 bus_devices_fail:
703         subsystem_unregister(&bus->subsys);
704 out:
705         return retval;
706 }
707
708
709 /**
710  *      bus_unregister - remove a bus from the system
711  *      @bus:   bus.
712  *
713  *      Unregister the child subsystems and the bus itself.
714  *      Finally, we call put_bus() to release the refcount
715  */
716 void bus_unregister(struct bus_type * bus)
717 {
718         pr_debug("bus %s: unregistering\n", bus->name);
719         bus_remove_attrs(bus);
720         kset_unregister(&bus->drivers);
721         kset_unregister(&bus->devices);
722         subsystem_unregister(&bus->subsys);
723 }
724
725 int __init buses_init(void)
726 {
727         return subsystem_register(&bus_subsys);
728 }
729
730
731 EXPORT_SYMBOL_GPL(bus_for_each_dev);
732 EXPORT_SYMBOL_GPL(bus_find_device);
733 EXPORT_SYMBOL_GPL(bus_for_each_drv);
734
735 EXPORT_SYMBOL_GPL(bus_add_device);
736 EXPORT_SYMBOL_GPL(bus_remove_device);
737 EXPORT_SYMBOL_GPL(bus_register);
738 EXPORT_SYMBOL_GPL(bus_unregister);
739 EXPORT_SYMBOL_GPL(bus_rescan_devices);
740 EXPORT_SYMBOL_GPL(get_bus);
741 EXPORT_SYMBOL_GPL(put_bus);
742 EXPORT_SYMBOL_GPL(find_bus);
743
744 EXPORT_SYMBOL_GPL(bus_create_file);
745 EXPORT_SYMBOL_GPL(bus_remove_file);