[SCSI] drivers/base/bus.c - export reprobe
[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         put_device(dev);
193         put_bus(bus);
194         return err;
195 }
196 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
197
198 #endif
199
200 static struct device * next_device(struct klist_iter * i)
201 {
202         struct klist_node * n = klist_next(i);
203         return n ? container_of(n, struct device, knode_bus) : NULL;
204 }
205
206 /**
207  *      bus_for_each_dev - device iterator.
208  *      @bus:   bus type.
209  *      @start: device to start iterating from.
210  *      @data:  data for the callback.
211  *      @fn:    function to be called for each device.
212  *
213  *      Iterate over @bus's list of devices, and call @fn for each,
214  *      passing it @data. If @start is not NULL, we use that device to
215  *      begin iterating from.
216  *
217  *      We check the return of @fn each time. If it returns anything
218  *      other than 0, we break out and return that value.
219  *
220  *      NOTE: The device that returns a non-zero value is not retained
221  *      in any way, nor is its refcount incremented. If the caller needs
222  *      to retain this data, it should do, and increment the reference
223  *      count in the supplied callback.
224  */
225
226 int bus_for_each_dev(struct bus_type * bus, struct device * start,
227                      void * data, int (*fn)(struct device *, void *))
228 {
229         struct klist_iter i;
230         struct device * dev;
231         int error = 0;
232
233         if (!bus)
234                 return -EINVAL;
235
236         klist_iter_init_node(&bus->klist_devices, &i,
237                              (start ? &start->knode_bus : NULL));
238         while ((dev = next_device(&i)) && !error)
239                 error = fn(dev, data);
240         klist_iter_exit(&i);
241         return error;
242 }
243
244 /**
245  * bus_find_device - device iterator for locating a particular device.
246  * @bus: bus type
247  * @start: Device to begin with
248  * @data: Data to pass to match function
249  * @match: Callback function to check device
250  *
251  * This is similar to the bus_for_each_dev() function above, but it
252  * returns a reference to a device that is 'found' for later use, as
253  * determined by the @match callback.
254  *
255  * The callback should return 0 if the device doesn't match and non-zero
256  * if it does.  If the callback returns non-zero, this function will
257  * return to the caller and not iterate over any more devices.
258  */
259 struct device * bus_find_device(struct bus_type *bus,
260                                 struct device *start, void *data,
261                                 int (*match)(struct device *, void *))
262 {
263         struct klist_iter i;
264         struct device *dev;
265
266         if (!bus)
267                 return NULL;
268
269         klist_iter_init_node(&bus->klist_devices, &i,
270                              (start ? &start->knode_bus : NULL));
271         while ((dev = next_device(&i)))
272                 if (match(dev, data) && get_device(dev))
273                         break;
274         klist_iter_exit(&i);
275         return dev;
276 }
277
278
279 static struct device_driver * next_driver(struct klist_iter * i)
280 {
281         struct klist_node * n = klist_next(i);
282         return n ? container_of(n, struct device_driver, knode_bus) : NULL;
283 }
284
285 /**
286  *      bus_for_each_drv - driver iterator
287  *      @bus:   bus we're dealing with.
288  *      @start: driver to start iterating on.
289  *      @data:  data to pass to the callback.
290  *      @fn:    function to call for each driver.
291  *
292  *      This is nearly identical to the device iterator above.
293  *      We iterate over each driver that belongs to @bus, and call
294  *      @fn for each. If @fn returns anything but 0, we break out
295  *      and return it. If @start is not NULL, we use it as the head
296  *      of the list.
297  *
298  *      NOTE: we don't return the driver that returns a non-zero
299  *      value, nor do we leave the reference count incremented for that
300  *      driver. If the caller needs to know that info, it must set it
301  *      in the callback. It must also be sure to increment the refcount
302  *      so it doesn't disappear before returning to the caller.
303  */
304
305 int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
306                      void * data, int (*fn)(struct device_driver *, void *))
307 {
308         struct klist_iter i;
309         struct device_driver * drv;
310         int error = 0;
311
312         if (!bus)
313                 return -EINVAL;
314
315         klist_iter_init_node(&bus->klist_drivers, &i,
316                              start ? &start->knode_bus : NULL);
317         while ((drv = next_driver(&i)) && !error)
318                 error = fn(drv, data);
319         klist_iter_exit(&i);
320         return error;
321 }
322
323 static int device_add_attrs(struct bus_type * bus, struct device * dev)
324 {
325         int error = 0;
326         int i;
327
328         if (bus->dev_attrs) {
329                 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
330                         error = device_create_file(dev,&bus->dev_attrs[i]);
331                         if (error)
332                                 goto Err;
333                 }
334         }
335  Done:
336         return error;
337  Err:
338         while (--i >= 0)
339                 device_remove_file(dev,&bus->dev_attrs[i]);
340         goto Done;
341 }
342
343
344 static void device_remove_attrs(struct bus_type * bus, struct device * dev)
345 {
346         int i;
347
348         if (bus->dev_attrs) {
349                 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
350                         device_remove_file(dev,&bus->dev_attrs[i]);
351         }
352 }
353
354
355 /**
356  *      bus_add_device - add device to bus
357  *      @dev:   device being added
358  *
359  *      - Add the device to its bus's list of devices.
360  *      - Try to attach to driver.
361  *      - Create link to device's physical location.
362  */
363 int bus_add_device(struct device * dev)
364 {
365         struct bus_type * bus = get_bus(dev->bus);
366         int error = 0;
367
368         if (bus) {
369                 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
370                 device_attach(dev);
371                 klist_add_tail(&dev->knode_bus, &bus->klist_devices);
372                 error = device_add_attrs(bus, dev);
373                 if (!error) {
374                         sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
375                         sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus");
376                 }
377         }
378         return error;
379 }
380
381 /**
382  *      bus_remove_device - remove device from bus
383  *      @dev:   device to be removed
384  *
385  *      - Remove symlink from bus's directory.
386  *      - Delete device from bus's list.
387  *      - Detach from its driver.
388  *      - Drop reference taken in bus_add_device().
389  */
390 void bus_remove_device(struct device * dev)
391 {
392         if (dev->bus) {
393                 sysfs_remove_link(&dev->kobj, "bus");
394                 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
395                 device_remove_attrs(dev->bus, dev);
396                 klist_remove(&dev->knode_bus);
397                 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
398                 device_release_driver(dev);
399                 put_bus(dev->bus);
400         }
401 }
402
403 static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv)
404 {
405         int error = 0;
406         int i;
407
408         if (bus->drv_attrs) {
409                 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
410                         error = driver_create_file(drv, &bus->drv_attrs[i]);
411                         if (error)
412                                 goto Err;
413                 }
414         }
415  Done:
416         return error;
417  Err:
418         while (--i >= 0)
419                 driver_remove_file(drv, &bus->drv_attrs[i]);
420         goto Done;
421 }
422
423
424 static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv)
425 {
426         int i;
427
428         if (bus->drv_attrs) {
429                 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
430                         driver_remove_file(drv, &bus->drv_attrs[i]);
431         }
432 }
433
434 #ifdef CONFIG_HOTPLUG
435 /*
436  * Thanks to drivers making their tables __devinit, we can't allow manual
437  * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
438  */
439 static void add_bind_files(struct device_driver *drv)
440 {
441         driver_create_file(drv, &driver_attr_unbind);
442         driver_create_file(drv, &driver_attr_bind);
443 }
444
445 static void remove_bind_files(struct device_driver *drv)
446 {
447         driver_remove_file(drv, &driver_attr_bind);
448         driver_remove_file(drv, &driver_attr_unbind);
449 }
450 #else
451 static inline void add_bind_files(struct device_driver *drv) {}
452 static inline void remove_bind_files(struct device_driver *drv) {}
453 #endif
454
455 /**
456  *      bus_add_driver - Add a driver to the bus.
457  *      @drv:   driver.
458  *
459  */
460 int bus_add_driver(struct device_driver * drv)
461 {
462         struct bus_type * bus = get_bus(drv->bus);
463         int error = 0;
464
465         if (bus) {
466                 pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
467                 error = kobject_set_name(&drv->kobj, "%s", drv->name);
468                 if (error) {
469                         put_bus(bus);
470                         return error;
471                 }
472                 drv->kobj.kset = &bus->drivers;
473                 if ((error = kobject_register(&drv->kobj))) {
474                         put_bus(bus);
475                         return error;
476                 }
477
478                 driver_attach(drv);
479                 klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
480                 module_add_driver(drv->owner, drv);
481
482                 driver_add_attrs(bus, drv);
483                 add_bind_files(drv);
484         }
485         return error;
486 }
487
488
489 /**
490  *      bus_remove_driver - delete driver from bus's knowledge.
491  *      @drv:   driver.
492  *
493  *      Detach the driver from the devices it controls, and remove
494  *      it from its bus's list of drivers. Finally, we drop the reference
495  *      to the bus we took in bus_add_driver().
496  */
497
498 void bus_remove_driver(struct device_driver * drv)
499 {
500         if (drv->bus) {
501                 remove_bind_files(drv);
502                 driver_remove_attrs(drv->bus, drv);
503                 klist_remove(&drv->knode_bus);
504                 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
505                 driver_detach(drv);
506                 module_remove_driver(drv);
507                 kobject_unregister(&drv->kobj);
508                 put_bus(drv->bus);
509         }
510 }
511
512
513 /* Helper for bus_rescan_devices's iter */
514 static int bus_rescan_devices_helper(struct device *dev, void *data)
515 {
516         if (!dev->driver) {
517                 if (dev->parent)        /* Needed for USB */
518                         down(&dev->parent->sem);
519                 device_attach(dev);
520                 if (dev->parent)
521                         up(&dev->parent->sem);
522         }
523         return 0;
524 }
525
526 /**
527  * bus_rescan_devices - rescan devices on the bus for possible drivers
528  * @bus: the bus to scan.
529  *
530  * This function will look for devices on the bus with no driver
531  * attached and rescan it against existing drivers to see if it matches
532  * any by calling device_attach() for the unbound devices.
533  */
534 void bus_rescan_devices(struct bus_type * bus)
535 {
536         bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
537 }
538
539 /**
540  * device_reprobe - remove driver for a device and probe for a new driver
541  * @dev: the device to reprobe
542  *
543  * This function detaches the attached driver (if any) for the given
544  * device and restarts the driver probing process.  It is intended
545  * to use if probing criteria changed during a devices lifetime and
546  * driver attachment should change accordingly.
547  */
548 void device_reprobe(struct device *dev)
549 {
550         if (dev->driver) {
551                 if (dev->parent)        /* Needed for USB */
552                         down(&dev->parent->sem);
553                 device_release_driver(dev);
554                 if (dev->parent)
555                         up(&dev->parent->sem);
556         }
557
558         bus_rescan_devices_helper(dev, NULL);
559 }
560 EXPORT_SYMBOL_GPL(device_reprobe);
561
562 struct bus_type * get_bus(struct bus_type * bus)
563 {
564         return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL;
565 }
566
567 void put_bus(struct bus_type * bus)
568 {
569         subsys_put(&bus->subsys);
570 }
571
572
573 /**
574  *      find_bus - locate bus by name.
575  *      @name:  name of bus.
576  *
577  *      Call kset_find_obj() to iterate over list of buses to
578  *      find a bus by name. Return bus if found.
579  *
580  *      Note that kset_find_obj increments bus' reference count.
581  */
582
583 struct bus_type * find_bus(char * name)
584 {
585         struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
586         return k ? to_bus(k) : NULL;
587 }
588
589
590 /**
591  *      bus_add_attrs - Add default attributes for this bus.
592  *      @bus:   Bus that has just been registered.
593  */
594
595 static int bus_add_attrs(struct bus_type * bus)
596 {
597         int error = 0;
598         int i;
599
600         if (bus->bus_attrs) {
601                 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
602                         if ((error = bus_create_file(bus,&bus->bus_attrs[i])))
603                                 goto Err;
604                 }
605         }
606  Done:
607         return error;
608  Err:
609         while (--i >= 0)
610                 bus_remove_file(bus,&bus->bus_attrs[i]);
611         goto Done;
612 }
613
614 static void bus_remove_attrs(struct bus_type * bus)
615 {
616         int i;
617
618         if (bus->bus_attrs) {
619                 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
620                         bus_remove_file(bus,&bus->bus_attrs[i]);
621         }
622 }
623
624 static void klist_devices_get(struct klist_node *n)
625 {
626         struct device *dev = container_of(n, struct device, knode_bus);
627
628         get_device(dev);
629 }
630
631 static void klist_devices_put(struct klist_node *n)
632 {
633         struct device *dev = container_of(n, struct device, knode_bus);
634
635         put_device(dev);
636 }
637
638 static void klist_drivers_get(struct klist_node *n)
639 {
640         struct device_driver *drv = container_of(n, struct device_driver,
641                                                  knode_bus);
642
643         get_driver(drv);
644 }
645
646 static void klist_drivers_put(struct klist_node *n)
647 {
648         struct device_driver *drv = container_of(n, struct device_driver,
649                                                  knode_bus);
650
651         put_driver(drv);
652 }
653
654 /**
655  *      bus_register - register a bus with the system.
656  *      @bus:   bus.
657  *
658  *      Once we have that, we registered the bus with the kobject
659  *      infrastructure, then register the children subsystems it has:
660  *      the devices and drivers that belong to the bus.
661  */
662 int bus_register(struct bus_type * bus)
663 {
664         int retval;
665
666         retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
667         if (retval)
668                 goto out;
669
670         subsys_set_kset(bus, bus_subsys);
671         retval = subsystem_register(&bus->subsys);
672         if (retval)
673                 goto out;
674
675         kobject_set_name(&bus->devices.kobj, "devices");
676         bus->devices.subsys = &bus->subsys;
677         retval = kset_register(&bus->devices);
678         if (retval)
679                 goto bus_devices_fail;
680
681         kobject_set_name(&bus->drivers.kobj, "drivers");
682         bus->drivers.subsys = &bus->subsys;
683         bus->drivers.ktype = &ktype_driver;
684         retval = kset_register(&bus->drivers);
685         if (retval)
686                 goto bus_drivers_fail;
687
688         klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
689         klist_init(&bus->klist_drivers, klist_drivers_get, klist_drivers_put);
690         bus_add_attrs(bus);
691
692         pr_debug("bus type '%s' registered\n", bus->name);
693         return 0;
694
695 bus_drivers_fail:
696         kset_unregister(&bus->devices);
697 bus_devices_fail:
698         subsystem_unregister(&bus->subsys);
699 out:
700         return retval;
701 }
702
703
704 /**
705  *      bus_unregister - remove a bus from the system
706  *      @bus:   bus.
707  *
708  *      Unregister the child subsystems and the bus itself.
709  *      Finally, we call put_bus() to release the refcount
710  */
711 void bus_unregister(struct bus_type * bus)
712 {
713         pr_debug("bus %s: unregistering\n", bus->name);
714         bus_remove_attrs(bus);
715         kset_unregister(&bus->drivers);
716         kset_unregister(&bus->devices);
717         subsystem_unregister(&bus->subsys);
718 }
719
720 int __init buses_init(void)
721 {
722         return subsystem_register(&bus_subsys);
723 }
724
725
726 EXPORT_SYMBOL_GPL(bus_for_each_dev);
727 EXPORT_SYMBOL_GPL(bus_find_device);
728 EXPORT_SYMBOL_GPL(bus_for_each_drv);
729
730 EXPORT_SYMBOL_GPL(bus_add_device);
731 EXPORT_SYMBOL_GPL(bus_remove_device);
732 EXPORT_SYMBOL_GPL(bus_register);
733 EXPORT_SYMBOL_GPL(bus_unregister);
734 EXPORT_SYMBOL_GPL(bus_rescan_devices);
735 EXPORT_SYMBOL_GPL(get_bus);
736 EXPORT_SYMBOL_GPL(put_bus);
737 EXPORT_SYMBOL_GPL(find_bus);
738
739 EXPORT_SYMBOL_GPL(bus_create_file);
740 EXPORT_SYMBOL_GPL(bus_remove_file);