2 * drivers/base/dd.c - The core device/driver interactions.
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.
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'.
12 * Copyright (c) 2002-5 Patrick Mochel
13 * Copyright (c) 2002-3 Open Source Development Labs
15 * This file is released under the GPLv2
18 #include <linux/device.h>
19 #include <linux/module.h>
22 #include "power/power.h"
24 #define to_drv(node) container_of(node, struct device_driver, kobj.entry)
28 * device_bind_driver - bind a driver to one device.
31 * Allow manual attachment of a driver to a device.
32 * Caller must have already set @dev->driver.
34 * Note that this does not modify the bus reference count
35 * nor take the bus's rwsem. Please verify those are accounted
36 * for before calling this. (It is ok to call with no other effort
37 * from a driver's probe() method.)
39 * This function must be called with @dev->sem held.
41 int device_bind_driver(struct device
*dev
)
45 if (klist_node_attached(&dev
->knode_driver
)) {
46 printk(KERN_WARNING
"%s: device %s already bound\n",
47 __FUNCTION__
, kobject_name(&dev
->kobj
));
51 pr_debug("bound device '%s' to driver '%s'\n",
52 dev
->bus_id
, dev
->driver
->name
);
53 klist_add_tail(&dev
->knode_driver
, &dev
->driver
->klist_devices
);
54 ret
= sysfs_create_link(&dev
->driver
->kobj
, &dev
->kobj
,
55 kobject_name(&dev
->kobj
));
57 ret
= sysfs_create_link(&dev
->kobj
, &dev
->driver
->kobj
,
60 sysfs_remove_link(&dev
->driver
->kobj
,
61 kobject_name(&dev
->kobj
));
67 * driver_probe_device - attempt to bind device & driver.
71 * First, we call the bus's match function, if one present, which
72 * should compare the device IDs the driver supports with the
73 * device IDs of the device. Note we don't do this ourselves
74 * because we don't know the format of the ID structures, nor what
75 * is to be considered a match and what is not.
77 * This function returns 1 if a match is found, an error if one
78 * occurs (that is not -ENODEV or -ENXIO), and 0 otherwise.
80 * This function must be called with @dev->sem held. When called
81 * for a USB interface, @dev->parent->sem must be held as well.
83 int driver_probe_device(struct device_driver
* drv
, struct device
* dev
)
87 if (drv
->bus
->match
&& !drv
->bus
->match(dev
, drv
))
90 pr_debug("%s: Matched Device %s with Driver %s\n",
91 drv
->bus
->name
, dev
->bus_id
, drv
->name
);
93 if (dev
->bus
->probe
) {
94 ret
= dev
->bus
->probe(dev
);
99 } else if (drv
->probe
) {
100 ret
= drv
->probe(dev
);
106 if (device_bind_driver(dev
)) {
107 printk(KERN_ERR
"%s: device_bind_driver(%s) failed\n",
108 __FUNCTION__
, dev
->bus_id
);
109 /* How does undo a ->probe? We're screwed. */
112 pr_debug("%s: Bound Device %s to Driver %s\n",
113 drv
->bus
->name
, dev
->bus_id
, drv
->name
);
117 if (ret
== -ENODEV
|| ret
== -ENXIO
) {
118 /* Driver matched, but didn't support device
119 * or device not found.
120 * Not an error; keep going.
124 /* driver matched but the probe failed */
126 "%s: probe of %s failed with error %d\n",
127 drv
->name
, dev
->bus_id
, ret
);
133 static int __device_attach(struct device_driver
* drv
, void * data
)
135 struct device
* dev
= data
;
136 return driver_probe_device(drv
, dev
);
140 * device_attach - try to attach device to a driver.
143 * Walk the list of drivers that the bus has and call
144 * driver_probe_device() for each pair. If a compatible
145 * pair is found, break out and return.
147 * Returns 1 if the device was bound to a driver;
148 * 0 if no matching device was found; error code otherwise.
150 * When called for a USB interface, @dev->parent->sem must be held.
152 int device_attach(struct device
* dev
)
158 ret
= device_bind_driver(dev
);
162 ret
= bus_for_each_drv(dev
->bus
, NULL
, dev
, __device_attach
);
167 static int __driver_attach(struct device
* dev
, void * data
)
169 struct device_driver
* drv
= data
;
172 * Lock device and try to bind to it. We drop the error
173 * here and always return 0, because we need to keep trying
174 * to bind to devices and some drivers will return an error
175 * simply if it didn't support the device.
177 * driver_probe_device() will spit a warning if there
181 if (dev
->parent
) /* Needed for USB */
182 down(&dev
->parent
->sem
);
185 driver_probe_device(drv
, dev
);
188 up(&dev
->parent
->sem
);
194 * driver_attach - try to bind driver to devices.
197 * Walk the list of devices that the bus has on it and try to
198 * match the driver with each one. If driver_probe_device()
199 * returns 0 and the @dev->driver is set, we've found a
202 int driver_attach(struct device_driver
* drv
)
204 return bus_for_each_dev(drv
->bus
, NULL
, drv
, __driver_attach
);
208 * device_release_driver - manually detach device from driver.
211 * Manually detach device from driver.
213 * __device_release_driver() must be called with @dev->sem held.
214 * When called for a USB interface, @dev->parent->sem must be held
218 static void __device_release_driver(struct device
* dev
)
220 struct device_driver
* drv
;
225 sysfs_remove_link(&drv
->kobj
, kobject_name(&dev
->kobj
));
226 sysfs_remove_link(&dev
->kobj
, "driver");
227 klist_remove(&dev
->knode_driver
);
229 if (dev
->bus
&& dev
->bus
->remove
)
230 dev
->bus
->remove(dev
);
231 else if (drv
->remove
)
238 void device_release_driver(struct device
* dev
)
241 * If anyone calls device_release_driver() recursively from
242 * within their ->remove callback for the same device, they
243 * will deadlock right here.
246 __device_release_driver(dev
);
252 * driver_detach - detach driver from all devices it controls.
255 void driver_detach(struct device_driver
* drv
)
260 spin_lock(&drv
->klist_devices
.k_lock
);
261 if (list_empty(&drv
->klist_devices
.k_list
)) {
262 spin_unlock(&drv
->klist_devices
.k_lock
);
265 dev
= list_entry(drv
->klist_devices
.k_list
.prev
,
266 struct device
, knode_driver
.n_node
);
268 spin_unlock(&drv
->klist_devices
.k_lock
);
270 if (dev
->parent
) /* Needed for USB */
271 down(&dev
->parent
->sem
);
273 if (dev
->driver
== drv
)
274 __device_release_driver(dev
);
277 up(&dev
->parent
->sem
);
283 EXPORT_SYMBOL_GPL(device_bind_driver
);
284 EXPORT_SYMBOL_GPL(device_release_driver
);
285 EXPORT_SYMBOL_GPL(device_attach
);
286 EXPORT_SYMBOL_GPL(driver_attach
);