| 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 | struct stupid_thread_structure {
|
| 98 | struct device_driver *drv;
|
| 99 | struct device *dev;
|
| 100 | };
|
| 101 |
|
| 102 | static atomic_t probe_count = ATOMIC_INIT(0);
|
| 103 | static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
|
| 104 |
|
| 105 | static int really_probe(void *void_data)
|
| 106 | {
|
| 107 | struct stupid_thread_structure *data = void_data;
|
| 108 | struct device_driver *drv = data->drv;
|
| 109 | struct device *dev = data->dev;
|
| 110 | int ret = 0;
|
| 111 |
|
| 112 | atomic_inc(&probe_count);
|
| 113 | pr_debug("%s: Probing driver %s with device %s\n",
|
| 114 | drv->bus->name, drv->name, dev->bus_id);
|
| 115 | WARN_ON(!list_empty(&dev->devres_head));
|
| 116 |
|
| 117 | dev->driver = drv;
|
| 118 | if (driver_sysfs_add(dev)) {
|
| 119 | printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
|
| 120 | __FUNCTION__, dev->bus_id);
|
| 121 | goto probe_failed;
|
| 122 | }
|
| 123 |
|
| 124 | if (dev->bus->probe) {
|
| 125 | ret = dev->bus->probe(dev);
|
| 126 | if (ret)
|
| 127 | goto probe_failed;
|
| 128 | } else if (drv->probe) {
|
| 129 | ret = drv->probe(dev);
|
| 130 | if (ret)
|
| 131 | goto probe_failed;
|
| 132 | }
|
| 133 |
|
| 134 | driver_bound(dev);
|
| 135 | ret = 1;
|
| 136 | pr_debug("%s: Bound Device %s to Driver %s\n",
|
| 137 | drv->bus->name, dev->bus_id, drv->name);
|
| 138 | goto done;
|
| 139 |
|
| 140 | probe_failed:
|
| 141 | devres_release_all(dev);
|
| 142 | driver_sysfs_remove(dev);
|
| 143 | dev->driver = NULL;
|
| 144 |
|
| 145 | if (ret != -ENODEV && ret != -ENXIO) {
|
| 146 |
|
| 147 | printk(KERN_WARNING
|
| 148 | "%s: probe of %s failed with error %d\n",
|
| 149 | drv->name, dev->bus_id, ret);
|
| 150 | }
|
| 151 | |
| 152 | * Ignore errors returned by ->probe so that the next driver can try
|
| 153 | * its luck.
|
| 154 |
|
| 155 | ret = 0;
|
| 156 | done:
|
| 157 | kfree(data);
|
| 158 | atomic_dec(&probe_count);
|
| 159 | wake_up(&probe_waitqueue);
|
| 160 | return ret;
|
| 161 | }
|
| 162 |
|
| 163 | |
| 164 | * driver_probe_done
|
| 165 | * Determine if the probe sequence is finished or not.
|
| 166 | *
|
| 167 | * Should somehow figure out how to use a semaphore, not an atomic variable...
|
| 168 |
|
| 169 | int driver_probe_done(void)
|
| 170 | {
|
| 171 | pr_debug("%s: probe_count = %d\n", __FUNCTION__,
|
| 172 | atomic_read(&probe_count));
|
| 173 | if (atomic_read(&probe_count))
|
| 174 | return -EBUSY;
|
| 175 | return 0;
|
| 176 | }
|
| 177 |
|
| 178 | |
| 179 | * driver_probe_device - attempt to bind device & driver together
|
| 180 | * @drv: driver to bind a device to
|
| 181 | * @dev: device to try to bind to the driver
|
| 182 | *
|
| 183 | * First, we call the bus's match function, if one present, which should
|
| 184 | * compare the device IDs the driver supports with the device IDs of the
|
| 185 | * device. Note we don't do this ourselves because we don't know the
|
| 186 | * format of the ID structures, nor what is to be considered a match and
|
| 187 | * what is not.
|
| 188 | *
|
| 189 | * This function returns 1 if a match is found, an error if one occurs
|
| 190 | * (that is not -ENODEV or -ENXIO), 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 | struct stupid_thread_structure *data;
|
| 198 | struct task_struct *probe_task;
|
| 199 | int ret = 0;
|
| 200 |
|
| 201 | if (!device_is_registered(dev))
|
| 202 | return -ENODEV;
|
| 203 | if (drv->bus->match && !drv->bus->match(dev, drv))
|
| 204 | goto done;
|
| 205 |
|
| 206 | pr_debug("%s: Matched Device %s with Driver %s\n",
|
| 207 | drv->bus->name, dev->bus_id, drv->name);
|
| 208 |
|
| 209 | data = kmalloc(sizeof(*data), GFP_KERNEL);
|
| 210 | if (!data)
|
| 211 | return -ENOMEM;
|
| 212 | data->drv = drv;
|
| 213 | data->dev = dev;
|
| 214 |
|
| 215 | if (drv->multithread_probe) {
|
| 216 | probe_task = kthread_run(really_probe, data,
|
| 217 | "probe-%s", dev->bus_id);
|
| 218 | if (IS_ERR(probe_task))
|
| 219 | ret = really_probe(data);
|
| 220 | } else
|
| 221 | ret = really_probe(data);
|
| 222 |
|
| 223 | done:
|
| 224 | return ret;
|
| 225 | }
|
| 226 |
|
| 227 | static int __device_attach(struct device_driver * drv, void * data)
|
| 228 | {
|
| 229 | struct device * dev = data;
|
| 230 | return driver_probe_device(drv, dev);
|
| 231 | }
|
| 232 |
|
| 233 | |
| 234 | * device_attach - try to attach device to a driver.
|
| 235 | * @dev: device.
|
| 236 | *
|
| 237 | * Walk the list of drivers that the bus has and call
|
| 238 | * driver_probe_device() for each pair. If a compatible
|
| 239 | * pair is found, break out and return.
|
| 240 | *
|
| 241 | * Returns 1 if the device was bound to a driver;
|
| 242 | * 0 if no matching device was found; error code otherwise.
|
| 243 | *
|
| 244 | * When called for a USB interface, @dev->parent->sem must be held.
|
| 245 |
|
| 246 | int device_attach(struct device * dev)
|
| 247 | {
|
| 248 | int ret = 0;
|
| 249 |
|
| 250 | down(&dev->sem);
|
| 251 | if (dev->driver) {
|
| 252 | ret = device_bind_driver(dev);
|
| 253 | if (ret == 0)
|
| 254 | ret = 1;
|
| 255 | } else
|
| 256 | ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
|
| 257 | up(&dev->sem);
|
| 258 | return ret;
|
| 259 | }
|
| 260 |
|
| 261 | static int __driver_attach(struct device * dev, void * data)
|
| 262 | {
|
| 263 | struct device_driver * drv = data;
|
| 264 |
|
| 265 | |
| 266 | * Lock device and try to bind to it. We drop the error
|
| 267 | * here and always return 0, because we need to keep trying
|
| 268 | * to bind to devices and some drivers will return an error
|
| 269 | * simply if it didn't support the device.
|
| 270 | *
|
| 271 | * driver_probe_device() will spit a warning if there
|
| 272 | * is an error.
|
| 273 |
|
| 274 |
|
| 275 | if (dev->parent)
|
| 276 | down(&dev->parent->sem);
|
| 277 | down(&dev->sem);
|
| 278 | if (!dev->driver)
|
| 279 | driver_probe_device(drv, dev);
|
| 280 | up(&dev->sem);
|
| 281 | if (dev->parent)
|
| 282 | up(&dev->parent->sem);
|
| 283 |
|
| 284 | return 0;
|
| 285 | }
|
| 286 |
|
| 287 | |
| 288 | * driver_attach - try to bind driver to devices.
|
| 289 | * @drv: driver.
|
| 290 | *
|
| 291 | * Walk the list of devices that the bus has on it and try to
|
| 292 | * match the driver with each one. If driver_probe_device()
|
| 293 | * returns 0 and the @dev->driver is set, we've found a
|
| 294 | * compatible pair.
|
| 295 |
|
| 296 | int driver_attach(struct device_driver * drv)
|
| 297 | {
|
| 298 | return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
|
| 299 | }
|
| 300 |
|
| 301 | |
| 302 | * device_release_driver - manually detach device from driver.
|
| 303 | * @dev: device.
|
| 304 | *
|
| 305 | * Manually detach device from driver.
|
| 306 | *
|
| 307 | * __device_release_driver() must be called with @dev->sem held.
|
| 308 | * When called for a USB interface, @dev->parent->sem must be held
|
| 309 | * as well.
|
| 310 |
|
| 311 |
|
| 312 | static void __device_release_driver(struct device * dev)
|
| 313 | {
|
| 314 | struct device_driver * drv;
|
| 315 |
|
| 316 | drv = dev->driver;
|
| 317 | if (drv) {
|
| 318 | get_driver(drv);
|
| 319 | driver_sysfs_remove(dev);
|
| 320 | sysfs_remove_link(&dev->kobj, "driver");
|
| 321 | klist_remove(&dev->knode_driver);
|
| 322 |
|
| 323 | if (dev->bus)
|
| 324 | blocking_notifier_call_chain(&dev->bus->bus_notifier,
|
| 325 | BUS_NOTIFY_UNBIND_DRIVER,
|
| 326 | dev);
|
| 327 |
|
| 328 | if (dev->bus && dev->bus->remove)
|
| 329 | dev->bus->remove(dev);
|
| 330 | else if (drv->remove)
|
| 331 | drv->remove(dev);
|
| 332 | devres_release_all(dev);
|
| 333 | dev->driver = NULL;
|
| 334 | put_driver(drv);
|
| 335 | }
|
| 336 | }
|
| 337 |
|
| 338 | void device_release_driver(struct device * dev)
|
| 339 | {
|
| 340 | |
| 341 | * If anyone calls device_release_driver() recursively from
|
| 342 | * within their ->remove callback for the same device, they
|
| 343 | * will deadlock right here.
|
| 344 |
|
| 345 | down(&dev->sem);
|
| 346 | __device_release_driver(dev);
|
| 347 | up(&dev->sem);
|
| 348 | }
|
| 349 |
|
| 350 |
|
| 351 | |
| 352 | * driver_detach - detach driver from all devices it controls.
|
| 353 | * @drv: driver.
|
| 354 |
|
| 355 | void driver_detach(struct device_driver * drv)
|
| 356 | {
|
| 357 | struct device * dev;
|
| 358 |
|
| 359 | for (;;) {
|
| 360 | spin_lock(&drv->klist_devices.k_lock);
|
| 361 | if (list_empty(&drv->klist_devices.k_list)) {
|
| 362 | spin_unlock(&drv->klist_devices.k_lock);
|
| 363 | break;
|
| 364 | }
|
| 365 | dev = list_entry(drv->klist_devices.k_list.prev,
|
| 366 | struct device, knode_driver.n_node);
|
| 367 | get_device(dev);
|
| 368 | spin_unlock(&drv->klist_devices.k_lock);
|
| 369 |
|
| 370 | if (dev->parent)
|
| 371 | down(&dev->parent->sem);
|
| 372 | down(&dev->sem);
|
| 373 | if (dev->driver == drv)
|
| 374 | __device_release_driver(dev);
|
| 375 | up(&dev->sem);
|
| 376 | if (dev->parent)
|
| 377 | up(&dev->parent->sem);
|
| 378 | put_device(dev);
|
| 379 | }
|
| 380 | }
|
| 381 |
|
| 382 | #ifdef CONFIG_PCI_MULTITHREAD_PROBE
|
| 383 | static int __init wait_for_probes(void)
|
| 384 | {
|
| 385 | DEFINE_WAIT(wait);
|
| 386 |
|
| 387 | printk(KERN_INFO "%s: waiting for %d threads\n", __FUNCTION__,
|
| 388 | atomic_read(&probe_count));
|
| 389 | if (!atomic_read(&probe_count))
|
| 390 | return 0;
|
| 391 | while (atomic_read(&probe_count)) {
|
| 392 | prepare_to_wait(&probe_waitqueue, &wait, TASK_UNINTERRUPTIBLE);
|
| 393 | if (atomic_read(&probe_count))
|
| 394 | schedule();
|
| 395 | }
|
| 396 | finish_wait(&probe_waitqueue, &wait);
|
| 397 | return 0;
|
| 398 | }
|
| 399 |
|
| 400 | core_initcall_sync(wait_for_probes);
|
| 401 | postcore_initcall_sync(wait_for_probes);
|
| 402 | arch_initcall_sync(wait_for_probes);
|
| 403 | subsys_initcall_sync(wait_for_probes);
|
| 404 | fs_initcall_sync(wait_for_probes);
|
| 405 | device_initcall_sync(wait_for_probes);
|
| 406 | late_initcall_sync(wait_for_probes);
|
| 407 | #endif
|
| 408 |
|
| 409 | EXPORT_SYMBOL_GPL(device_bind_driver);
|
| 410 | EXPORT_SYMBOL_GPL(device_release_driver);
|
| 411 | EXPORT_SYMBOL_GPL(device_attach);
|
| 412 | EXPORT_SYMBOL_GPL(driver_attach);
|
| 413 |
|