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