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