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 | */ |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 41 | int device_bind_driver(struct device *dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 42 | { |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 43 | int ret; |
| 44 | |
| 45 | if (klist_node_attached(&dev->knode_driver)) { |
| 46 | printk(KERN_WARNING "%s: device %s already bound\n", |
| 47 | __FUNCTION__, kobject_name(&dev->kobj)); |
| 48 | return 0; |
| 49 | } |
Daniel Ritz | 4c898c7 | 2005-09-22 00:47:11 -0700 | [diff] [blame] | 50 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 51 | pr_debug("bound device '%s' to driver '%s'\n", |
| 52 | dev->bus_id, dev->driver->name); |
James Bottomley | d856f1e3 | 2005-08-19 09:14:01 -0400 | [diff] [blame] | 53 | klist_add_tail(&dev->knode_driver, &dev->driver->klist_devices); |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 54 | ret = sysfs_create_link(&dev->driver->kobj, &dev->kobj, |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 55 | kobject_name(&dev->kobj)); |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 56 | if (ret == 0) { |
| 57 | ret = sysfs_create_link(&dev->kobj, &dev->driver->kobj, |
| 58 | "driver"); |
| 59 | if (ret) |
| 60 | sysfs_remove_link(&dev->driver->kobj, |
| 61 | kobject_name(&dev->kobj)); |
| 62 | } |
| 63 | return ret; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 64 | } |
| 65 | |
| 66 | /** |
| 67 | * driver_probe_device - attempt to bind device & driver. |
| 68 | * @drv: driver. |
| 69 | * @dev: device. |
| 70 | * |
| 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. |
| 76 | * |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 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. |
| 79 | * |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 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. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 82 | */ |
Greg Kroah-Hartman | afdce75 | 2005-06-22 16:09:05 -0700 | [diff] [blame] | 83 | int driver_probe_device(struct device_driver * drv, struct device * dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 84 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 85 | int ret = 0; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 86 | |
| 87 | if (drv->bus->match && !drv->bus->match(dev, drv)) |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 88 | goto Done; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 89 | |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 90 | pr_debug("%s: Matched Device %s with Driver %s\n", |
| 91 | drv->bus->name, dev->bus_id, drv->name); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 92 | dev->driver = drv; |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 93 | if (dev->bus->probe) { |
| 94 | ret = dev->bus->probe(dev); |
| 95 | if (ret) { |
| 96 | dev->driver = NULL; |
| 97 | goto ProbeFailed; |
| 98 | } |
| 99 | } else if (drv->probe) { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 100 | ret = drv->probe(dev); |
| 101 | if (ret) { |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 102 | dev->driver = NULL; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 103 | goto ProbeFailed; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 104 | } |
| 105 | } |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 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. */ |
| 110 | } |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 111 | ret = 1; |
| 112 | pr_debug("%s: Bound Device %s to Driver %s\n", |
| 113 | drv->bus->name, dev->bus_id, drv->name); |
| 114 | goto Done; |
| 115 | |
| 116 | ProbeFailed: |
| 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. |
| 121 | */ |
| 122 | ret = 0; |
| 123 | } else { |
| 124 | /* driver matched but the probe failed */ |
| 125 | printk(KERN_WARNING |
| 126 | "%s: probe of %s failed with error %d\n", |
| 127 | drv->name, dev->bus_id, ret); |
| 128 | } |
| 129 | Done: |
| 130 | return ret; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 131 | } |
| 132 | |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 133 | static int __device_attach(struct device_driver * drv, void * data) |
| 134 | { |
| 135 | struct device * dev = data; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 136 | return driver_probe_device(drv, dev); |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 137 | } |
| 138 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 139 | /** |
| 140 | * device_attach - try to attach device to a driver. |
| 141 | * @dev: device. |
| 142 | * |
| 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. |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 146 | * |
Hannes Reinecke | ca2b94b | 2005-05-18 10:42:23 +0200 | [diff] [blame] | 147 | * Returns 1 if the device was bound to a driver; |
| 148 | * 0 if no matching device was found; error code otherwise. |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 149 | * |
| 150 | * 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] | 151 | */ |
| 152 | int device_attach(struct device * dev) |
| 153 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 154 | int ret = 0; |
| 155 | |
| 156 | down(&dev->sem); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 157 | if (dev->driver) { |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 158 | ret = device_bind_driver(dev); |
| 159 | if (ret == 0) |
| 160 | ret = 1; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 161 | } else |
| 162 | ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); |
| 163 | up(&dev->sem); |
| 164 | return ret; |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 165 | } |
| 166 | |
| 167 | static int __driver_attach(struct device * dev, void * data) |
| 168 | { |
| 169 | struct device_driver * drv = data; |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 170 | |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 171 | /* |
| 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. |
| 176 | * |
| 177 | * driver_probe_device() will spit a warning if there |
| 178 | * is an error. |
| 179 | */ |
| 180 | |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 181 | if (dev->parent) /* Needed for USB */ |
| 182 | down(&dev->parent->sem); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 183 | down(&dev->sem); |
| 184 | if (!dev->driver) |
| 185 | driver_probe_device(drv, dev); |
| 186 | up(&dev->sem); |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 187 | if (dev->parent) |
| 188 | up(&dev->parent->sem); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 189 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 190 | return 0; |
| 191 | } |
| 192 | |
| 193 | /** |
| 194 | * driver_attach - try to bind driver to devices. |
| 195 | * @drv: driver. |
| 196 | * |
| 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 |
| 200 | * compatible pair. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 201 | */ |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 202 | int driver_attach(struct device_driver * drv) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 203 | { |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame^] | 204 | return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | /** |
| 208 | * device_release_driver - manually detach device from driver. |
| 209 | * @dev: device. |
| 210 | * |
| 211 | * Manually detach device from driver. |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 212 | * |
| 213 | * __device_release_driver() must be called with @dev->sem held. |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 214 | * When called for a USB interface, @dev->parent->sem must be held |
| 215 | * as well. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 216 | */ |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 217 | |
| 218 | static void __device_release_driver(struct device * dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 219 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 220 | struct device_driver * drv; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 221 | |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 222 | drv = dev->driver; |
| 223 | if (drv) { |
| 224 | get_driver(drv); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 225 | sysfs_remove_link(&drv->kobj, kobject_name(&dev->kobj)); |
| 226 | sysfs_remove_link(&dev->kobj, "driver"); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 227 | klist_remove(&dev->knode_driver); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 228 | |
Alan Stern | 0f836ca | 2006-03-31 11:52:25 -0500 | [diff] [blame] | 229 | if (dev->bus && dev->bus->remove) |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 230 | dev->bus->remove(dev); |
| 231 | else if (drv->remove) |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 232 | drv->remove(dev); |
| 233 | dev->driver = NULL; |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 234 | put_driver(drv); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 235 | } |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 236 | } |
| 237 | |
| 238 | void device_release_driver(struct device * dev) |
| 239 | { |
| 240 | /* |
| 241 | * If anyone calls device_release_driver() recursively from |
| 242 | * within their ->remove callback for the same device, they |
| 243 | * will deadlock right here. |
| 244 | */ |
| 245 | down(&dev->sem); |
| 246 | __device_release_driver(dev); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 247 | up(&dev->sem); |
| 248 | } |
| 249 | |
mochel@digitalimplant.org | 94e7b1c5 | 2005-03-21 12:25:36 -0800 | [diff] [blame] | 250 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 251 | /** |
| 252 | * driver_detach - detach driver from all devices it controls. |
| 253 | * @drv: driver. |
| 254 | */ |
| 255 | void driver_detach(struct device_driver * drv) |
| 256 | { |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 257 | struct device * dev; |
| 258 | |
| 259 | for (;;) { |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 260 | spin_lock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 261 | if (list_empty(&drv->klist_devices.k_list)) { |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 262 | spin_unlock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 263 | break; |
| 264 | } |
| 265 | dev = list_entry(drv->klist_devices.k_list.prev, |
| 266 | struct device, knode_driver.n_node); |
| 267 | get_device(dev); |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 268 | spin_unlock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 269 | |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 270 | if (dev->parent) /* Needed for USB */ |
| 271 | down(&dev->parent->sem); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 272 | down(&dev->sem); |
| 273 | if (dev->driver == drv) |
| 274 | __device_release_driver(dev); |
| 275 | up(&dev->sem); |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 276 | if (dev->parent) |
| 277 | up(&dev->parent->sem); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 278 | put_device(dev); |
| 279 | } |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 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); |
| 287 | |