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->p->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->p->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 void wait_for_device_probe(void) 177 { 178 /* wait for the known devices to complete their probing */ 179 wait_event(probe_waitqueue, atomic_read(&probe_count) == 0); 180 async_synchronize_full(); 181 } 182 EXPORT_SYMBOL_GPL(wait_for_device_probe); 183 184 /** 185 * driver_probe_device - attempt to bind device & driver together 186 * @drv: driver to bind a device to 187 * @dev: device to try to bind to the driver 188 * 189 * This function returns -ENODEV if the device is not registered, 190 * 1 if the device is bound sucessfully 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 int ret = 0; 198 199 if (!device_is_registered(dev)) 200 return -ENODEV; 201 202 pr_debug("bus: '%s': %s: matched device %s with driver %s\n", 203 drv->bus->name, __func__, dev_name(dev), drv->name); 204 205 ret = really_probe(dev, drv); 206 207 return ret; 208 } 209 210 static int __device_attach(struct device_driver *drv, void *data) 211 { 212 struct device *dev = data; 213 214 if (!driver_match_device(drv, dev)) 215 return 0; 216 217 return driver_probe_device(drv, dev); 218 } 219 220 /** 221 * device_attach - try to attach device to a driver. 222 * @dev: device. 223 * 224 * Walk the list of drivers that the bus has and call 225 * driver_probe_device() for each pair. If a compatible 226 * pair is found, break out and return. 227 * 228 * Returns 1 if the device was bound to a driver; 229 * 0 if no matching device was found; 230 * -ENODEV if the device is not registered. 231 * 232 * When called for a USB interface, @dev->parent->sem must be held. 233 */ 234 int device_attach(struct device *dev) 235 { 236 int ret = 0; 237 238 down(&dev->sem); 239 if (dev->driver) { 240 ret = device_bind_driver(dev); 241 if (ret == 0) 242 ret = 1; 243 else { 244 dev->driver = NULL; 245 ret = 0; 246 } 247 } else { 248 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); 249 } 250 up(&dev->sem); 251 return ret; 252 } 253 EXPORT_SYMBOL_GPL(device_attach); 254 255 static int __driver_attach(struct device *dev, void *data) 256 { 257 struct device_driver *drv = data; 258 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 269 if (!driver_match_device(drv, dev)) 270 return 0; 271 272 if (dev->parent) /* Needed for USB */ 273 down(&dev->parent->sem); 274 down(&dev->sem); 275 if (!dev->driver) 276 driver_probe_device(drv, dev); 277 up(&dev->sem); 278 if (dev->parent) 279 up(&dev->parent->sem); 280 281 return 0; 282 } 283 284 /** 285 * driver_attach - try to bind driver to devices. 286 * @drv: driver. 287 * 288 * Walk the list of devices that the bus has on it and try to 289 * match the driver with each one. If driver_probe_device() 290 * returns 0 and the @dev->driver is set, we've found a 291 * compatible pair. 292 */ 293 int driver_attach(struct device_driver *drv) 294 { 295 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 296 } 297 EXPORT_SYMBOL_GPL(driver_attach); 298 299 /* 300 * __device_release_driver() must be called with @dev->sem held. 301 * When called for a USB interface, @dev->parent->sem must be held as well. 302 */ 303 static void __device_release_driver(struct device *dev) 304 { 305 struct device_driver *drv; 306 307 drv = dev->driver; 308 if (drv) { 309 driver_sysfs_remove(dev); 310 311 if (dev->bus) 312 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 313 BUS_NOTIFY_UNBIND_DRIVER, 314 dev); 315 316 if (dev->bus && dev->bus->remove) 317 dev->bus->remove(dev); 318 else if (drv->remove) 319 drv->remove(dev); 320 devres_release_all(dev); 321 dev->driver = NULL; 322 klist_remove(&dev->p->knode_driver); 323 } 324 } 325 326 /** 327 * device_release_driver - manually detach device from driver. 328 * @dev: device. 329 * 330 * Manually detach device from driver. 331 * When called for a USB interface, @dev->parent->sem must be held. 332 */ 333 void device_release_driver(struct device *dev) 334 { 335 /* 336 * If anyone calls device_release_driver() recursively from 337 * within their ->remove callback for the same device, they 338 * will deadlock right here. 339 */ 340 down(&dev->sem); 341 __device_release_driver(dev); 342 up(&dev->sem); 343 } 344 EXPORT_SYMBOL_GPL(device_release_driver); 345 346 /** 347 * driver_detach - detach driver from all devices it controls. 348 * @drv: driver. 349 */ 350 void driver_detach(struct device_driver *drv) 351 { 352 struct device_private *dev_prv; 353 struct device *dev; 354 355 for (;;) { 356 spin_lock(&drv->p->klist_devices.k_lock); 357 if (list_empty(&drv->p->klist_devices.k_list)) { 358 spin_unlock(&drv->p->klist_devices.k_lock); 359 break; 360 } 361 dev_prv = list_entry(drv->p->klist_devices.k_list.prev, 362 struct device_private, 363 knode_driver.n_node); 364 dev = dev_prv->device; 365 get_device(dev); 366 spin_unlock(&drv->p->klist_devices.k_lock); 367 368 if (dev->parent) /* Needed for USB */ 369 down(&dev->parent->sem); 370 down(&dev->sem); 371 if (dev->driver == drv) 372 __device_release_driver(dev); 373 up(&dev->sem); 374 if (dev->parent) 375 up(&dev->parent->sem); 376 put_device(dev); 377 } 378 } 379