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/module.h> 22 #include <linux/kthread.h> 23 #include <linux/wait.h> 24 25 #include "base.h" 26 #include "power/power.h" 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 __func__, kobject_name(&dev->kobj)); 34 return; 35 } 36 37 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->bus_id, 38 __func__, dev->driver->name); 39 40 if (dev->bus) 41 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 42 BUS_NOTIFY_BOUND_DRIVER, dev); 43 44 klist_add_tail(&dev->knode_driver, &dev->driver->p->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->p->kobj, &dev->kobj, 52 kobject_name(&dev->kobj)); 53 if (ret == 0) { 54 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj, 55 "driver"); 56 if (ret) 57 sysfs_remove_link(&dev->driver->p->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->p->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 EXPORT_SYMBOL_GPL(device_bind_driver); 97 98 static atomic_t probe_count = ATOMIC_INIT(0); 99 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); 100 101 static int really_probe(struct device *dev, struct device_driver *drv) 102 { 103 int ret = 0; 104 105 atomic_inc(&probe_count); 106 pr_debug("bus: '%s': %s: probing driver %s with device %s\n", 107 drv->bus->name, __func__, drv->name, dev->bus_id); 108 WARN_ON(!list_empty(&dev->devres_head)); 109 110 dev->driver = drv; 111 if (driver_sysfs_add(dev)) { 112 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", 113 __func__, dev->bus_id); 114 goto probe_failed; 115 } 116 117 if (dev->bus->probe) { 118 ret = dev->bus->probe(dev); 119 if (ret) 120 goto probe_failed; 121 } else if (drv->probe) { 122 ret = drv->probe(dev); 123 if (ret) 124 goto probe_failed; 125 } 126 127 driver_bound(dev); 128 ret = 1; 129 pr_debug("bus: '%s': %s: bound device %s to driver %s\n", 130 drv->bus->name, __func__, dev->bus_id, drv->name); 131 goto done; 132 133 probe_failed: 134 devres_release_all(dev); 135 driver_sysfs_remove(dev); 136 dev->driver = NULL; 137 138 if (ret != -ENODEV && ret != -ENXIO) { 139 /* driver matched but the probe failed */ 140 printk(KERN_WARNING 141 "%s: probe of %s failed with error %d\n", 142 drv->name, dev->bus_id, ret); 143 } 144 /* 145 * Ignore errors returned by ->probe so that the next driver can try 146 * its luck. 147 */ 148 ret = 0; 149 done: 150 atomic_dec(&probe_count); 151 wake_up(&probe_waitqueue); 152 return ret; 153 } 154 155 /** 156 * driver_probe_done 157 * Determine if the probe sequence is finished or not. 158 * 159 * Should somehow figure out how to use a semaphore, not an atomic variable... 160 */ 161 int driver_probe_done(void) 162 { 163 pr_debug("%s: probe_count = %d\n", __func__, 164 atomic_read(&probe_count)); 165 if (atomic_read(&probe_count)) 166 return -EBUSY; 167 return 0; 168 } 169 170 /** 171 * driver_probe_device - attempt to bind device & driver together 172 * @drv: driver to bind a device to 173 * @dev: device to try to bind to the driver 174 * 175 * First, we call the bus's match function, if one present, which should 176 * compare the device IDs the driver supports with the device IDs of the 177 * device. Note we don't do this ourselves because we don't know the 178 * format of the ID structures, nor what is to be considered a match and 179 * what is not. 180 * 181 * This function returns 1 if a match is found, -ENODEV if the device is 182 * not registered, and 0 otherwise. 183 * 184 * This function must be called with @dev->sem held. When called for a 185 * USB interface, @dev->parent->sem must be held as well. 186 */ 187 int driver_probe_device(struct device_driver *drv, struct device *dev) 188 { 189 int ret = 0; 190 191 if (!device_is_registered(dev)) 192 return -ENODEV; 193 if (drv->bus->match && !drv->bus->match(dev, drv)) 194 goto done; 195 196 pr_debug("bus: '%s': %s: matched device %s with driver %s\n", 197 drv->bus->name, __func__, dev->bus_id, drv->name); 198 199 ret = really_probe(dev, drv); 200 201 done: 202 return ret; 203 } 204 205 static int __device_attach(struct device_driver *drv, void *data) 206 { 207 struct device *dev = data; 208 return driver_probe_device(drv, dev); 209 } 210 211 /** 212 * device_attach - try to attach device to a driver. 213 * @dev: device. 214 * 215 * Walk the list of drivers that the bus has and call 216 * driver_probe_device() for each pair. If a compatible 217 * pair is found, break out and return. 218 * 219 * Returns 1 if the device was bound to a driver; 220 * 0 if no matching device was found; 221 * -ENODEV if the device is not registered. 222 * 223 * When called for a USB interface, @dev->parent->sem must be held. 224 */ 225 int device_attach(struct device *dev) 226 { 227 int ret = 0; 228 229 down(&dev->sem); 230 if (dev->driver) { 231 ret = device_bind_driver(dev); 232 if (ret == 0) 233 ret = 1; 234 else { 235 dev->driver = NULL; 236 ret = 0; 237 } 238 } else { 239 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); 240 } 241 up(&dev->sem); 242 return ret; 243 } 244 EXPORT_SYMBOL_GPL(device_attach); 245 246 static int __driver_attach(struct device *dev, void *data) 247 { 248 struct device_driver *drv = data; 249 250 /* 251 * Lock device and try to bind to it. We drop the error 252 * here and always return 0, because we need to keep trying 253 * to bind to devices and some drivers will return an error 254 * simply if it didn't support the device. 255 * 256 * driver_probe_device() will spit a warning if there 257 * is an error. 258 */ 259 260 if (drv->bus->match && !drv->bus->match(dev, drv)) 261 return 0; 262 263 if (dev->parent) /* Needed for USB */ 264 down(&dev->parent->sem); 265 down(&dev->sem); 266 if (!dev->driver) 267 driver_probe_device(drv, dev); 268 up(&dev->sem); 269 if (dev->parent) 270 up(&dev->parent->sem); 271 272 return 0; 273 } 274 275 /** 276 * driver_attach - try to bind driver to devices. 277 * @drv: driver. 278 * 279 * Walk the list of devices that the bus has on it and try to 280 * match the driver with each one. If driver_probe_device() 281 * returns 0 and the @dev->driver is set, we've found a 282 * compatible pair. 283 */ 284 int driver_attach(struct device_driver *drv) 285 { 286 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 287 } 288 EXPORT_SYMBOL_GPL(driver_attach); 289 290 /* 291 * __device_release_driver() must be called with @dev->sem held. 292 * When called for a USB interface, @dev->parent->sem must be held as well. 293 */ 294 static void __device_release_driver(struct device *dev) 295 { 296 struct device_driver *drv; 297 298 drv = dev->driver; 299 if (drv) { 300 driver_sysfs_remove(dev); 301 sysfs_remove_link(&dev->kobj, "driver"); 302 303 if (dev->bus) 304 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 305 BUS_NOTIFY_UNBIND_DRIVER, 306 dev); 307 308 if (dev->bus && dev->bus->remove) 309 dev->bus->remove(dev); 310 else if (drv->remove) 311 drv->remove(dev); 312 devres_release_all(dev); 313 dev->driver = NULL; 314 klist_remove(&dev->knode_driver); 315 } 316 } 317 318 /** 319 * device_release_driver - manually detach device from driver. 320 * @dev: device. 321 * 322 * Manually detach device from driver. 323 * When called for a USB interface, @dev->parent->sem must be held. 324 */ 325 void device_release_driver(struct device *dev) 326 { 327 /* 328 * If anyone calls device_release_driver() recursively from 329 * within their ->remove callback for the same device, they 330 * will deadlock right here. 331 */ 332 down(&dev->sem); 333 __device_release_driver(dev); 334 up(&dev->sem); 335 } 336 EXPORT_SYMBOL_GPL(device_release_driver); 337 338 /** 339 * driver_detach - detach driver from all devices it controls. 340 * @drv: driver. 341 */ 342 void driver_detach(struct device_driver *drv) 343 { 344 struct device *dev; 345 346 for (;;) { 347 spin_lock(&drv->p->klist_devices.k_lock); 348 if (list_empty(&drv->p->klist_devices.k_list)) { 349 spin_unlock(&drv->p->klist_devices.k_lock); 350 break; 351 } 352 dev = list_entry(drv->p->klist_devices.k_list.prev, 353 struct device, knode_driver.n_node); 354 get_device(dev); 355 spin_unlock(&drv->p->klist_devices.k_lock); 356 357 if (dev->parent) /* Needed for USB */ 358 down(&dev->parent->sem); 359 down(&dev->sem); 360 if (dev->driver == drv) 361 __device_release_driver(dev); 362 up(&dev->sem); 363 if (dev->parent) 364 up(&dev->parent->sem); 365 put_device(dev); 366 } 367 } 368