a35f04121a00f938503f3b585c4e792e8a578d8f
[linux-2.6.git] / drivers / base / driver.c
1 /*
2  * driver.c - centralized device driver management
3  *
4  * Copyright (c) 2002-3 Patrick Mochel
5  * Copyright (c) 2002-3 Open Source Development Labs
6  * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
7  * Copyright (c) 2007 Novell Inc.
8  *
9  * This file is released under the GPLv2
10  *
11  */
12
13 #include <linux/device.h>
14 #include <linux/module.h>
15 #include <linux/errno.h>
16 #include <linux/string.h>
17 #include "base.h"
18
19 #define to_dev(node) container_of(node, struct device, driver_list)
20
21
22 static struct device *next_device(struct klist_iter *i)
23 {
24         struct klist_node *n = klist_next(i);
25         return n ? container_of(n, struct device, knode_driver) : NULL;
26 }
27
28 /**
29  * driver_for_each_device - Iterator for devices bound to a driver.
30  * @drv: Driver we're iterating.
31  * @start: Device to begin with
32  * @data: Data to pass to the callback.
33  * @fn: Function to call for each device.
34  *
35  * Iterate over the @drv's list of devices calling @fn for each one.
36  */
37 int driver_for_each_device(struct device_driver *drv, struct device *start,
38                            void *data, int (*fn)(struct device *, void *))
39 {
40         struct klist_iter i;
41         struct device *dev;
42         int error = 0;
43
44         if (!drv)
45                 return -EINVAL;
46
47         klist_iter_init_node(&drv->p->klist_devices, &i,
48                              start ? &start->knode_driver : NULL);
49         while ((dev = next_device(&i)) && !error)
50                 error = fn(dev, data);
51         klist_iter_exit(&i);
52         return error;
53 }
54 EXPORT_SYMBOL_GPL(driver_for_each_device);
55
56 /**
57  * driver_find_device - device iterator for locating a particular device.
58  * @drv: The device's driver
59  * @start: Device to begin with
60  * @data: Data to pass to match function
61  * @match: Callback function to check device
62  *
63  * This is similar to the driver_for_each_device() function above, but
64  * it returns a reference to a device that is 'found' for later use, as
65  * determined by the @match callback.
66  *
67  * The callback should return 0 if the device doesn't match and non-zero
68  * if it does.  If the callback returns non-zero, this function will
69  * return to the caller and not iterate over any more devices.
70  */
71 struct device *driver_find_device(struct device_driver *drv,
72                                   struct device *start, void *data,
73                                   int (*match)(struct device *dev, void *data))
74 {
75         struct klist_iter i;
76         struct device *dev;
77
78         if (!drv)
79                 return NULL;
80
81         klist_iter_init_node(&drv->p->klist_devices, &i,
82                              (start ? &start->knode_driver : NULL));
83         while ((dev = next_device(&i)))
84                 if (match(dev, data) && get_device(dev))
85                         break;
86         klist_iter_exit(&i);
87         return dev;
88 }
89 EXPORT_SYMBOL_GPL(driver_find_device);
90
91 /**
92  * driver_create_file - create sysfs file for driver.
93  * @drv: driver.
94  * @attr: driver attribute descriptor.
95  */
96 int driver_create_file(struct device_driver *drv,
97                        struct driver_attribute *attr)
98 {
99         int error;
100         if (get_driver(drv)) {
101                 error = sysfs_create_file(&drv->p->kobj, &attr->attr);
102                 put_driver(drv);
103         } else
104                 error = -EINVAL;
105         return error;
106 }
107 EXPORT_SYMBOL_GPL(driver_create_file);
108
109 /**
110  * driver_remove_file - remove sysfs file for driver.
111  * @drv: driver.
112  * @attr: driver attribute descriptor.
113  */
114 void driver_remove_file(struct device_driver *drv,
115                         struct driver_attribute *attr)
116 {
117         if (get_driver(drv)) {
118                 sysfs_remove_file(&drv->p->kobj, &attr->attr);
119                 put_driver(drv);
120         }
121 }
122 EXPORT_SYMBOL_GPL(driver_remove_file);
123
124 /**
125  * driver_add_kobj - add a kobject below the specified driver
126  *
127  * You really don't want to do this, this is only here due to one looney
128  * iseries driver, go poke those developers if you are annoyed about
129  * this...
130  */
131 int driver_add_kobj(struct device_driver *drv, struct kobject *kobj,
132                     const char *fmt, ...)
133 {
134         va_list args;
135         char *name;
136
137         va_start(args, fmt);
138         name = kvasprintf(GFP_KERNEL, fmt, args);
139         va_end(args);
140
141         if (!name)
142                 return -ENOMEM;
143
144         return kobject_add(kobj, &drv->p->kobj, "%s", name);
145 }
146 EXPORT_SYMBOL_GPL(driver_add_kobj);
147
148 /**
149  * get_driver - increment driver reference count.
150  * @drv: driver.
151  */
152 struct device_driver *get_driver(struct device_driver *drv)
153 {
154         if (drv) {
155                 struct driver_private *priv;
156                 struct kobject *kobj;
157
158                 kobj = kobject_get(&drv->p->kobj);
159                 priv = to_driver(kobj);
160                 return priv->driver;
161         }
162         return NULL;
163 }
164 EXPORT_SYMBOL_GPL(get_driver);
165
166 /**
167  * put_driver - decrement driver's refcount.
168  * @drv: driver.
169  */
170 void put_driver(struct device_driver *drv)
171 {
172         kobject_put(&drv->p->kobj);
173 }
174 EXPORT_SYMBOL_GPL(put_driver);
175
176 static int driver_add_groups(struct device_driver *drv,
177                              struct attribute_group **groups)
178 {
179         int error = 0;
180         int i;
181
182         if (groups) {
183                 for (i = 0; groups[i]; i++) {
184                         error = sysfs_create_group(&drv->p->kobj, groups[i]);
185                         if (error) {
186                                 while (--i >= 0)
187                                         sysfs_remove_group(&drv->p->kobj,
188                                                            groups[i]);
189                                 break;
190                         }
191                 }
192         }
193         return error;
194 }
195
196 static void driver_remove_groups(struct device_driver *drv,
197                                  struct attribute_group **groups)
198 {
199         int i;
200
201         if (groups)
202                 for (i = 0; groups[i]; i++)
203                         sysfs_remove_group(&drv->p->kobj, groups[i]);
204 }
205
206 /**
207  * driver_register - register driver with bus
208  * @drv: driver to register
209  *
210  * We pass off most of the work to the bus_add_driver() call,
211  * since most of the things we have to do deal with the bus
212  * structures.
213  */
214 int driver_register(struct device_driver *drv)
215 {
216         int ret;
217
218         if ((drv->bus->probe && drv->probe) ||
219             (drv->bus->remove && drv->remove) ||
220             (drv->bus->shutdown && drv->shutdown))
221                 printk(KERN_WARNING "Driver '%s' needs updating - please use "
222                         "bus_type methods\n", drv->name);
223         ret = bus_add_driver(drv);
224         if (ret)
225                 return ret;
226         ret = driver_add_groups(drv, drv->groups);
227         if (ret)
228                 bus_remove_driver(drv);
229         return ret;
230 }
231 EXPORT_SYMBOL_GPL(driver_register);
232
233 /**
234  * driver_unregister - remove driver from system.
235  * @drv: driver.
236  *
237  * Again, we pass off most of the work to the bus-level call.
238  */
239 void driver_unregister(struct device_driver *drv)
240 {
241         driver_remove_groups(drv, drv->groups);
242         bus_remove_driver(drv);
243 }
244 EXPORT_SYMBOL_GPL(driver_unregister);
245
246 /**
247  * driver_find - locate driver on a bus by its name.
248  * @name: name of the driver.
249  * @bus: bus to scan for the driver.
250  *
251  * Call kset_find_obj() to iterate over list of drivers on
252  * a bus to find driver by name. Return driver if found.
253  *
254  * Note that kset_find_obj increments driver's reference count.
255  */
256 struct device_driver *driver_find(const char *name, struct bus_type *bus)
257 {
258         struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);
259         struct driver_private *priv;
260
261         if (k) {
262                 priv = to_driver(k);
263                 return priv->driver;
264         }
265         return NULL;
266 }
267 EXPORT_SYMBOL_GPL(driver_find);