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> |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 20 | #include <linux/kthread.h> |
Andrew Morton | 735a7ff | 2006-10-27 11:42:37 -0700 | [diff] [blame] | 21 | #include <linux/wait.h> |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 22 | |
| 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 Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 29 | static 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 | |
| 47 | static 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 | |
| 63 | static 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.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 73 | /** |
| 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 Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 84 | * |
| 85 | * This function must be called with @dev->sem held. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 86 | */ |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame] | 87 | int device_bind_driver(struct device *dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 88 | { |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 89 | driver_bound(dev); |
| 90 | return driver_sysfs_add(dev); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 91 | } |
| 92 | |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 93 | struct stupid_thread_structure { |
| 94 | struct device_driver *drv; |
| 95 | struct device *dev; |
| 96 | }; |
| 97 | |
| 98 | static atomic_t probe_count = ATOMIC_INIT(0); |
Andrew Morton | 735a7ff | 2006-10-27 11:42:37 -0700 | [diff] [blame] | 99 | static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); |
| 100 | |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 101 | static int really_probe(void *void_data) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 102 | { |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 103 | struct stupid_thread_structure *data = void_data; |
| 104 | struct device_driver *drv = data->drv; |
| 105 | struct device *dev = data->dev; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 106 | int ret = 0; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 107 | |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 108 | atomic_inc(&probe_count); |
| 109 | pr_debug("%s: Probing driver %s with device %s\n", |
| 110 | drv->bus->name, drv->name, dev->bus_id); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 111 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 112 | dev->driver = drv; |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 113 | if (driver_sysfs_add(dev)) { |
| 114 | printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", |
| 115 | __FUNCTION__, dev->bus_id); |
| 116 | goto probe_failed; |
| 117 | } |
| 118 | |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 119 | if (dev->bus->probe) { |
| 120 | ret = dev->bus->probe(dev); |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 121 | if (ret) |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 122 | goto probe_failed; |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 123 | } else if (drv->probe) { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 124 | ret = drv->probe(dev); |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 125 | if (ret) |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 126 | goto probe_failed; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 127 | } |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 128 | |
| 129 | driver_bound(dev); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 130 | ret = 1; |
| 131 | pr_debug("%s: Bound Device %s to Driver %s\n", |
| 132 | drv->bus->name, dev->bus_id, drv->name); |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 133 | goto done; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 134 | |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 135 | probe_failed: |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 136 | driver_sysfs_remove(dev); |
| 137 | dev->driver = NULL; |
| 138 | |
Cornelia Huck | c578abb | 2006-11-27 10:35:10 +0100 | [diff] [blame^] | 139 | if (ret != -ENODEV && ret != -ENXIO) { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 140 | /* driver matched but the probe failed */ |
| 141 | printk(KERN_WARNING |
| 142 | "%s: probe of %s failed with error %d\n", |
| 143 | drv->name, dev->bus_id, ret); |
| 144 | } |
Cornelia Huck | c578abb | 2006-11-27 10:35:10 +0100 | [diff] [blame^] | 145 | /* |
| 146 | * Ignore errors returned by ->probe so that the next driver can try |
| 147 | * its luck. |
| 148 | */ |
| 149 | ret = 0; |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 150 | done: |
| 151 | kfree(data); |
| 152 | atomic_dec(&probe_count); |
Andrew Morton | 735a7ff | 2006-10-27 11:42:37 -0700 | [diff] [blame] | 153 | wake_up(&probe_waitqueue); |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 154 | return ret; |
| 155 | } |
| 156 | |
| 157 | /** |
| 158 | * driver_probe_done |
| 159 | * Determine if the probe sequence is finished or not. |
| 160 | * |
| 161 | * Should somehow figure out how to use a semaphore, not an atomic variable... |
| 162 | */ |
| 163 | int driver_probe_done(void) |
| 164 | { |
| 165 | pr_debug("%s: probe_count = %d\n", __FUNCTION__, |
| 166 | atomic_read(&probe_count)); |
| 167 | if (atomic_read(&probe_count)) |
| 168 | return -EBUSY; |
| 169 | return 0; |
| 170 | } |
| 171 | |
| 172 | /** |
| 173 | * driver_probe_device - attempt to bind device & driver together |
| 174 | * @drv: driver to bind a device to |
| 175 | * @dev: device to try to bind to the driver |
| 176 | * |
| 177 | * First, we call the bus's match function, if one present, which should |
| 178 | * compare the device IDs the driver supports with the device IDs of the |
| 179 | * device. Note we don't do this ourselves because we don't know the |
| 180 | * format of the ID structures, nor what is to be considered a match and |
| 181 | * what is not. |
| 182 | * |
| 183 | * This function returns 1 if a match is found, an error if one occurs |
| 184 | * (that is not -ENODEV or -ENXIO), and 0 otherwise. |
| 185 | * |
| 186 | * This function must be called with @dev->sem held. When called for a |
| 187 | * USB interface, @dev->parent->sem must be held as well. |
| 188 | */ |
| 189 | int driver_probe_device(struct device_driver * drv, struct device * dev) |
| 190 | { |
| 191 | struct stupid_thread_structure *data; |
| 192 | struct task_struct *probe_task; |
| 193 | int ret = 0; |
| 194 | |
Alan Stern | f2eaae1 | 2006-09-18 16:22:34 -0400 | [diff] [blame] | 195 | if (!device_is_registered(dev)) |
| 196 | return -ENODEV; |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 197 | if (drv->bus->match && !drv->bus->match(dev, drv)) |
| 198 | goto done; |
| 199 | |
| 200 | pr_debug("%s: Matched Device %s with Driver %s\n", |
| 201 | drv->bus->name, dev->bus_id, drv->name); |
| 202 | |
| 203 | data = kmalloc(sizeof(*data), GFP_KERNEL); |
Akinobu Mita | 4d66423 | 2006-10-09 18:04:30 +0900 | [diff] [blame] | 204 | if (!data) |
| 205 | return -ENOMEM; |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 206 | data->drv = drv; |
| 207 | data->dev = dev; |
| 208 | |
| 209 | if (drv->multithread_probe) { |
| 210 | probe_task = kthread_run(really_probe, data, |
| 211 | "probe-%s", dev->bus_id); |
| 212 | if (IS_ERR(probe_task)) |
Duncan Sands | 0fbf116 | 2006-09-27 23:38:08 +0200 | [diff] [blame] | 213 | ret = really_probe(data); |
Greg Kroah-Hartman | d779249 | 2006-07-18 10:59:59 -0700 | [diff] [blame] | 214 | } else |
| 215 | ret = really_probe(data); |
| 216 | |
| 217 | done: |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 218 | return ret; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 219 | } |
| 220 | |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 221 | static int __device_attach(struct device_driver * drv, void * data) |
| 222 | { |
| 223 | struct device * dev = data; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 224 | return driver_probe_device(drv, dev); |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 225 | } |
| 226 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 227 | /** |
| 228 | * device_attach - try to attach device to a driver. |
| 229 | * @dev: device. |
| 230 | * |
| 231 | * Walk the list of drivers that the bus has and call |
| 232 | * driver_probe_device() for each pair. If a compatible |
| 233 | * pair is found, break out and return. |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 234 | * |
Hannes Reinecke | ca2b94b | 2005-05-18 10:42:23 +0200 | [diff] [blame] | 235 | * Returns 1 if the device was bound to a driver; |
| 236 | * 0 if no matching device was found; error code otherwise. |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 237 | * |
| 238 | * 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] | 239 | */ |
| 240 | int device_attach(struct device * dev) |
| 241 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 242 | int ret = 0; |
| 243 | |
| 244 | down(&dev->sem); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 245 | if (dev->driver) { |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame] | 246 | ret = device_bind_driver(dev); |
| 247 | if (ret == 0) |
| 248 | ret = 1; |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 249 | } else |
| 250 | ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); |
| 251 | up(&dev->sem); |
| 252 | return ret; |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | static int __driver_attach(struct device * dev, void * data) |
| 256 | { |
| 257 | struct device_driver * drv = data; |
mochel@digitalimplant.org | 2287c32 | 2005-03-24 10:50:24 -0800 | [diff] [blame] | 258 | |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 259 | /* |
| 260 | * Lock device and try to bind to it. We drop the error |
| 261 | * here and always return 0, because we need to keep trying |
| 262 | * to bind to devices and some drivers will return an error |
| 263 | * simply if it didn't support the device. |
| 264 | * |
| 265 | * driver_probe_device() will spit a warning if there |
| 266 | * is an error. |
| 267 | */ |
| 268 | |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 269 | if (dev->parent) /* Needed for USB */ |
| 270 | down(&dev->parent->sem); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 271 | down(&dev->sem); |
| 272 | if (!dev->driver) |
| 273 | driver_probe_device(drv, dev); |
| 274 | up(&dev->sem); |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 275 | if (dev->parent) |
| 276 | up(&dev->parent->sem); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 277 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 278 | return 0; |
| 279 | } |
| 280 | |
| 281 | /** |
| 282 | * driver_attach - try to bind driver to devices. |
| 283 | * @drv: driver. |
| 284 | * |
| 285 | * Walk the list of devices that the bus has on it and try to |
| 286 | * match the driver with each one. If driver_probe_device() |
| 287 | * returns 0 and the @dev->driver is set, we've found a |
| 288 | * compatible pair. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 289 | */ |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame] | 290 | int driver_attach(struct device_driver * drv) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 291 | { |
Andrew Morton | f86db39 | 2006-08-14 22:43:20 -0700 | [diff] [blame] | 292 | return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | /** |
| 296 | * device_release_driver - manually detach device from driver. |
| 297 | * @dev: device. |
| 298 | * |
| 299 | * Manually detach device from driver. |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 300 | * |
| 301 | * __device_release_driver() must be called with @dev->sem held. |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 302 | * When called for a USB interface, @dev->parent->sem must be held |
| 303 | * as well. |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 304 | */ |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 305 | |
| 306 | static void __device_release_driver(struct device * dev) |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 307 | { |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 308 | struct device_driver * drv; |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 309 | |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 310 | drv = dev->driver; |
| 311 | if (drv) { |
| 312 | get_driver(drv); |
Kay Sievers | 1901fb2 | 2006-10-07 21:55:55 +0200 | [diff] [blame] | 313 | driver_sysfs_remove(dev); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 314 | sysfs_remove_link(&dev->kobj, "driver"); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 315 | klist_remove(&dev->knode_driver); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 316 | |
Benjamin Herrenschmidt | 116af37 | 2006-10-25 13:44:59 +1000 | [diff] [blame] | 317 | if (dev->bus) |
| 318 | blocking_notifier_call_chain(&dev->bus->bus_notifier, |
| 319 | BUS_NOTIFY_UNBIND_DRIVER, |
| 320 | dev); |
| 321 | |
Alan Stern | 0f836ca | 2006-03-31 11:52:25 -0500 | [diff] [blame] | 322 | if (dev->bus && dev->bus->remove) |
Russell King | 594c828 | 2006-01-05 14:29:51 +0000 | [diff] [blame] | 323 | dev->bus->remove(dev); |
| 324 | else if (drv->remove) |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 325 | drv->remove(dev); |
| 326 | dev->driver = NULL; |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 327 | put_driver(drv); |
Patrick Mochel | 0d3e5a2 | 2005-04-05 23:46:33 -0700 | [diff] [blame] | 328 | } |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | void device_release_driver(struct device * dev) |
| 332 | { |
| 333 | /* |
| 334 | * If anyone calls device_release_driver() recursively from |
| 335 | * within their ->remove callback for the same device, they |
| 336 | * will deadlock right here. |
| 337 | */ |
| 338 | down(&dev->sem); |
| 339 | __device_release_driver(dev); |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 340 | up(&dev->sem); |
| 341 | } |
| 342 | |
mochel@digitalimplant.org | 94e7b1c5 | 2005-03-21 12:25:36 -0800 | [diff] [blame] | 343 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 344 | /** |
| 345 | * driver_detach - detach driver from all devices it controls. |
| 346 | * @drv: driver. |
| 347 | */ |
| 348 | void driver_detach(struct device_driver * drv) |
| 349 | { |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 350 | struct device * dev; |
| 351 | |
| 352 | for (;;) { |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 353 | spin_lock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 354 | if (list_empty(&drv->klist_devices.k_list)) { |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 355 | spin_unlock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 356 | break; |
| 357 | } |
| 358 | dev = list_entry(drv->klist_devices.k_list.prev, |
| 359 | struct device, knode_driver.n_node); |
| 360 | get_device(dev); |
Alan Stern | 2b08c8d | 2005-11-23 15:43:50 -0800 | [diff] [blame] | 361 | spin_unlock(&drv->klist_devices.k_lock); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 362 | |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 363 | if (dev->parent) /* Needed for USB */ |
| 364 | down(&dev->parent->sem); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 365 | down(&dev->sem); |
| 366 | if (dev->driver == drv) |
| 367 | __device_release_driver(dev); |
| 368 | up(&dev->sem); |
Alan Stern | bf74ad5 | 2005-11-17 16:54:12 -0500 | [diff] [blame] | 369 | if (dev->parent) |
| 370 | up(&dev->parent->sem); |
Alan Stern | c95a6b0 | 2005-05-06 15:38:33 -0400 | [diff] [blame] | 371 | put_device(dev); |
| 372 | } |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 373 | } |
| 374 | |
Andrew Morton | 735a7ff | 2006-10-27 11:42:37 -0700 | [diff] [blame] | 375 | #ifdef CONFIG_PCI_MULTITHREAD_PROBE |
| 376 | static int __init wait_for_probes(void) |
| 377 | { |
| 378 | DEFINE_WAIT(wait); |
| 379 | |
| 380 | printk(KERN_INFO "%s: waiting for %d threads\n", __FUNCTION__, |
| 381 | atomic_read(&probe_count)); |
| 382 | if (!atomic_read(&probe_count)) |
| 383 | return 0; |
| 384 | while (atomic_read(&probe_count)) { |
| 385 | prepare_to_wait(&probe_waitqueue, &wait, TASK_UNINTERRUPTIBLE); |
| 386 | if (atomic_read(&probe_count)) |
| 387 | schedule(); |
| 388 | } |
| 389 | finish_wait(&probe_waitqueue, &wait); |
| 390 | return 0; |
| 391 | } |
| 392 | |
| 393 | core_initcall_sync(wait_for_probes); |
| 394 | postcore_initcall_sync(wait_for_probes); |
| 395 | arch_initcall_sync(wait_for_probes); |
| 396 | subsys_initcall_sync(wait_for_probes); |
| 397 | fs_initcall_sync(wait_for_probes); |
| 398 | device_initcall_sync(wait_for_probes); |
| 399 | late_initcall_sync(wait_for_probes); |
| 400 | #endif |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 401 | |
mochel@digitalimplant.org | 07e4a3e | 2005-03-21 10:52:54 -0800 | [diff] [blame] | 402 | EXPORT_SYMBOL_GPL(device_bind_driver); |
| 403 | EXPORT_SYMBOL_GPL(device_release_driver); |
| 404 | EXPORT_SYMBOL_GPL(device_attach); |
| 405 | EXPORT_SYMBOL_GPL(driver_attach); |
| 406 | |