blob: 7ac474db88c525f46a0846810ca5f384fa07b104 [file] [log] [blame]
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001/*
2 * drivers/base/dd.c - The core device/driver interactions.
3 *
4 * This file contains the (sometimes tricky) code that controls the
5 * interactions between devices and drivers, which primarily includes
6 * driver binding and unbinding.
7 *
8 * All of this code used to exist in drivers/base/bus.c, but was
9 * relocated to here in the name of compartmentalization (since it wasn't
10 * strictly code just for the 'struct bus_type'.
11 *
12 * Copyright (c) 2002-5 Patrick Mochel
13 * Copyright (c) 2002-3 Open Source Development Labs
14 *
15 * This file is released under the GPLv2
16 */
17
18#include <linux/device.h>
19#include <linux/module.h>
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -070020#include <linux/kthread.h>
Andrew Morton735a7ff2006-10-27 11:42:37 -070021#include <linux/wait.h>
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080022
23#include "base.h"
24#include "power/power.h"
25
26#define to_drv(node) container_of(node, struct device_driver, kobj.entry)
27
28
Kay Sievers1901fb22006-10-07 21:55:55 +020029static void driver_bound(struct device *dev)
30{
31 if (klist_node_attached(&dev->knode_driver)) {
32 printk(KERN_WARNING "%s: device %s already bound\n",
33 __FUNCTION__, kobject_name(&dev->kobj));
34 return;
35 }
36
37 pr_debug("bound device '%s' to driver '%s'\n",
38 dev->bus_id, dev->driver->name);
39
40 if (dev->bus)
41 blocking_notifier_call_chain(&dev->bus->bus_notifier,
42 BUS_NOTIFY_BOUND_DRIVER, dev);
43
44 klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices);
45}
46
47static int driver_sysfs_add(struct device *dev)
48{
49 int ret;
50
51 ret = sysfs_create_link(&dev->driver->kobj, &dev->kobj,
52 kobject_name(&dev->kobj));
53 if (ret == 0) {
54 ret = sysfs_create_link(&dev->kobj, &dev->driver->kobj,
55 "driver");
56 if (ret)
57 sysfs_remove_link(&dev->driver->kobj,
58 kobject_name(&dev->kobj));
59 }
60 return ret;
61}
62
63static void driver_sysfs_remove(struct device *dev)
64{
65 struct device_driver *drv = dev->driver;
66
67 if (drv) {
68 sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj));
69 sysfs_remove_link(&dev->kobj, "driver");
70 }
71}
72
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080073/**
74 * device_bind_driver - bind a driver to one device.
75 * @dev: device.
76 *
77 * Allow manual attachment of a driver to a device.
78 * Caller must have already set @dev->driver.
79 *
80 * Note that this does not modify the bus reference count
81 * nor take the bus's rwsem. Please verify those are accounted
82 * for before calling this. (It is ok to call with no other effort
83 * from a driver's probe() method.)
Patrick Mochel0d3e5a22005-04-05 23:46:33 -070084 *
85 * This function must be called with @dev->sem held.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080086 */
Andrew Mortonf86db392006-08-14 22:43:20 -070087int device_bind_driver(struct device *dev)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080088{
Cornelia Huckcb986b72006-11-27 10:35:12 +010089 int ret;
90
91 ret = driver_sysfs_add(dev);
92 if (!ret)
93 driver_bound(dev);
94 return ret;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080095}
96
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -070097static atomic_t probe_count = ATOMIC_INIT(0);
Andrew Morton735a7ff2006-10-27 11:42:37 -070098static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
99
Cornelia Huck21c7f302007-02-05 16:15:25 -0800100static int really_probe(struct device *dev, struct device_driver *drv)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800101{
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700102 int ret = 0;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800103
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700104 atomic_inc(&probe_count);
105 pr_debug("%s: Probing driver %s with device %s\n",
106 drv->bus->name, drv->name, dev->bus_id);
Tejun Heo9ac78492007-01-20 16:00:26 +0900107 WARN_ON(!list_empty(&dev->devres_head));
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800108
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800109 dev->driver = drv;
Kay Sievers1901fb22006-10-07 21:55:55 +0200110 if (driver_sysfs_add(dev)) {
111 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
112 __FUNCTION__, dev->bus_id);
113 goto probe_failed;
114 }
115
Russell King594c8282006-01-05 14:29:51 +0000116 if (dev->bus->probe) {
117 ret = dev->bus->probe(dev);
Kay Sievers1901fb22006-10-07 21:55:55 +0200118 if (ret)
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700119 goto probe_failed;
Russell King594c8282006-01-05 14:29:51 +0000120 } else if (drv->probe) {
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700121 ret = drv->probe(dev);
Kay Sievers1901fb22006-10-07 21:55:55 +0200122 if (ret)
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700123 goto probe_failed;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800124 }
Kay Sievers1901fb22006-10-07 21:55:55 +0200125
126 driver_bound(dev);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700127 ret = 1;
128 pr_debug("%s: Bound Device %s to Driver %s\n",
129 drv->bus->name, dev->bus_id, drv->name);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700130 goto done;
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700131
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700132probe_failed:
Tejun Heo9ac78492007-01-20 16:00:26 +0900133 devres_release_all(dev);
Kay Sievers1901fb22006-10-07 21:55:55 +0200134 driver_sysfs_remove(dev);
135 dev->driver = NULL;
136
Cornelia Huckc578abb2006-11-27 10:35:10 +0100137 if (ret != -ENODEV && ret != -ENXIO) {
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700138 /* driver matched but the probe failed */
139 printk(KERN_WARNING
140 "%s: probe of %s failed with error %d\n",
141 drv->name, dev->bus_id, ret);
142 }
Cornelia Huckc578abb2006-11-27 10:35:10 +0100143 /*
144 * Ignore errors returned by ->probe so that the next driver can try
145 * its luck.
146 */
147 ret = 0;
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700148done:
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700149 atomic_dec(&probe_count);
Andrew Morton735a7ff2006-10-27 11:42:37 -0700150 wake_up(&probe_waitqueue);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700151 return ret;
152}
153
154/**
155 * driver_probe_done
156 * Determine if the probe sequence is finished or not.
157 *
158 * Should somehow figure out how to use a semaphore, not an atomic variable...
159 */
160int driver_probe_done(void)
161{
162 pr_debug("%s: probe_count = %d\n", __FUNCTION__,
163 atomic_read(&probe_count));
164 if (atomic_read(&probe_count))
165 return -EBUSY;
166 return 0;
167}
168
169/**
170 * driver_probe_device - attempt to bind device & driver together
171 * @drv: driver to bind a device to
172 * @dev: device to try to bind to the driver
173 *
174 * First, we call the bus's match function, if one present, which should
175 * compare the device IDs the driver supports with the device IDs of the
176 * device. Note we don't do this ourselves because we don't know the
177 * format of the ID structures, nor what is to be considered a match and
178 * what is not.
179 *
Cornelia Huck21c7f302007-02-05 16:15:25 -0800180 * This function returns 1 if a match is found, -ENODEV if the device is
181 * not registered, and 0 otherwise.
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700182 *
183 * This function must be called with @dev->sem held. When called for a
184 * USB interface, @dev->parent->sem must be held as well.
185 */
186int driver_probe_device(struct device_driver * drv, struct device * dev)
187{
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700188 int ret = 0;
189
Alan Sternf2eaae12006-09-18 16:22:34 -0400190 if (!device_is_registered(dev))
191 return -ENODEV;
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700192 if (drv->bus->match && !drv->bus->match(dev, drv))
193 goto done;
194
195 pr_debug("%s: Matched Device %s with Driver %s\n",
196 drv->bus->name, dev->bus_id, drv->name);
197
Cornelia Huck21c7f302007-02-05 16:15:25 -0800198 ret = really_probe(dev, drv);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700199
200done:
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700201 return ret;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800202}
203
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -0800204static int __device_attach(struct device_driver * drv, void * data)
205{
206 struct device * dev = data;
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700207 return driver_probe_device(drv, dev);
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -0800208}
209
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800210/**
211 * device_attach - try to attach device to a driver.
212 * @dev: device.
213 *
214 * Walk the list of drivers that the bus has and call
215 * driver_probe_device() for each pair. If a compatible
Adrian Bunk5adc55d2007-03-27 03:02:51 +0200216 * pair is found, break out and return.
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700217 *
Hannes Reineckeca2b94b2005-05-18 10:42:23 +0200218 * Returns 1 if the device was bound to a driver;
Adrian Bunk5adc55d2007-03-27 03:02:51 +0200219 * 0 if no matching device was found;
Cornelia Huckc6a46692007-02-05 16:15:26 -0800220 * -ENODEV if the device is not registered.
Alan Sternbf74ad52005-11-17 16:54:12 -0500221 *
222 * When called for a USB interface, @dev->parent->sem must be held.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800223 */
224int device_attach(struct device * dev)
225{
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700226 int ret = 0;
227
228 down(&dev->sem);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800229 if (dev->driver) {
Andrew Mortonf86db392006-08-14 22:43:20 -0700230 ret = device_bind_driver(dev);
231 if (ret == 0)
232 ret = 1;
Cornelia Huckc6a46692007-02-05 16:15:26 -0800233 else {
234 dev->driver = NULL;
235 ret = 0;
236 }
Cornelia Huck21c7f302007-02-05 16:15:25 -0800237 } else {
Adrian Bunk5adc55d2007-03-27 03:02:51 +0200238 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
Cornelia Huck21c7f302007-02-05 16:15:25 -0800239 }
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700240 up(&dev->sem);
241 return ret;
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -0800242}
243
244static int __driver_attach(struct device * dev, void * data)
245{
246 struct device_driver * drv = data;
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -0800247
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700248 /*
249 * Lock device and try to bind to it. We drop the error
250 * here and always return 0, because we need to keep trying
251 * to bind to devices and some drivers will return an error
252 * simply if it didn't support the device.
253 *
254 * driver_probe_device() will spit a warning if there
255 * is an error.
256 */
257
Alan Sternbf74ad52005-11-17 16:54:12 -0500258 if (dev->parent) /* Needed for USB */
259 down(&dev->parent->sem);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700260 down(&dev->sem);
261 if (!dev->driver)
262 driver_probe_device(drv, dev);
263 up(&dev->sem);
Alan Sternbf74ad52005-11-17 16:54:12 -0500264 if (dev->parent)
265 up(&dev->parent->sem);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700266
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800267 return 0;
268}
269
270/**
271 * driver_attach - try to bind driver to devices.
272 * @drv: driver.
273 *
274 * Walk the list of devices that the bus has on it and try to
275 * match the driver with each one. If driver_probe_device()
276 * returns 0 and the @dev->driver is set, we've found a
277 * compatible pair.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800278 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700279int driver_attach(struct device_driver * drv)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800280{
Andrew Mortonf86db392006-08-14 22:43:20 -0700281 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800282}
283
Stefan Richterab71c6f2007-06-17 11:02:12 +0200284/*
Alan Sternc95a6b02005-05-06 15:38:33 -0400285 * __device_release_driver() must be called with @dev->sem held.
Stefan Richterab71c6f2007-06-17 11:02:12 +0200286 * When called for a USB interface, @dev->parent->sem must be held as well.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800287 */
Alan Sternc95a6b02005-05-06 15:38:33 -0400288static void __device_release_driver(struct device * dev)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800289{
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700290 struct device_driver * drv;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800291
Stefan Richter1f5681a2007-06-17 11:01:18 +0200292 drv = get_driver(dev->driver);
Alan Sternc95a6b02005-05-06 15:38:33 -0400293 if (drv) {
Kay Sievers1901fb22006-10-07 21:55:55 +0200294 driver_sysfs_remove(dev);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700295 sysfs_remove_link(&dev->kobj, "driver");
Alan Sternc95a6b02005-05-06 15:38:33 -0400296 klist_remove(&dev->knode_driver);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700297
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +1000298 if (dev->bus)
299 blocking_notifier_call_chain(&dev->bus->bus_notifier,
300 BUS_NOTIFY_UNBIND_DRIVER,
301 dev);
302
Alan Stern0f836ca2006-03-31 11:52:25 -0500303 if (dev->bus && dev->bus->remove)
Russell King594c8282006-01-05 14:29:51 +0000304 dev->bus->remove(dev);
305 else if (drv->remove)
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700306 drv->remove(dev);
Tejun Heo9ac78492007-01-20 16:00:26 +0900307 devres_release_all(dev);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700308 dev->driver = NULL;
Alan Sternc95a6b02005-05-06 15:38:33 -0400309 put_driver(drv);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700310 }
Alan Sternc95a6b02005-05-06 15:38:33 -0400311}
312
Stefan Richterab71c6f2007-06-17 11:02:12 +0200313/**
314 * device_release_driver - manually detach device from driver.
315 * @dev: device.
316 *
317 * Manually detach device from driver.
318 * When called for a USB interface, @dev->parent->sem must be held.
319 */
Alan Sternc95a6b02005-05-06 15:38:33 -0400320void device_release_driver(struct device * dev)
321{
322 /*
323 * If anyone calls device_release_driver() recursively from
324 * within their ->remove callback for the same device, they
325 * will deadlock right here.
326 */
327 down(&dev->sem);
328 __device_release_driver(dev);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800329 up(&dev->sem);
330}
331
mochel@digitalimplant.org94e7b1c52005-03-21 12:25:36 -0800332
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800333/**
334 * driver_detach - detach driver from all devices it controls.
335 * @drv: driver.
336 */
337void driver_detach(struct device_driver * drv)
338{
Alan Sternc95a6b02005-05-06 15:38:33 -0400339 struct device * dev;
340
341 for (;;) {
Alan Stern2b08c8d2005-11-23 15:43:50 -0800342 spin_lock(&drv->klist_devices.k_lock);
Alan Sternc95a6b02005-05-06 15:38:33 -0400343 if (list_empty(&drv->klist_devices.k_list)) {
Alan Stern2b08c8d2005-11-23 15:43:50 -0800344 spin_unlock(&drv->klist_devices.k_lock);
Alan Sternc95a6b02005-05-06 15:38:33 -0400345 break;
346 }
347 dev = list_entry(drv->klist_devices.k_list.prev,
348 struct device, knode_driver.n_node);
349 get_device(dev);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800350 spin_unlock(&drv->klist_devices.k_lock);
Alan Sternc95a6b02005-05-06 15:38:33 -0400351
Alan Sternbf74ad52005-11-17 16:54:12 -0500352 if (dev->parent) /* Needed for USB */
353 down(&dev->parent->sem);
Alan Sternc95a6b02005-05-06 15:38:33 -0400354 down(&dev->sem);
355 if (dev->driver == drv)
356 __device_release_driver(dev);
357 up(&dev->sem);
Alan Sternbf74ad52005-11-17 16:54:12 -0500358 if (dev->parent)
359 up(&dev->parent->sem);
Alan Sternc95a6b02005-05-06 15:38:33 -0400360 put_device(dev);
361 }
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800362}
363
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800364EXPORT_SYMBOL_GPL(device_bind_driver);
365EXPORT_SYMBOL_GPL(device_release_driver);
366EXPORT_SYMBOL_GPL(device_attach);
367EXPORT_SYMBOL_GPL(driver_attach);
368