[PATCH] Driver Core: remove unused exports
[linux-2.6.git] / 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  *      - Create link to device's bus.
366  */
367 int bus_add_device(struct device * dev)
368 {
369         struct bus_type * bus = get_bus(dev->bus);
370         int error = 0;
371
372         if (bus) {
373                 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
374                 error = device_add_attrs(bus, dev);
375                 if (!error) {
376                         sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
377                         sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus");
378                 }
379         }
380         return error;
381 }
382
383 /**
384  *      bus_attach_device - add device to bus
385  *      @dev:   device tried to attach to a driver
386  *
387  *      - Try to attach to driver.
388  */
389 void bus_attach_device(struct device * dev)
390 {
391         struct bus_type * bus = dev->bus;
392
393         if (bus) {
394                 device_attach(dev);
395                 klist_add_tail(&dev->knode_bus, &bus->klist_devices);
396         }
397 }
398
399 /**
400  *      bus_remove_device - remove device from bus
401  *      @dev:   device to be removed
402  *
403  *      - Remove symlink from bus's directory.
404  *      - Delete device from bus's list.
405  *      - Detach from its driver.
406  *      - Drop reference taken in bus_add_device().
407  */
408 void bus_remove_device(struct device * dev)
409 {
410         if (dev->bus) {
411                 sysfs_remove_link(&dev->kobj, "bus");
412                 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
413                 device_remove_attrs(dev->bus, dev);
414                 klist_remove(&dev->knode_bus);
415                 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
416                 device_release_driver(dev);
417                 put_bus(dev->bus);
418         }
419 }
420
421 static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv)
422 {
423         int error = 0;
424         int i;
425
426         if (bus->drv_attrs) {
427                 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
428                         error = driver_create_file(drv, &bus->drv_attrs[i]);
429                         if (error)
430                                 goto Err;
431                 }
432         }
433  Done:
434         return error;
435  Err:
436         while (--i >= 0)
437                 driver_remove_file(drv, &bus->drv_attrs[i]);
438         goto Done;
439 }
440
441
442 static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv)
443 {
444         int i;
445
446         if (bus->drv_attrs) {
447                 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
448                         driver_remove_file(drv, &bus->drv_attrs[i]);
449         }
450 }
451
452 #ifdef CONFIG_HOTPLUG
453 /*
454  * Thanks to drivers making their tables __devinit, we can't allow manual
455  * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
456  */
457 static void add_bind_files(struct device_driver *drv)
458 {
459         driver_create_file(drv, &driver_attr_unbind);
460         driver_create_file(drv, &driver_attr_bind);
461 }
462
463 static void remove_bind_files(struct device_driver *drv)
464 {
465         driver_remove_file(drv, &driver_attr_bind);
466         driver_remove_file(drv, &driver_attr_unbind);
467 }
468 #else
469 static inline void add_bind_files(struct device_driver *drv) {}
470 static inline void remove_bind_files(struct device_driver *drv) {}
471 #endif
472
473 /**
474  *      bus_add_driver - Add a driver to the bus.
475  *      @drv:   driver.
476  *
477  */
478 int bus_add_driver(struct device_driver * drv)
479 {
480         struct bus_type * bus = get_bus(drv->bus);
481         int error = 0;
482
483         if (bus) {
484                 pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
485                 error = kobject_set_name(&drv->kobj, "%s", drv->name);
486                 if (error) {
487                         put_bus(bus);
488                         return error;
489                 }
490                 drv->kobj.kset = &bus->drivers;
491                 if ((error = kobject_register(&drv->kobj))) {
492                         put_bus(bus);
493                         return error;
494                 }
495
496                 driver_attach(drv);
497                 klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
498                 module_add_driver(drv->owner, drv);
499
500                 driver_add_attrs(bus, drv);
501                 add_bind_files(drv);
502         }
503         return error;
504 }
505
506
507 /**
508  *      bus_remove_driver - delete driver from bus's knowledge.
509  *      @drv:   driver.
510  *
511  *      Detach the driver from the devices it controls, and remove
512  *      it from its bus's list of drivers. Finally, we drop the reference
513  *      to the bus we took in bus_add_driver().
514  */
515
516 void bus_remove_driver(struct device_driver * drv)
517 {
518         if (drv->bus) {
519                 remove_bind_files(drv);
520                 driver_remove_attrs(drv->bus, drv);
521                 klist_remove(&drv->knode_bus);
522                 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
523                 driver_detach(drv);
524                 module_remove_driver(drv);
525                 kobject_unregister(&drv->kobj);
526                 put_bus(drv->bus);
527         }
528 }
529
530
531 /* Helper for bus_rescan_devices's iter */
532 static int bus_rescan_devices_helper(struct device *dev, void *data)
533 {
534         if (!dev->driver) {
535                 if (dev->parent)        /* Needed for USB */
536                         down(&dev->parent->sem);
537                 device_attach(dev);
538                 if (dev->parent)
539                         up(&dev->parent->sem);
540         }
541         return 0;
542 }
543
544 /**
545  * bus_rescan_devices - rescan devices on the bus for possible drivers
546  * @bus: the bus to scan.
547  *
548  * This function will look for devices on the bus with no driver
549  * attached and rescan it against existing drivers to see if it matches
550  * any by calling device_attach() for the unbound devices.
551  */
552 void bus_rescan_devices(struct bus_type * bus)
553 {
554         bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
555 }
556
557 /**
558  * device_reprobe - remove driver for a device and probe for a new driver
559  * @dev: the device to reprobe
560  *
561  * This function detaches the attached driver (if any) for the given
562  * device and restarts the driver probing process.  It is intended
563  * to use if probing criteria changed during a devices lifetime and
564  * driver attachment should change accordingly.
565  */
566 void device_reprobe(struct device *dev)
567 {
568         if (dev->driver) {
569                 if (dev->parent)        /* Needed for USB */
570                         down(&dev->parent->sem);
571                 device_release_driver(dev);
572                 if (dev->parent)
573                         up(&dev->parent->sem);
574         }
575
576         bus_rescan_devices_helper(dev, NULL);
577 }
578 EXPORT_SYMBOL_GPL(device_reprobe);
579
580 struct bus_type * get_bus(struct bus_type * bus)
581 {
582         return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL;
583 }
584
585 void put_bus(struct bus_type * bus)
586 {
587         subsys_put(&bus->subsys);
588 }
589
590
591 /**
592  *      find_bus - locate bus by name.
593  *      @name:  name of bus.
594  *
595  *      Call kset_find_obj() to iterate over list of buses to
596  *      find a bus by name. Return bus if found.
597  *
598  *      Note that kset_find_obj increments bus' reference count.
599  */
600
601 struct bus_type * find_bus(char * name)
602 {
603         struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
604         return k ? to_bus(k) : NULL;
605 }
606
607
608 /**
609  *      bus_add_attrs - Add default attributes for this bus.
610  *      @bus:   Bus that has just been registered.
611  */
612
613 static int bus_add_attrs(struct bus_type * bus)
614 {
615         int error = 0;
616         int i;
617
618         if (bus->bus_attrs) {
619                 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
620                         if ((error = bus_create_file(bus,&bus->bus_attrs[i])))
621                                 goto Err;
622                 }
623         }
624  Done:
625         return error;
626  Err:
627         while (--i >= 0)
628                 bus_remove_file(bus,&bus->bus_attrs[i]);
629         goto Done;
630 }
631
632 static void bus_remove_attrs(struct bus_type * bus)
633 {
634         int i;
635
636         if (bus->bus_attrs) {
637                 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
638                         bus_remove_file(bus,&bus->bus_attrs[i]);
639         }
640 }
641
642 static void klist_devices_get(struct klist_node *n)
643 {
644         struct device *dev = container_of(n, struct device, knode_bus);
645
646         get_device(dev);
647 }
648
649 static void klist_devices_put(struct klist_node *n)
650 {
651         struct device *dev = container_of(n, struct device, knode_bus);
652
653         put_device(dev);
654 }
655
656 static void klist_drivers_get(struct klist_node *n)
657 {
658         struct device_driver *drv = container_of(n, struct device_driver,
659                                                  knode_bus);
660
661         get_driver(drv);
662 }
663
664 static void klist_drivers_put(struct klist_node *n)
665 {
666         struct device_driver *drv = container_of(n, struct device_driver,
667                                                  knode_bus);
668
669         put_driver(drv);
670 }
671
672 /**
673  *      bus_register - register a bus with the system.
674  *      @bus:   bus.
675  *
676  *      Once we have that, we registered the bus with the kobject
677  *      infrastructure, then register the children subsystems it has:
678  *      the devices and drivers that belong to the bus.
679  */
680 int bus_register(struct bus_type * bus)
681 {
682         int retval;
683
684         retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
685         if (retval)
686                 goto out;
687
688         subsys_set_kset(bus, bus_subsys);
689         retval = subsystem_register(&bus->subsys);
690         if (retval)
691                 goto out;
692
693         kobject_set_name(&bus->devices.kobj, "devices");
694         bus->devices.subsys = &bus->subsys;
695         retval = kset_register(&bus->devices);
696         if (retval)
697                 goto bus_devices_fail;
698
699         kobject_set_name(&bus->drivers.kobj, "drivers");
700         bus->drivers.subsys = &bus->subsys;
701         bus->drivers.ktype = &ktype_driver;
702         retval = kset_register(&bus->drivers);
703         if (retval)
704                 goto bus_drivers_fail;
705
706         klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
707         klist_init(&bus->klist_drivers, klist_drivers_get, klist_drivers_put);
708         bus_add_attrs(bus);
709
710         pr_debug("bus type '%s' registered\n", bus->name);
711         return 0;
712
713 bus_drivers_fail:
714         kset_unregister(&bus->devices);
715 bus_devices_fail:
716         subsystem_unregister(&bus->subsys);
717 out:
718         return retval;
719 }
720
721
722 /**
723  *      bus_unregister - remove a bus from the system
724  *      @bus:   bus.
725  *
726  *      Unregister the child subsystems and the bus itself.
727  *      Finally, we call put_bus() to release the refcount
728  */
729 void bus_unregister(struct bus_type * bus)
730 {
731         pr_debug("bus %s: unregistering\n", bus->name);
732         bus_remove_attrs(bus);
733         kset_unregister(&bus->drivers);
734         kset_unregister(&bus->devices);
735         subsystem_unregister(&bus->subsys);
736 }
737
738 int __init buses_init(void)
739 {
740         return subsystem_register(&bus_subsys);
741 }
742
743
744 EXPORT_SYMBOL_GPL(bus_for_each_dev);
745 EXPORT_SYMBOL_GPL(bus_find_device);
746 EXPORT_SYMBOL_GPL(bus_for_each_drv);
747
748 EXPORT_SYMBOL_GPL(bus_register);
749 EXPORT_SYMBOL_GPL(bus_unregister);
750 EXPORT_SYMBOL_GPL(bus_rescan_devices);
751
752 EXPORT_SYMBOL_GPL(bus_create_file);
753 EXPORT_SYMBOL_GPL(bus_remove_file);