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 * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de> 15 * Copyright (c) 2007 Novell Inc. 16 * 17 * This file is released under the GPLv2 18 */ 19 20 #include <linux/device.h> 21 #include <linux/delay.h> 22 #include <linux/module.h> 23 #include <linux/kthread.h> 24 #include <linux/wait.h> 25 #include <linux/async.h> 26 27 #include "base.h" 28 #include "power/power.h" 29 30 31 static void driver_bound(struct device *dev) 32 { 33 if (klist_node_attached(&dev->knode_driver)) { 34 printk(KERN_WARNING "%s: device %s already bound\n", 35 __func__, kobject_name(&dev->kobj)); 36 return; 37 } 38 39 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev), 40 __func__, dev->driver->name); 41 42 if (dev->bus) 43 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 44 BUS_NOTIFY_BOUND_DRIVER, dev); 45 46 klist_add_tail(&dev->knode_driver, &dev->driver->p->klist_devices); 47 } 48 49 static int driver_sysfs_add(struct device *dev) 50 { 51 int ret; 52 53 ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj, 54 kobject_name(&dev->kobj)); 55 if (ret == 0) { 56 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj, 57 "driver"); 58 if (ret) 59 sysfs_remove_link(&dev->driver->p->kobj, 60 kobject_name(&dev->kobj)); 61 } 62 return ret; 63 } 64 65 static void driver_sysfs_remove(struct device *dev) 66 { 67 struct device_driver *drv = dev->driver; 68 69 if (drv) { 70 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj)); 71 sysfs_remove_link(&dev->kobj, "driver"); 72 } 73 } 74 75 /** 76 * device_bind_driver - bind a driver to one device. 77 * @dev: device. 78 * 79 * Allow manual attachment of a driver to a device. 80 * Caller must have already set @dev->driver. 81 * 82 * Note that this does not modify the bus reference count 83 * nor take the bus's rwsem. Please verify those are accounted 84 * for before calling this. (It is ok to call with no other effort 85 * from a driver's probe() method.) 86 * 87 * This function must be called with @dev->sem held. 88 */ 89 int device_bind_driver(struct device *dev) 90 { 91 int ret; 92 93 ret = driver_sysfs_add(dev); 94 if (!ret) 95 driver_bound(dev); 96 return ret; 97 } 98 EXPORT_SYMBOL_GPL(device_bind_driver); 99 100 static atomic_t probe_count = ATOMIC_INIT(0); 101 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); 102 103 static int really_probe(struct device *dev, struct device_driver *drv) 104 { 105 int ret = 0; 106 107 atomic_inc(&probe_count); 108 pr_debug("bus: '%s': %s: probing driver %s with device %s\n", 109 drv->bus->name, __func__, drv->name, dev_name(dev)); 110 WARN_ON(!list_empty(&dev->devres_head)); 111 112 dev->driver = drv; 113 if (driver_sysfs_add(dev)) { 114 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", 115 __func__, dev_name(dev)); 116 goto probe_failed; 117 } 118 119 if (dev->bus->probe) { 120 ret = dev->bus->probe(dev); 121 if (ret) 122 goto probe_failed; 123 } else if (drv->probe) { 124 ret = drv->probe(dev); 125 if (ret) 126 goto probe_failed; 127 } 128 129 driver_bound(dev); 130 ret = 1; 131 pr_debug("bus: '%s': %s: bound device %s to driver %s\n", 132 drv->bus->name, __func__, dev_name(dev), drv->name); 133 goto done; 134 135 probe_failed: 136 devres_release_all(dev); 137 driver_sysfs_remove(dev); 138 dev->driver = NULL; 139 140 if (ret != -ENODEV && ret != -ENXIO) { 141 /* driver matched but the probe failed */ 142 printk(KERN_WARNING 143 "%s: probe of %s failed with error %d\n", 144 drv->name, dev_name(dev), ret); 145 } 146 /* 147 * Ignore errors returned by ->probe so that the next driver can try 148 * its luck. 149 */ 150 ret = 0; 151 done: 152 atomic_dec(&probe_count); 153 wake_up(&probe_waitqueue); 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", __func__, 166 atomic_read(&probe_count)); 167 if (atomic_read(&probe_count)) 168 return -EBUSY; 169 return 0; 170 } 171 172 /** 173 * wait_for_device_probe 174 * Wait for device probing to be completed. 175 * 176 * Note: this function polls at 100 msec intervals. 177 */ 178 int wait_for_device_probe(void) 179 { 180 /* wait for the known devices to complete their probing */ 181 while (driver_probe_done() != 0) 182 msleep(100); 183 async_synchronize_full(); 184 return 0; 185 } 186 187 /** 188 * driver_probe_device - attempt to bind device & driver together 189 * @drv: driver to bind a device to 190 * @dev: device to try to bind to the driver 191 * 192 * First, we call the bus's match function, if one present, which should 193 * compare the device IDs the driver supports with the device IDs of the 194 * device. Note we don't do this ourselves because we don't know the 195 * format of the ID structures, nor what is to be considered a match and 196 * what is not. 197 * 198 * This function returns 1 if a match is found, -ENODEV if the device is 199 * not registered, and 0 otherwise. 200 * 201 * This function must be called with @dev->sem held. When called for a 202 * USB interface, @dev->parent->sem must be held as well. 203 */ 204 int driver_probe_device(struct device_driver *drv, struct device *dev) 205 { 206 int ret = 0; 207 208 if (!device_is_registered(dev)) 209 return -ENODEV; 210 if (drv->bus->match && !drv->bus->match(dev, drv)) 211 goto done; 212 213 pr_debug("bus: '%s': %s: matched device %s with driver %s\n", 214 drv->bus->name, __func__, dev_name(dev), drv->name); 215 216 ret = really_probe(dev, drv); 217 218 done: 219 return ret; 220 } 221 222 static int __device_attach(struct device_driver *drv, void *data) 223 { 224 struct device *dev = data; 225 return driver_probe_device(drv, dev); 226 } 227 228 /** 229 * device_attach - try to attach device to a driver. 230 * @dev: device. 231 * 232 * Walk the list of drivers that the bus has and call 233 * driver_probe_device() for each pair. If a compatible 234 * pair is found, break out and return. 235 * 236 * Returns 1 if the device was bound to a driver; 237 * 0 if no matching device was found; 238 * -ENODEV if the device is not registered. 239 * 240 * When called for a USB interface, @dev->parent->sem must be held. 241 */ 242 int device_attach(struct device *dev) 243 { 244 int ret = 0; 245 246 down(&dev->sem); 247 if (dev->driver) { 248 ret = device_bind_driver(dev); 249 if (ret == 0) 250 ret = 1; 251 else { 252 dev->driver = NULL; 253 ret = 0; 254 } 255 } else { 256 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); 257 } 258 up(&dev->sem); 259 return ret; 260 } 261 EXPORT_SYMBOL_GPL(device_attach); 262 263 static int __driver_attach(struct device *dev, void *data) 264 { 265 struct device_driver *drv = data; 266 267 /* 268 * Lock device and try to bind to it. We drop the error 269 * here and always return 0, because we need to keep trying 270 * to bind to devices and some drivers will return an error 271 * simply if it didn't support the device. 272 * 273 * driver_probe_device() will spit a warning if there 274 * is an error. 275 */ 276 277 if (drv->bus->match && !drv->bus->match(dev, drv)) 278 return 0; 279 280 if (dev->parent) /* Needed for USB */ 281 down(&dev->parent->sem); 282 down(&dev->sem); 283 if (!dev->driver) 284 driver_probe_device(drv, dev); 285 up(&dev->sem); 286 if (dev->parent) 287 up(&dev->parent->sem); 288 289 return 0; 290 } 291 292 /** 293 * driver_attach - try to bind driver to devices. 294 * @drv: driver. 295 * 296 * Walk the list of devices that the bus has on it and try to 297 * match the driver with each one. If driver_probe_device() 298 * returns 0 and the @dev->driver is set, we've found a 299 * compatible pair. 300 */ 301 int driver_attach(struct device_driver *drv) 302 { 303 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 304 } 305 EXPORT_SYMBOL_GPL(driver_attach); 306 307 /* 308 * __device_release_driver() must be called with @dev->sem held. 309 * When called for a USB interface, @dev->parent->sem must be held as well. 310 */ 311 static void __device_release_driver(struct device *dev) 312 { 313 struct device_driver *drv; 314 315 drv = dev->driver; 316 if (drv) { 317 driver_sysfs_remove(dev); 318 319 if (dev->bus) 320 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 321 BUS_NOTIFY_UNBIND_DRIVER, 322 dev); 323 324 if (dev->bus && dev->bus->remove) 325 dev->bus->remove(dev); 326 else if (drv->remove) 327 drv->remove(dev); 328 devres_release_all(dev); 329 dev->driver = NULL; 330 klist_remove(&dev->knode_driver); 331 } 332 } 333 334 /** 335 * device_release_driver - manually detach device from driver. 336 * @dev: device. 337 * 338 * Manually detach device from driver. 339 * When called for a USB interface, @dev->parent->sem must be held. 340 */ 341 void device_release_driver(struct device *dev) 342 { 343 /* 344 * If anyone calls device_release_driver() recursively from 345 * within their ->remove callback for the same device, they 346 * will deadlock right here. 347 */ 348 down(&dev->sem); 349 __device_release_driver(dev); 350 up(&dev->sem); 351 } 352 EXPORT_SYMBOL_GPL(device_release_driver); 353 354 /** 355 * driver_detach - detach driver from all devices it controls. 356 * @drv: driver. 357 */ 358 void driver_detach(struct device_driver *drv) 359 { 360 struct device *dev; 361 362 for (;;) { 363 spin_lock(&drv->p->klist_devices.k_lock); 364 if (list_empty(&drv->p->klist_devices.k_list)) { 365 spin_unlock(&drv->p->klist_devices.k_lock); 366 break; 367 } 368 dev = list_entry(drv->p->klist_devices.k_list.prev, 369 struct device, knode_driver.n_node); 370 get_device(dev); 371 spin_unlock(&drv->p->klist_devices.k_lock); 372 373 if (dev->parent) /* Needed for USB */ 374 down(&dev->parent->sem); 375 down(&dev->sem); 376 if (dev->driver == drv) 377 __device_release_driver(dev); 378 up(&dev->sem); 379 if (dev->parent) 380 up(&dev->parent->sem); 381 put_device(dev); 382 } 383 } 384