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