mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 1 | /* |
| 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> |
| 20 | |
| 21 | #include "base.h" |
| 22 | #include "power/power.h" |
| 23 | |
| 24 | #define to_drv(node) container_of(node, struct device_driver, kobj.entry) |
| 25 | |
| 26 | |
| 27 | /** |
| 28 | * device_bind_driver - bind a driver to one device. |
| 29 | * @dev: device. |
| 30 | * |
| 31 | * Allow manual attachment of a driver to a device. |
| 32 | * Caller must have already set @dev->driver. |
| 33 | * |
| 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.) |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 38 | * |
| 39 | * This function must be called with @dev->sem held. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 40 | */ |
| 41 | void device_bind_driver(struct device * dev) |
| 42 | { |
Daniel Ritz | 4c898c7 | 2005-09-22 00:47:11 -0700 | [diff] [blame] | 43 | if (klist_node_attached(&dev->knode_driver)) |
| 44 | return; |
| 45 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 46 | pr_debug("bound device '%s' to driver '%s'\n", |
| 47 | dev->bus_id, dev->driver->name); |
James Bottomley | d856f1e3 | 2005-08-19 09:14:01 -0400 | [diff] [blame] | 48 | klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 49 | sysfs_create_link(&dev->driver->kobj, &dev->kobj, |
| 50 | kobject_name(&dev->kobj)); |
| 51 | sysfs_create_link(&dev->kobj, &dev->driver->kobj, "driver"); |
| 52 | } |
| 53 | |
| 54 | /** |
| 55 | * driver_probe_device - attempt to bind device & driver. |
| 56 | * @drv: driver. |
| 57 | * @dev: device. |
| 58 | * |
| 59 | * First, we call the bus's match function, if one present, which |
| 60 | * should compare the device IDs the driver supports with the |
| 61 | * device IDs of the device. Note we don't do this ourselves |
| 62 | * because we don't know the format of the ID structures, nor what |
| 63 | * is to be considered a match and what is not. |
| 64 | * |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 65 | * This function returns 1 if a match is found, an error if one |
| 66 | * occurs (that is not -ENODEV or -ENXIO), and 0 otherwise. |
| 67 | * |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 68 | * This function must be called with @dev->sem held. When called |
| 69 | * for a USB interface, @dev->parent->sem must be held as well. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 70 | */ |
Greg Kroah-Hartman | afdce75 | 2005-06-22 16:09:05 -0700 | [diff] [blame] | 71 | int driver_probe_device(struct device_driver * drv, struct device * dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 72 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 73 | int ret = 0; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 74 | |
| 75 | if (drv->bus->match && !drv->bus->match(dev, drv)) |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 76 | goto Done; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 77 | |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 78 | pr_debug("%s: Matched Device %s with Driver %s\n", |
| 79 | drv->bus->name, dev->bus_id, drv->name); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 80 | dev->driver = drv; |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 81 | if (dev->bus->probe) { |
| 82 | ret = dev->bus->probe(dev); |
| 83 | if (ret) { |
| 84 | dev->driver = NULL; |
| 85 | goto ProbeFailed; |
| 86 | } |
| 87 | } else if (drv->probe) { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 88 | ret = drv->probe(dev); |
| 89 | if (ret) { |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 90 | dev->driver = NULL; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 91 | goto ProbeFailed; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 92 | } |
| 93 | } |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 94 | device_bind_driver(dev); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 95 | ret = 1; |
| 96 | pr_debug("%s: Bound Device %s to Driver %s\n", |
| 97 | drv->bus->name, dev->bus_id, drv->name); |
| 98 | goto Done; |
| 99 | |
| 100 | ProbeFailed: |
| 101 | if (ret == -ENODEV || ret == -ENXIO) { |
| 102 | /* Driver matched, but didn't support device |
| 103 | * or device not found. |
| 104 | * Not an error; keep going. |
| 105 | */ |
| 106 | ret = 0; |
| 107 | } else { |
| 108 | /* driver matched but the probe failed */ |
| 109 | printk(KERN_WARNING |
| 110 | "%s: probe of %s failed with error %d\n", |
| 111 | drv->name, dev->bus_id, ret); |
| 112 | } |
| 113 | Done: |
| 114 | return ret; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 115 | } |
| 116 | |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 117 | static int __device_attach(struct device_driver * drv, void * data) |
| 118 | { |
| 119 | struct device * dev = data; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 120 | return driver_probe_device(drv, dev); |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 121 | } |
| 122 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 123 | /** |
| 124 | * device_attach - try to attach device to a driver. |
| 125 | * @dev: device. |
| 126 | * |
| 127 | * Walk the list of drivers that the bus has and call |
| 128 | * driver_probe_device() for each pair. If a compatible |
| 129 | * pair is found, break out and return. |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 130 | * |
Hannes Reinecke | ca2b94b | 2005-05-18 10:42:23 +0200 | [diff] [blame] | 131 | * Returns 1 if the device was bound to a driver; |
| 132 | * 0 if no matching device was found; error code otherwise. |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 133 | * |
| 134 | * When called for a USB interface, @dev->parent->sem must be held. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 135 | */ |
| 136 | int device_attach(struct device * dev) |
| 137 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 138 | int ret = 0; |
| 139 | |
| 140 | down(&dev->sem); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 141 | if (dev->driver) { |
| 142 | device_bind_driver(dev); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 143 | ret = 1; |
| 144 | } else |
| 145 | ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); |
| 146 | up(&dev->sem); |
| 147 | return ret; |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | static int __driver_attach(struct device * dev, void * data) |
| 151 | { |
| 152 | struct device_driver * drv = data; |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 153 | |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 154 | /* |
| 155 | * Lock device and try to bind to it. We drop the error |
| 156 | * here and always return 0, because we need to keep trying |
| 157 | * to bind to devices and some drivers will return an error |
| 158 | * simply if it didn't support the device. |
| 159 | * |
| 160 | * driver_probe_device() will spit a warning if there |
| 161 | * is an error. |
| 162 | */ |
| 163 | |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 164 | if (dev->parent) /* Needed for USB */ |
| 165 | down(&dev->parent->sem); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 166 | down(&dev->sem); |
| 167 | if (!dev->driver) |
| 168 | driver_probe_device(drv, dev); |
| 169 | up(&dev->sem); |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 170 | if (dev->parent) |
| 171 | up(&dev->parent->sem); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 172 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 173 | return 0; |
| 174 | } |
| 175 | |
| 176 | /** |
| 177 | * driver_attach - try to bind driver to devices. |
| 178 | * @drv: driver. |
| 179 | * |
| 180 | * Walk the list of devices that the bus has on it and try to |
| 181 | * match the driver with each one. If driver_probe_device() |
| 182 | * returns 0 and the @dev->driver is set, we've found a |
| 183 | * compatible pair. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 184 | */ |
| 185 | void driver_attach(struct device_driver * drv) |
| 186 | { |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 187 | bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | /** |
| 191 | * device_release_driver - manually detach device from driver. |
| 192 | * @dev: device. |
| 193 | * |
| 194 | * Manually detach device from driver. |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 195 | * |
| 196 | * __device_release_driver() must be called with @dev->sem held. |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 197 | * When called for a USB interface, @dev->parent->sem must be held |
| 198 | * as well. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 199 | */ |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 200 | |
| 201 | static void __device_release_driver(struct device * dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 202 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 203 | struct device_driver * drv; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 204 | |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 205 | drv = dev->driver; |
| 206 | if (drv) { |
| 207 | get_driver(drv); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 208 | sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj)); |
| 209 | sysfs_remove_link(&dev->kobj, "driver"); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 210 | klist_remove(&dev->knode_driver); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 211 | |
Alan Stern | 0f836ca | 2006-03-31 11:52:25 -0500 | [diff] [blame] | 212 | if (dev->bus && dev->bus->remove) |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 213 | dev->bus->remove(dev); |
| 214 | else if (drv->remove) |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 215 | drv->remove(dev); |
| 216 | dev->driver = NULL; |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 217 | put_driver(drv); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 218 | } |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | void device_release_driver(struct device * dev) |
| 222 | { |
| 223 | /* |
| 224 | * If anyone calls device_release_driver() recursively from |
| 225 | * within their ->remove callback for the same device, they |
| 226 | * will deadlock right here. |
| 227 | */ |
| 228 | down(&dev->sem); |
| 229 | __device_release_driver(dev); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 230 | up(&dev->sem); |
| 231 | } |
| 232 | |
mochel@digitalimplant.org | 94e7b1c5 | 2005-03-21 12:25:36 -0800 | [diff] [blame] | 233 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 234 | /** |
| 235 | * driver_detach - detach driver from all devices it controls. |
| 236 | * @drv: driver. |
| 237 | */ |
| 238 | void driver_detach(struct device_driver * drv) |
| 239 | { |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 240 | struct device * dev; |
| 241 | |
| 242 | for (;;) { |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 243 | spin_lock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 244 | if (list_empty(&drv->klist_devices.k_list)) { |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 245 | spin_unlock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 246 | break; |
| 247 | } |
| 248 | dev = list_entry(drv->klist_devices.k_list.prev, |
| 249 | struct device, knode_driver.n_node); |
| 250 | get_device(dev); |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 251 | spin_unlock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 252 | |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 253 | if (dev->parent) /* Needed for USB */ |
| 254 | down(&dev->parent->sem); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 255 | down(&dev->sem); |
| 256 | if (dev->driver == drv) |
| 257 | __device_release_driver(dev); |
| 258 | up(&dev->sem); |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 259 | if (dev->parent) |
| 260 | up(&dev->parent->sem); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 261 | put_device(dev); |
| 262 | } |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 266 | EXPORT_SYMBOL_GPL(device_bind_driver); |
| 267 | EXPORT_SYMBOL_GPL(device_release_driver); |
| 268 | EXPORT_SYMBOL_GPL(device_attach); |
| 269 | EXPORT_SYMBOL_GPL(driver_attach); |
| 270 | |