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