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-2009 Greg Kroah-Hartman <gregkh@suse.de> 15 * Copyright (c) 2007-2009 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 #include <linux/pm_runtime.h> 27 #include <linux/pinctrl/devinfo.h> 28 29 #include "base.h" 30 #include "power/power.h" 31 32 /* 33 * Deferred Probe infrastructure. 34 * 35 * Sometimes driver probe order matters, but the kernel doesn't always have 36 * dependency information which means some drivers will get probed before a 37 * resource it depends on is available. For example, an SDHCI driver may 38 * first need a GPIO line from an i2c GPIO controller before it can be 39 * initialized. If a required resource is not available yet, a driver can 40 * request probing to be deferred by returning -EPROBE_DEFER from its probe hook 41 * 42 * Deferred probe maintains two lists of devices, a pending list and an active 43 * list. A driver returning -EPROBE_DEFER causes the device to be added to the 44 * pending list. A successful driver probe will trigger moving all devices 45 * from the pending to the active list so that the workqueue will eventually 46 * retry them. 47 * 48 * The deferred_probe_mutex must be held any time the deferred_probe_*_list 49 * of the (struct device*)->p->deferred_probe pointers are manipulated 50 */ 51 static DEFINE_MUTEX(deferred_probe_mutex); 52 static LIST_HEAD(deferred_probe_pending_list); 53 static LIST_HEAD(deferred_probe_active_list); 54 static struct workqueue_struct *deferred_wq; 55 static atomic_t deferred_trigger_count = ATOMIC_INIT(0); 56 57 /* 58 * deferred_probe_work_func() - Retry probing devices in the active list. 59 */ 60 static void deferred_probe_work_func(struct work_struct *work) 61 { 62 struct device *dev; 63 struct device_private *private; 64 /* 65 * This block processes every device in the deferred 'active' list. 66 * Each device is removed from the active list and passed to 67 * bus_probe_device() to re-attempt the probe. The loop continues 68 * until every device in the active list is removed and retried. 69 * 70 * Note: Once the device is removed from the list and the mutex is 71 * released, it is possible for the device get freed by another thread 72 * and cause a illegal pointer dereference. This code uses 73 * get/put_device() to ensure the device structure cannot disappear 74 * from under our feet. 75 */ 76 mutex_lock(&deferred_probe_mutex); 77 while (!list_empty(&deferred_probe_active_list)) { 78 private = list_first_entry(&deferred_probe_active_list, 79 typeof(*dev->p), deferred_probe); 80 dev = private->device; 81 list_del_init(&private->deferred_probe); 82 83 get_device(dev); 84 85 /* 86 * Drop the mutex while probing each device; the probe path may 87 * manipulate the deferred list 88 */ 89 mutex_unlock(&deferred_probe_mutex); 90 91 /* 92 * Force the device to the end of the dpm_list since 93 * the PM code assumes that the order we add things to 94 * the list is a good order for suspend but deferred 95 * probe makes that very unsafe. 96 */ 97 device_pm_lock(); 98 device_pm_move_last(dev); 99 device_pm_unlock(); 100 101 dev_dbg(dev, "Retrying from deferred list\n"); 102 bus_probe_device(dev); 103 104 mutex_lock(&deferred_probe_mutex); 105 106 put_device(dev); 107 } 108 mutex_unlock(&deferred_probe_mutex); 109 } 110 static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func); 111 112 static void driver_deferred_probe_add(struct device *dev) 113 { 114 mutex_lock(&deferred_probe_mutex); 115 if (list_empty(&dev->p->deferred_probe)) { 116 dev_dbg(dev, "Added to deferred list\n"); 117 list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list); 118 } 119 mutex_unlock(&deferred_probe_mutex); 120 } 121 122 void driver_deferred_probe_del(struct device *dev) 123 { 124 mutex_lock(&deferred_probe_mutex); 125 if (!list_empty(&dev->p->deferred_probe)) { 126 dev_dbg(dev, "Removed from deferred list\n"); 127 list_del_init(&dev->p->deferred_probe); 128 } 129 mutex_unlock(&deferred_probe_mutex); 130 } 131 132 static bool driver_deferred_probe_enable = false; 133 /** 134 * driver_deferred_probe_trigger() - Kick off re-probing deferred devices 135 * 136 * This functions moves all devices from the pending list to the active 137 * list and schedules the deferred probe workqueue to process them. It 138 * should be called anytime a driver is successfully bound to a device. 139 * 140 * Note, there is a race condition in multi-threaded probe. In the case where 141 * more than one device is probing at the same time, it is possible for one 142 * probe to complete successfully while another is about to defer. If the second 143 * depends on the first, then it will get put on the pending list after the 144 * trigger event has already occured and will be stuck there. 145 * 146 * The atomic 'deferred_trigger_count' is used to determine if a successful 147 * trigger has occurred in the midst of probing a driver. If the trigger count 148 * changes in the midst of a probe, then deferred processing should be triggered 149 * again. 150 */ 151 static void driver_deferred_probe_trigger(void) 152 { 153 if (!driver_deferred_probe_enable) 154 return; 155 156 /* 157 * A successful probe means that all the devices in the pending list 158 * should be triggered to be reprobed. Move all the deferred devices 159 * into the active list so they can be retried by the workqueue 160 */ 161 mutex_lock(&deferred_probe_mutex); 162 atomic_inc(&deferred_trigger_count); 163 list_splice_tail_init(&deferred_probe_pending_list, 164 &deferred_probe_active_list); 165 mutex_unlock(&deferred_probe_mutex); 166 167 /* 168 * Kick the re-probe thread. It may already be scheduled, but it is 169 * safe to kick it again. 170 */ 171 queue_work(deferred_wq, &deferred_probe_work); 172 } 173 174 /** 175 * deferred_probe_initcall() - Enable probing of deferred devices 176 * 177 * We don't want to get in the way when the bulk of drivers are getting probed. 178 * Instead, this initcall makes sure that deferred probing is delayed until 179 * late_initcall time. 180 */ 181 static int deferred_probe_initcall(void) 182 { 183 deferred_wq = create_singlethread_workqueue("deferwq"); 184 if (WARN_ON(!deferred_wq)) 185 return -ENOMEM; 186 187 driver_deferred_probe_enable = true; 188 driver_deferred_probe_trigger(); 189 /* Sort as many dependencies as possible before exiting initcalls */ 190 flush_workqueue(deferred_wq); 191 return 0; 192 } 193 late_initcall(deferred_probe_initcall); 194 195 static void driver_bound(struct device *dev) 196 { 197 if (klist_node_attached(&dev->p->knode_driver)) { 198 printk(KERN_WARNING "%s: device %s already bound\n", 199 __func__, kobject_name(&dev->kobj)); 200 return; 201 } 202 203 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->driver->name, 204 __func__, dev_name(dev)); 205 206 klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices); 207 208 /* 209 * Make sure the device is no longer in one of the deferred lists and 210 * kick off retrying all pending devices 211 */ 212 driver_deferred_probe_del(dev); 213 driver_deferred_probe_trigger(); 214 215 if (dev->bus) 216 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 217 BUS_NOTIFY_BOUND_DRIVER, dev); 218 } 219 220 static int driver_sysfs_add(struct device *dev) 221 { 222 int ret; 223 224 if (dev->bus) 225 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 226 BUS_NOTIFY_BIND_DRIVER, dev); 227 228 ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj, 229 kobject_name(&dev->kobj)); 230 if (ret == 0) { 231 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj, 232 "driver"); 233 if (ret) 234 sysfs_remove_link(&dev->driver->p->kobj, 235 kobject_name(&dev->kobj)); 236 } 237 return ret; 238 } 239 240 static void driver_sysfs_remove(struct device *dev) 241 { 242 struct device_driver *drv = dev->driver; 243 244 if (drv) { 245 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj)); 246 sysfs_remove_link(&dev->kobj, "driver"); 247 } 248 } 249 250 /** 251 * device_bind_driver - bind a driver to one device. 252 * @dev: device. 253 * 254 * Allow manual attachment of a driver to a device. 255 * Caller must have already set @dev->driver. 256 * 257 * Note that this does not modify the bus reference count 258 * nor take the bus's rwsem. Please verify those are accounted 259 * for before calling this. (It is ok to call with no other effort 260 * from a driver's probe() method.) 261 * 262 * This function must be called with the device lock held. 263 */ 264 int device_bind_driver(struct device *dev) 265 { 266 int ret; 267 268 ret = driver_sysfs_add(dev); 269 if (!ret) 270 driver_bound(dev); 271 return ret; 272 } 273 EXPORT_SYMBOL_GPL(device_bind_driver); 274 275 static atomic_t probe_count = ATOMIC_INIT(0); 276 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); 277 278 static int really_probe(struct device *dev, struct device_driver *drv) 279 { 280 int ret = 0; 281 int local_trigger_count = atomic_read(&deferred_trigger_count); 282 283 atomic_inc(&probe_count); 284 pr_debug("bus: '%s': %s: probing driver %s with device %s\n", 285 drv->bus->name, __func__, drv->name, dev_name(dev)); 286 WARN_ON(!list_empty(&dev->devres_head)); 287 288 dev->driver = drv; 289 290 /* If using pinctrl, bind pins now before probing */ 291 ret = pinctrl_bind_pins(dev); 292 if (ret) 293 goto probe_failed; 294 295 if (driver_sysfs_add(dev)) { 296 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", 297 __func__, dev_name(dev)); 298 goto probe_failed; 299 } 300 301 if (dev->bus->probe) { 302 ret = dev->bus->probe(dev); 303 if (ret) 304 goto probe_failed; 305 } else if (drv->probe) { 306 ret = drv->probe(dev); 307 if (ret) 308 goto probe_failed; 309 } 310 311 driver_bound(dev); 312 ret = 1; 313 pr_debug("bus: '%s': %s: bound device %s to driver %s\n", 314 drv->bus->name, __func__, dev_name(dev), drv->name); 315 goto done; 316 317 probe_failed: 318 devres_release_all(dev); 319 driver_sysfs_remove(dev); 320 dev->driver = NULL; 321 dev_set_drvdata(dev, NULL); 322 323 if (ret == -EPROBE_DEFER) { 324 /* Driver requested deferred probing */ 325 dev_info(dev, "Driver %s requests probe deferral\n", drv->name); 326 driver_deferred_probe_add(dev); 327 /* Did a trigger occur while probing? Need to re-trigger if yes */ 328 if (local_trigger_count != atomic_read(&deferred_trigger_count)) 329 driver_deferred_probe_trigger(); 330 } else if (ret != -ENODEV && ret != -ENXIO) { 331 /* driver matched but the probe failed */ 332 printk(KERN_WARNING 333 "%s: probe of %s failed with error %d\n", 334 drv->name, dev_name(dev), ret); 335 } else { 336 pr_debug("%s: probe of %s rejects match %d\n", 337 drv->name, dev_name(dev), ret); 338 } 339 /* 340 * Ignore errors returned by ->probe so that the next driver can try 341 * its luck. 342 */ 343 ret = 0; 344 done: 345 atomic_dec(&probe_count); 346 wake_up(&probe_waitqueue); 347 return ret; 348 } 349 350 /** 351 * driver_probe_done 352 * Determine if the probe sequence is finished or not. 353 * 354 * Should somehow figure out how to use a semaphore, not an atomic variable... 355 */ 356 int driver_probe_done(void) 357 { 358 pr_debug("%s: probe_count = %d\n", __func__, 359 atomic_read(&probe_count)); 360 if (atomic_read(&probe_count)) 361 return -EBUSY; 362 return 0; 363 } 364 365 /** 366 * wait_for_device_probe 367 * Wait for device probing to be completed. 368 */ 369 void wait_for_device_probe(void) 370 { 371 /* wait for the known devices to complete their probing */ 372 wait_event(probe_waitqueue, atomic_read(&probe_count) == 0); 373 async_synchronize_full(); 374 } 375 EXPORT_SYMBOL_GPL(wait_for_device_probe); 376 377 /** 378 * driver_probe_device - attempt to bind device & driver together 379 * @drv: driver to bind a device to 380 * @dev: device to try to bind to the driver 381 * 382 * This function returns -ENODEV if the device is not registered, 383 * 1 if the device is bound successfully and 0 otherwise. 384 * 385 * This function must be called with @dev lock held. When called for a 386 * USB interface, @dev->parent lock must be held as well. 387 */ 388 int driver_probe_device(struct device_driver *drv, struct device *dev) 389 { 390 int ret = 0; 391 392 if (!device_is_registered(dev)) 393 return -ENODEV; 394 395 pr_debug("bus: '%s': %s: matched device %s with driver %s\n", 396 drv->bus->name, __func__, dev_name(dev), drv->name); 397 398 pm_runtime_barrier(dev); 399 ret = really_probe(dev, drv); 400 pm_request_idle(dev); 401 402 return ret; 403 } 404 405 static int __device_attach(struct device_driver *drv, void *data) 406 { 407 struct device *dev = data; 408 409 if (!driver_match_device(drv, dev)) 410 return 0; 411 412 return driver_probe_device(drv, dev); 413 } 414 415 /** 416 * device_attach - try to attach device to a driver. 417 * @dev: device. 418 * 419 * Walk the list of drivers that the bus has and call 420 * driver_probe_device() for each pair. If a compatible 421 * pair is found, break out and return. 422 * 423 * Returns 1 if the device was bound to a driver; 424 * 0 if no matching driver was found; 425 * -ENODEV if the device is not registered. 426 * 427 * When called for a USB interface, @dev->parent lock must be held. 428 */ 429 int device_attach(struct device *dev) 430 { 431 int ret = 0; 432 433 device_lock(dev); 434 if (dev->driver) { 435 if (klist_node_attached(&dev->p->knode_driver)) { 436 ret = 1; 437 goto out_unlock; 438 } 439 ret = device_bind_driver(dev); 440 if (ret == 0) 441 ret = 1; 442 else { 443 dev->driver = NULL; 444 ret = 0; 445 } 446 } else { 447 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach); 448 pm_request_idle(dev); 449 } 450 out_unlock: 451 device_unlock(dev); 452 return ret; 453 } 454 EXPORT_SYMBOL_GPL(device_attach); 455 456 static int __driver_attach(struct device *dev, void *data) 457 { 458 struct device_driver *drv = data; 459 460 /* 461 * Lock device and try to bind to it. We drop the error 462 * here and always return 0, because we need to keep trying 463 * to bind to devices and some drivers will return an error 464 * simply if it didn't support the device. 465 * 466 * driver_probe_device() will spit a warning if there 467 * is an error. 468 */ 469 470 if (!driver_match_device(drv, dev)) 471 return 0; 472 473 if (dev->parent) /* Needed for USB */ 474 device_lock(dev->parent); 475 device_lock(dev); 476 if (!dev->driver) 477 driver_probe_device(drv, dev); 478 device_unlock(dev); 479 if (dev->parent) 480 device_unlock(dev->parent); 481 482 return 0; 483 } 484 485 /** 486 * driver_attach - try to bind driver to devices. 487 * @drv: driver. 488 * 489 * Walk the list of devices that the bus has on it and try to 490 * match the driver with each one. If driver_probe_device() 491 * returns 0 and the @dev->driver is set, we've found a 492 * compatible pair. 493 */ 494 int driver_attach(struct device_driver *drv) 495 { 496 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 497 } 498 EXPORT_SYMBOL_GPL(driver_attach); 499 500 /* 501 * __device_release_driver() must be called with @dev lock held. 502 * When called for a USB interface, @dev->parent lock must be held as well. 503 */ 504 static void __device_release_driver(struct device *dev) 505 { 506 struct device_driver *drv; 507 508 drv = dev->driver; 509 if (drv) { 510 pm_runtime_get_sync(dev); 511 512 driver_sysfs_remove(dev); 513 514 if (dev->bus) 515 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 516 BUS_NOTIFY_UNBIND_DRIVER, 517 dev); 518 519 pm_runtime_put_sync(dev); 520 521 if (dev->bus && dev->bus->remove) 522 dev->bus->remove(dev); 523 else if (drv->remove) 524 drv->remove(dev); 525 devres_release_all(dev); 526 dev->driver = NULL; 527 dev_set_drvdata(dev, NULL); 528 klist_remove(&dev->p->knode_driver); 529 if (dev->bus) 530 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 531 BUS_NOTIFY_UNBOUND_DRIVER, 532 dev); 533 534 } 535 } 536 537 /** 538 * device_release_driver - manually detach device from driver. 539 * @dev: device. 540 * 541 * Manually detach device from driver. 542 * When called for a USB interface, @dev->parent lock must be held. 543 */ 544 void device_release_driver(struct device *dev) 545 { 546 /* 547 * If anyone calls device_release_driver() recursively from 548 * within their ->remove callback for the same device, they 549 * will deadlock right here. 550 */ 551 device_lock(dev); 552 __device_release_driver(dev); 553 device_unlock(dev); 554 } 555 EXPORT_SYMBOL_GPL(device_release_driver); 556 557 /** 558 * driver_detach - detach driver from all devices it controls. 559 * @drv: driver. 560 */ 561 void driver_detach(struct device_driver *drv) 562 { 563 struct device_private *dev_prv; 564 struct device *dev; 565 566 for (;;) { 567 spin_lock(&drv->p->klist_devices.k_lock); 568 if (list_empty(&drv->p->klist_devices.k_list)) { 569 spin_unlock(&drv->p->klist_devices.k_lock); 570 break; 571 } 572 dev_prv = list_entry(drv->p->klist_devices.k_list.prev, 573 struct device_private, 574 knode_driver.n_node); 575 dev = dev_prv->device; 576 get_device(dev); 577 spin_unlock(&drv->p->klist_devices.k_lock); 578 579 if (dev->parent) /* Needed for USB */ 580 device_lock(dev->parent); 581 device_lock(dev); 582 if (dev->driver == drv) 583 __device_release_driver(dev); 584 device_unlock(dev); 585 if (dev->parent) 586 device_unlock(dev->parent); 587 put_device(dev); 588 } 589 } 590