[PATCH] Fix manual binding infinite loop
[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 /* Manually detach a device from it's associated driver. */
137 static int driver_helper(struct device *dev, void *data)
138 {
139         const char *name = data;
140
141         if (strcmp(name, dev->bus_id) == 0)
142                 return 1;
143         return 0;
144 }
145
146 static ssize_t driver_unbind(struct device_driver *drv,
147                              const char *buf, size_t count)
148 {
149         struct bus_type *bus = get_bus(drv->bus);
150         struct device *dev;
151         int err = -ENODEV;
152
153         dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
154         if ((dev) &&
155             (dev->driver == drv)) {
156                 device_release_driver(dev);
157                 err = count;
158         }
159         if (err)
160                 return err;
161         return count;
162 }
163 static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
164
165 /*
166  * Manually attach a device to a driver.
167  * Note: the driver must want to bind to the device,
168  * it is not possible to override the driver's id table.
169  */
170 static ssize_t driver_bind(struct device_driver *drv,
171                            const char *buf, size_t count)
172 {
173         struct bus_type *bus = get_bus(drv->bus);
174         struct device *dev;
175         int err = -ENODEV;
176
177         dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
178         if ((dev) &&
179             (dev->driver == NULL)) {
180                 down(&dev->sem);
181                 err = driver_probe_device(drv, dev);
182                 up(&dev->sem);
183                 put_device(dev);
184         }
185         if (err)
186                 return err;
187         return count;
188 }
189 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
190
191
192 static struct device * next_device(struct klist_iter * i)
193 {
194         struct klist_node * n = klist_next(i);
195         return n ? container_of(n, struct device, knode_bus) : NULL;
196 }
197
198 /**
199  *      bus_for_each_dev - device iterator.
200  *      @bus:   bus type.
201  *      @start: device to start iterating from.
202  *      @data:  data for the callback.
203  *      @fn:    function to be called for each device.
204  *
205  *      Iterate over @bus's list of devices, and call @fn for each,
206  *      passing it @data. If @start is not NULL, we use that device to
207  *      begin iterating from.
208  *
209  *      We check the return of @fn each time. If it returns anything
210  *      other than 0, we break out and return that value.
211  *
212  *      NOTE: The device that returns a non-zero value is not retained
213  *      in any way, nor is its refcount incremented. If the caller needs
214  *      to retain this data, it should do, and increment the reference
215  *      count in the supplied callback.
216  */
217
218 int bus_for_each_dev(struct bus_type * bus, struct device * start,
219                      void * data, int (*fn)(struct device *, void *))
220 {
221         struct klist_iter i;
222         struct device * dev;
223         int error = 0;
224
225         if (!bus)
226                 return -EINVAL;
227
228         klist_iter_init_node(&bus->klist_devices, &i,
229                              (start ? &start->knode_bus : NULL));
230         while ((dev = next_device(&i)) && !error)
231                 error = fn(dev, data);
232         klist_iter_exit(&i);
233         return error;
234 }
235
236 /**
237  * bus_find_device - device iterator for locating a particular device.
238  * @bus: bus type
239  * @start: Device to begin with
240  * @data: Data to pass to match function
241  * @match: Callback function to check device
242  *
243  * This is similar to the bus_for_each_dev() function above, but it
244  * returns a reference to a device that is 'found' for later use, as
245  * determined by the @match callback.
246  *
247  * The callback should return 0 if the device doesn't match and non-zero
248  * if it does.  If the callback returns non-zero, this function will
249  * return to the caller and not iterate over any more devices.
250  */
251 struct device * bus_find_device(struct bus_type *bus,
252                                 struct device *start, void *data,
253                                 int (*match)(struct device *, void *))
254 {
255         struct klist_iter i;
256         struct device *dev;
257
258         if (!bus)
259                 return NULL;
260
261         klist_iter_init_node(&bus->klist_devices, &i,
262                              (start ? &start->knode_bus : NULL));
263         while ((dev = next_device(&i)))
264                 if (match(dev, data) && get_device(dev))
265                         break;
266         klist_iter_exit(&i);
267         return dev;
268 }
269
270
271 static struct device_driver * next_driver(struct klist_iter * i)
272 {
273         struct klist_node * n = klist_next(i);
274         return n ? container_of(n, struct device_driver, knode_bus) : NULL;
275 }
276
277 /**
278  *      bus_for_each_drv - driver iterator
279  *      @bus:   bus we're dealing with.
280  *      @start: driver to start iterating on.
281  *      @data:  data to pass to the callback.
282  *      @fn:    function to call for each driver.
283  *
284  *      This is nearly identical to the device iterator above.
285  *      We iterate over each driver that belongs to @bus, and call
286  *      @fn for each. If @fn returns anything but 0, we break out
287  *      and return it. If @start is not NULL, we use it as the head
288  *      of the list.
289  *
290  *      NOTE: we don't return the driver that returns a non-zero
291  *      value, nor do we leave the reference count incremented for that
292  *      driver. If the caller needs to know that info, it must set it
293  *      in the callback. It must also be sure to increment the refcount
294  *      so it doesn't disappear before returning to the caller.
295  */
296
297 int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
298                      void * data, int (*fn)(struct device_driver *, void *))
299 {
300         struct klist_iter i;
301         struct device_driver * drv;
302         int error = 0;
303
304         if (!bus)
305                 return -EINVAL;
306
307         klist_iter_init_node(&bus->klist_drivers, &i,
308                              start ? &start->knode_bus : NULL);
309         while ((drv = next_driver(&i)) && !error)
310                 error = fn(drv, data);
311         klist_iter_exit(&i);
312         return error;
313 }
314
315 static int device_add_attrs(struct bus_type * bus, struct device * dev)
316 {
317         int error = 0;
318         int i;
319
320         if (bus->dev_attrs) {
321                 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
322                         error = device_create_file(dev,&bus->dev_attrs[i]);
323                         if (error)
324                                 goto Err;
325                 }
326         }
327  Done:
328         return error;
329  Err:
330         while (--i >= 0)
331                 device_remove_file(dev,&bus->dev_attrs[i]);
332         goto Done;
333 }
334
335
336 static void device_remove_attrs(struct bus_type * bus, struct device * dev)
337 {
338         int i;
339
340         if (bus->dev_attrs) {
341                 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
342                         device_remove_file(dev,&bus->dev_attrs[i]);
343         }
344 }
345
346
347 /**
348  *      bus_add_device - add device to bus
349  *      @dev:   device being added
350  *
351  *      - Add the device to its bus's list of devices.
352  *      - Try to attach to driver.
353  *      - Create link to device's physical location.
354  */
355 int bus_add_device(struct device * dev)
356 {
357         struct bus_type * bus = get_bus(dev->bus);
358         int error = 0;
359
360         if (bus) {
361                 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
362                 device_attach(dev);
363                 klist_add_tail(&bus->klist_devices, &dev->knode_bus);
364                 error = device_add_attrs(bus, dev);
365                 if (!error) {
366                         sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
367                         sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus");
368                 }
369         }
370         return error;
371 }
372
373 /**
374  *      bus_remove_device - remove device from bus
375  *      @dev:   device to be removed
376  *
377  *      - Remove symlink from bus's directory.
378  *      - Delete device from bus's list.
379  *      - Detach from its driver.
380  *      - Drop reference taken in bus_add_device().
381  */
382 void bus_remove_device(struct device * dev)
383 {
384         if (dev->bus) {
385                 sysfs_remove_link(&dev->kobj, "bus");
386                 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
387                 device_remove_attrs(dev->bus, dev);
388                 klist_remove(&dev->knode_bus);
389                 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
390                 device_release_driver(dev);
391                 put_bus(dev->bus);
392         }
393 }
394
395 static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv)
396 {
397         int error = 0;
398         int i;
399
400         if (bus->drv_attrs) {
401                 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
402                         error = driver_create_file(drv, &bus->drv_attrs[i]);
403                         if (error)
404                                 goto Err;
405                 }
406         }
407  Done:
408         return error;
409  Err:
410         while (--i >= 0)
411                 driver_remove_file(drv, &bus->drv_attrs[i]);
412         goto Done;
413 }
414
415
416 static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv)
417 {
418         int i;
419
420         if (bus->drv_attrs) {
421                 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
422                         driver_remove_file(drv, &bus->drv_attrs[i]);
423         }
424 }
425
426
427 /**
428  *      bus_add_driver - Add a driver to the bus.
429  *      @drv:   driver.
430  *
431  */
432 int bus_add_driver(struct device_driver * drv)
433 {
434         struct bus_type * bus = get_bus(drv->bus);
435         int error = 0;
436
437         if (bus) {
438                 pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
439                 error = kobject_set_name(&drv->kobj, "%s", drv->name);
440                 if (error) {
441                         put_bus(bus);
442                         return error;
443                 }
444                 drv->kobj.kset = &bus->drivers;
445                 if ((error = kobject_register(&drv->kobj))) {
446                         put_bus(bus);
447                         return error;
448                 }
449
450                 driver_attach(drv);
451                 klist_add_tail(&bus->klist_drivers, &drv->knode_bus);
452                 module_add_driver(drv->owner, drv);
453
454                 driver_add_attrs(bus, drv);
455                 driver_create_file(drv, &driver_attr_unbind);
456                 driver_create_file(drv, &driver_attr_bind);
457         }
458         return error;
459 }
460
461
462 /**
463  *      bus_remove_driver - delete driver from bus's knowledge.
464  *      @drv:   driver.
465  *
466  *      Detach the driver from the devices it controls, and remove
467  *      it from its bus's list of drivers. Finally, we drop the reference
468  *      to the bus we took in bus_add_driver().
469  */
470
471 void bus_remove_driver(struct device_driver * drv)
472 {
473         if (drv->bus) {
474                 driver_remove_file(drv, &driver_attr_bind);
475                 driver_remove_file(drv, &driver_attr_unbind);
476                 driver_remove_attrs(drv->bus, drv);
477                 klist_remove(&drv->knode_bus);
478                 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
479                 driver_detach(drv);
480                 module_remove_driver(drv);
481                 kobject_unregister(&drv->kobj);
482                 put_bus(drv->bus);
483         }
484 }
485
486
487 /* Helper for bus_rescan_devices's iter */
488 static int bus_rescan_devices_helper(struct device *dev, void *data)
489 {
490         if (!dev->driver)
491                 device_attach(dev);
492         return 0;
493 }
494
495 /**
496  * bus_rescan_devices - rescan devices on the bus for possible drivers
497  * @bus: the bus to scan.
498  *
499  * This function will look for devices on the bus with no driver
500  * attached and rescan it against existing drivers to see if it matches
501  * any by calling device_attach() for the unbound devices.
502  */
503 void bus_rescan_devices(struct bus_type * bus)
504 {
505         bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
506 }
507
508
509 struct bus_type * get_bus(struct bus_type * bus)
510 {
511         return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL;
512 }
513
514 void put_bus(struct bus_type * bus)
515 {
516         subsys_put(&bus->subsys);
517 }
518
519
520 /**
521  *      find_bus - locate bus by name.
522  *      @name:  name of bus.
523  *
524  *      Call kset_find_obj() to iterate over list of buses to
525  *      find a bus by name. Return bus if found.
526  *
527  *      Note that kset_find_obj increments bus' reference count.
528  */
529
530 struct bus_type * find_bus(char * name)
531 {
532         struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
533         return k ? to_bus(k) : NULL;
534 }
535
536
537 /**
538  *      bus_add_attrs - Add default attributes for this bus.
539  *      @bus:   Bus that has just been registered.
540  */
541
542 static int bus_add_attrs(struct bus_type * bus)
543 {
544         int error = 0;
545         int i;
546
547         if (bus->bus_attrs) {
548                 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
549                         if ((error = bus_create_file(bus,&bus->bus_attrs[i])))
550                                 goto Err;
551                 }
552         }
553  Done:
554         return error;
555  Err:
556         while (--i >= 0)
557                 bus_remove_file(bus,&bus->bus_attrs[i]);
558         goto Done;
559 }
560
561 static void bus_remove_attrs(struct bus_type * bus)
562 {
563         int i;
564
565         if (bus->bus_attrs) {
566                 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
567                         bus_remove_file(bus,&bus->bus_attrs[i]);
568         }
569 }
570
571 /**
572  *      bus_register - register a bus with the system.
573  *      @bus:   bus.
574  *
575  *      Once we have that, we registered the bus with the kobject
576  *      infrastructure, then register the children subsystems it has:
577  *      the devices and drivers that belong to the bus.
578  */
579 int bus_register(struct bus_type * bus)
580 {
581         int retval;
582
583         retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
584         if (retval)
585                 goto out;
586
587         subsys_set_kset(bus, bus_subsys);
588         retval = subsystem_register(&bus->subsys);
589         if (retval)
590                 goto out;
591
592         kobject_set_name(&bus->devices.kobj, "devices");
593         bus->devices.subsys = &bus->subsys;
594         retval = kset_register(&bus->devices);
595         if (retval)
596                 goto bus_devices_fail;
597
598         kobject_set_name(&bus->drivers.kobj, "drivers");
599         bus->drivers.subsys = &bus->subsys;
600         bus->drivers.ktype = &ktype_driver;
601         retval = kset_register(&bus->drivers);
602         if (retval)
603                 goto bus_drivers_fail;
604
605         klist_init(&bus->klist_devices);
606         klist_init(&bus->klist_drivers);
607         bus_add_attrs(bus);
608
609         pr_debug("bus type '%s' registered\n", bus->name);
610         return 0;
611
612 bus_drivers_fail:
613         kset_unregister(&bus->devices);
614 bus_devices_fail:
615         subsystem_unregister(&bus->subsys);
616 out:
617         return retval;
618 }
619
620
621 /**
622  *      bus_unregister - remove a bus from the system
623  *      @bus:   bus.
624  *
625  *      Unregister the child subsystems and the bus itself.
626  *      Finally, we call put_bus() to release the refcount
627  */
628 void bus_unregister(struct bus_type * bus)
629 {
630         pr_debug("bus %s: unregistering\n", bus->name);
631         bus_remove_attrs(bus);
632         kset_unregister(&bus->drivers);
633         kset_unregister(&bus->devices);
634         subsystem_unregister(&bus->subsys);
635 }
636
637 int __init buses_init(void)
638 {
639         return subsystem_register(&bus_subsys);
640 }
641
642
643 EXPORT_SYMBOL_GPL(bus_for_each_dev);
644 EXPORT_SYMBOL_GPL(bus_find_device);
645 EXPORT_SYMBOL_GPL(bus_for_each_drv);
646
647 EXPORT_SYMBOL_GPL(bus_add_device);
648 EXPORT_SYMBOL_GPL(bus_remove_device);
649 EXPORT_SYMBOL_GPL(bus_register);
650 EXPORT_SYMBOL_GPL(bus_unregister);
651 EXPORT_SYMBOL_GPL(bus_rescan_devices);
652 EXPORT_SYMBOL_GPL(get_bus);
653 EXPORT_SYMBOL_GPL(put_bus);
654 EXPORT_SYMBOL_GPL(find_bus);
655
656 EXPORT_SYMBOL_GPL(bus_create_file);
657 EXPORT_SYMBOL_GPL(bus_remove_file);