1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/device.h>
14#include <linux/module.h>
15#include <linux/errno.h>
16#include <linux/slab.h>
17#include <linux/string.h>
18#include <linux/sysfs.h>
19#include "base.h"
20
21static struct device *next_device(struct klist_iter *i)
22{
23 struct klist_node *n = klist_next(i);
24 struct device *dev = NULL;
25 struct device_private *dev_prv;
26
27 if (n) {
28 dev_prv = to_device_private_driver(n);
29 dev = dev_prv->device;
30 }
31 return dev;
32}
33
34
35
36
37
38
39
40
41
42
43int driver_for_each_device(struct device_driver *drv, struct device *start,
44 void *data, int (*fn)(struct device *, void *))
45{
46 struct klist_iter i;
47 struct device *dev;
48 int error = 0;
49
50 if (!drv)
51 return -EINVAL;
52
53 klist_iter_init_node(&drv->p->klist_devices, &i,
54 start ? &start->p->knode_driver : NULL);
55 while ((dev = next_device(&i)) && !error)
56 error = fn(dev, data);
57 klist_iter_exit(&i);
58 return error;
59}
60EXPORT_SYMBOL_GPL(driver_for_each_device);
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77struct device *driver_find_device(struct device_driver *drv,
78 struct device *start, void *data,
79 int (*match)(struct device *dev, void *data))
80{
81 struct klist_iter i;
82 struct device *dev;
83
84 if (!drv || !drv->p)
85 return NULL;
86
87 klist_iter_init_node(&drv->p->klist_devices, &i,
88 (start ? &start->p->knode_driver : NULL));
89 while ((dev = next_device(&i)))
90 if (match(dev, data) && get_device(dev))
91 break;
92 klist_iter_exit(&i);
93 return dev;
94}
95EXPORT_SYMBOL_GPL(driver_find_device);
96
97
98
99
100
101
102int driver_create_file(struct device_driver *drv,
103 const struct driver_attribute *attr)
104{
105 int error;
106
107 if (drv)
108 error = sysfs_create_file(&drv->p->kobj, &attr->attr);
109 else
110 error = -EINVAL;
111 return error;
112}
113EXPORT_SYMBOL_GPL(driver_create_file);
114
115
116
117
118
119
120void driver_remove_file(struct device_driver *drv,
121 const struct driver_attribute *attr)
122{
123 if (drv)
124 sysfs_remove_file(&drv->p->kobj, &attr->attr);
125}
126EXPORT_SYMBOL_GPL(driver_remove_file);
127
128int driver_add_groups(struct device_driver *drv,
129 const struct attribute_group **groups)
130{
131 return sysfs_create_groups(&drv->p->kobj, groups);
132}
133
134void driver_remove_groups(struct device_driver *drv,
135 const struct attribute_group **groups)
136{
137 sysfs_remove_groups(&drv->p->kobj, groups);
138}
139
140
141
142
143
144
145
146
147
148int driver_register(struct device_driver *drv)
149{
150 int ret;
151 struct device_driver *other;
152
153 BUG_ON(!drv->bus->p);
154
155 if ((drv->bus->probe && drv->probe) ||
156 (drv->bus->remove && drv->remove) ||
157 (drv->bus->shutdown && drv->shutdown))
158 printk(KERN_WARNING "Driver '%s' needs updating - please use "
159 "bus_type methods\n", drv->name);
160
161 other = driver_find(drv->name, drv->bus);
162 if (other) {
163 printk(KERN_ERR "Error: Driver '%s' is already registered, "
164 "aborting...\n", drv->name);
165 return -EBUSY;
166 }
167
168 ret = bus_add_driver(drv);
169 if (ret)
170 return ret;
171 ret = driver_add_groups(drv, drv->groups);
172 if (ret) {
173 bus_remove_driver(drv);
174 return ret;
175 }
176 kobject_uevent(&drv->p->kobj, KOBJ_ADD);
177
178 return ret;
179}
180EXPORT_SYMBOL_GPL(driver_register);
181
182
183
184
185
186
187
188void driver_unregister(struct device_driver *drv)
189{
190 if (!drv || !drv->p) {
191 WARN(1, "Unexpected driver unregister!\n");
192 return;
193 }
194 driver_remove_groups(drv, drv->groups);
195 bus_remove_driver(drv);
196}
197EXPORT_SYMBOL_GPL(driver_unregister);
198
199
200
201
202
203
204
205
206
207
208
209
210
211struct device_driver *driver_find(const char *name, struct bus_type *bus)
212{
213 struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);
214 struct driver_private *priv;
215
216 if (k) {
217
218 kobject_put(k);
219 priv = to_driver(k);
220 return priv->driver;
221 }
222 return NULL;
223}
224EXPORT_SYMBOL_GPL(driver_find);
225