1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/device.h>
21#include <linux/delay.h>
22#include <linux/module.h>
23#include <linux/kthread.h>
24#include <linux/wait.h>
25#include <linux/async.h>
26#include <linux/pm_runtime.h>
27
28#include "base.h"
29#include "power/power.h"
30
31
32static void driver_bound(struct device *dev)
33{
34 if (klist_node_attached(&dev->p->knode_driver)) {
35 printk(KERN_WARNING "%s: device %s already bound\n",
36 __func__, kobject_name(&dev->kobj));
37 return;
38 }
39
40 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
41 __func__, dev->driver->name);
42
43 if (dev->bus)
44 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
45 BUS_NOTIFY_BOUND_DRIVER, dev);
46
47 klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
48}
49
50static int driver_sysfs_add(struct device *dev)
51{
52 int ret;
53
54 ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
55 kobject_name(&dev->kobj));
56 if (ret == 0) {
57 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
58 "driver");
59 if (ret)
60 sysfs_remove_link(&dev->driver->p->kobj,
61 kobject_name(&dev->kobj));
62 }
63 return ret;
64}
65
66static void driver_sysfs_remove(struct device *dev)
67{
68 struct device_driver *drv = dev->driver;
69
70 if (drv) {
71 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
72 sysfs_remove_link(&dev->kobj, "driver");
73 }
74}
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90int device_bind_driver(struct device *dev)
91{
92 int ret;
93
94 ret = driver_sysfs_add(dev);
95 if (!ret)
96 driver_bound(dev);
97 return ret;
98}
99EXPORT_SYMBOL_GPL(device_bind_driver);
100
101static atomic_t probe_count = ATOMIC_INIT(0);
102static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
103
104static int really_probe(struct device *dev, struct device_driver *drv)
105{
106 int ret = 0;
107
108 atomic_inc(&probe_count);
109 pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
110 drv->bus->name, __func__, drv->name, dev_name(dev));
111 WARN_ON(!list_empty(&dev->devres_head));
112
113 dev->driver = drv;
114 if (driver_sysfs_add(dev)) {
115 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
116 __func__, dev_name(dev));
117 goto probe_failed;
118 }
119
120 if (dev->bus->probe) {
121 ret = dev->bus->probe(dev);
122 if (ret)
123 goto probe_failed;
124 } else if (drv->probe) {
125 ret = drv->probe(dev);
126 if (ret)
127 goto probe_failed;
128 }
129
130 driver_bound(dev);
131 ret = 1;
132 pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
133 drv->bus->name, __func__, dev_name(dev), drv->name);
134 goto done;
135
136probe_failed:
137 devres_release_all(dev);
138 driver_sysfs_remove(dev);
139 dev->driver = NULL;
140
141 if (ret != -ENODEV && ret != -ENXIO) {
142
143 printk(KERN_WARNING
144 "%s: probe of %s failed with error %d\n",
145 drv->name, dev_name(dev), ret);
146 }
147
148
149
150
151 ret = 0;
152done:
153 atomic_dec(&probe_count);
154 wake_up(&probe_waitqueue);
155 return ret;
156}
157
158
159
160
161
162
163
164int driver_probe_done(void)
165{
166 pr_debug("%s: probe_count = %d\n", __func__,
167 atomic_read(&probe_count));
168 if (atomic_read(&probe_count))
169 return -EBUSY;
170 return 0;
171}
172
173
174
175
176
177void wait_for_device_probe(void)
178{
179
180 wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
181 async_synchronize_full();
182}
183EXPORT_SYMBOL_GPL(wait_for_device_probe);
184
185
186
187
188
189
190
191
192
193
194
195
196int driver_probe_device(struct device_driver *drv, struct device *dev)
197{
198 int ret = 0;
199
200 if (!device_is_registered(dev))
201 return -ENODEV;
202
203 pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
204 drv->bus->name, __func__, dev_name(dev), drv->name);
205
206 pm_runtime_get_noresume(dev);
207 pm_runtime_barrier(dev);
208 ret = really_probe(dev, drv);
209 pm_runtime_put_sync(dev);
210
211 return ret;
212}
213
214static int __device_attach(struct device_driver *drv, void *data)
215{
216 struct device *dev = data;
217
218 if (!driver_match_device(drv, dev))
219 return 0;
220
221 return driver_probe_device(drv, dev);
222}
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238int device_attach(struct device *dev)
239{
240 int ret = 0;
241
242 down(&dev->sem);
243 if (dev->driver) {
244 ret = device_bind_driver(dev);
245 if (ret == 0)
246 ret = 1;
247 else {
248 dev->driver = NULL;
249 ret = 0;
250 }
251 } else {
252 pm_runtime_get_noresume(dev);
253 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
254 pm_runtime_put_sync(dev);
255 }
256 up(&dev->sem);
257 return ret;
258}
259EXPORT_SYMBOL_GPL(device_attach);
260
261static int __driver_attach(struct device *dev, void *data)
262{
263 struct device_driver *drv = data;
264
265
266
267
268
269
270
271
272
273
274
275 if (!driver_match_device(drv, dev))
276 return 0;
277
278 if (dev->parent)
279 down(&dev->parent->sem);
280 down(&dev->sem);
281 if (!dev->driver)
282 driver_probe_device(drv, dev);
283 up(&dev->sem);
284 if (dev->parent)
285 up(&dev->parent->sem);
286
287 return 0;
288}
289
290
291
292
293
294
295
296
297
298
299int driver_attach(struct device_driver *drv)
300{
301 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
302}
303EXPORT_SYMBOL_GPL(driver_attach);
304
305
306
307
308
309static void __device_release_driver(struct device *dev)
310{
311 struct device_driver *drv;
312
313 drv = dev->driver;
314 if (drv) {
315 pm_runtime_get_noresume(dev);
316 pm_runtime_barrier(dev);
317
318 driver_sysfs_remove(dev);
319
320 if (dev->bus)
321 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
322 BUS_NOTIFY_UNBIND_DRIVER,
323 dev);
324
325 if (dev->bus && dev->bus->remove)
326 dev->bus->remove(dev);
327 else if (drv->remove)
328 drv->remove(dev);
329 devres_release_all(dev);
330 dev->driver = NULL;
331 klist_remove(&dev->p->knode_driver);
332 if (dev->bus)
333 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
334 BUS_NOTIFY_UNBOUND_DRIVER,
335 dev);
336
337 pm_runtime_put_sync(dev);
338 }
339}
340
341
342
343
344
345
346
347
348void device_release_driver(struct device *dev)
349{
350
351
352
353
354
355 down(&dev->sem);
356 __device_release_driver(dev);
357 up(&dev->sem);
358}
359EXPORT_SYMBOL_GPL(device_release_driver);
360
361
362
363
364
365void driver_detach(struct device_driver *drv)
366{
367 struct device_private *dev_prv;
368 struct device *dev;
369
370 for (;;) {
371 spin_lock(&drv->p->klist_devices.k_lock);
372 if (list_empty(&drv->p->klist_devices.k_list)) {
373 spin_unlock(&drv->p->klist_devices.k_lock);
374 break;
375 }
376 dev_prv = list_entry(drv->p->klist_devices.k_list.prev,
377 struct device_private,
378 knode_driver.n_node);
379 dev = dev_prv->device;
380 get_device(dev);
381 spin_unlock(&drv->p->klist_devices.k_lock);
382
383 if (dev->parent)
384 down(&dev->parent->sem);
385 down(&dev->sem);
386 if (dev->driver == drv)
387 __device_release_driver(dev);
388 up(&dev->sem);
389 if (dev->parent)
390 up(&dev->parent->sem);
391 put_device(dev);
392 }
393}
394
395
396
397
398
399void *dev_get_drvdata(const struct device *dev)
400{
401 if (dev && dev->p)
402 return dev->p->driver_data;
403 return NULL;
404}
405EXPORT_SYMBOL(dev_get_drvdata);
406
407void dev_set_drvdata(struct device *dev, void *data)
408{
409 int error;
410
411 if (!dev)
412 return;
413 if (!dev->p) {
414 error = device_private_init(dev);
415 if (error)
416 return;
417 }
418 dev->p->driver_data = data;
419}
420EXPORT_SYMBOL(dev_set_drvdata);
421