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 atomic_t deferred_trigger_count = ATOMIC_INIT(0); 55 56 /* 57 * In some cases, like suspend to RAM or hibernation, It might be reasonable 58 * to prohibit probing of devices as it could be unsafe. 59 * Once defer_all_probes is true all drivers probes will be forcibly deferred. 60 */ 61 static bool defer_all_probes; 62 63 /* 64 * deferred_probe_work_func() - Retry probing devices in the active list. 65 */ 66 static void deferred_probe_work_func(struct work_struct *work) 67 { 68 struct device *dev; 69 struct device_private *private; 70 /* 71 * This block processes every device in the deferred 'active' list. 72 * Each device is removed from the active list and passed to 73 * bus_probe_device() to re-attempt the probe. The loop continues 74 * until every device in the active list is removed and retried. 75 * 76 * Note: Once the device is removed from the list and the mutex is 77 * released, it is possible for the device get freed by another thread 78 * and cause a illegal pointer dereference. This code uses 79 * get/put_device() to ensure the device structure cannot disappear 80 * from under our feet. 81 */ 82 mutex_lock(&deferred_probe_mutex); 83 while (!list_empty(&deferred_probe_active_list)) { 84 private = list_first_entry(&deferred_probe_active_list, 85 typeof(*dev->p), deferred_probe); 86 dev = private->device; 87 list_del_init(&private->deferred_probe); 88 89 get_device(dev); 90 91 /* 92 * Drop the mutex while probing each device; the probe path may 93 * manipulate the deferred list 94 */ 95 mutex_unlock(&deferred_probe_mutex); 96 97 /* 98 * Force the device to the end of the dpm_list since 99 * the PM code assumes that the order we add things to 100 * the list is a good order for suspend but deferred 101 * probe makes that very unsafe. 102 */ 103 device_pm_lock(); 104 device_pm_move_last(dev); 105 device_pm_unlock(); 106 107 dev_dbg(dev, "Retrying from deferred list\n"); 108 bus_probe_device(dev); 109 110 mutex_lock(&deferred_probe_mutex); 111 112 put_device(dev); 113 } 114 mutex_unlock(&deferred_probe_mutex); 115 } 116 static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func); 117 118 static void driver_deferred_probe_add(struct device *dev) 119 { 120 mutex_lock(&deferred_probe_mutex); 121 if (list_empty(&dev->p->deferred_probe)) { 122 dev_dbg(dev, "Added to deferred list\n"); 123 list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list); 124 } 125 mutex_unlock(&deferred_probe_mutex); 126 } 127 128 void driver_deferred_probe_del(struct device *dev) 129 { 130 mutex_lock(&deferred_probe_mutex); 131 if (!list_empty(&dev->p->deferred_probe)) { 132 dev_dbg(dev, "Removed from deferred list\n"); 133 list_del_init(&dev->p->deferred_probe); 134 } 135 mutex_unlock(&deferred_probe_mutex); 136 } 137 138 static bool driver_deferred_probe_enable = false; 139 /** 140 * driver_deferred_probe_trigger() - Kick off re-probing deferred devices 141 * 142 * This functions moves all devices from the pending list to the active 143 * list and schedules the deferred probe workqueue to process them. It 144 * should be called anytime a driver is successfully bound to a device. 145 * 146 * Note, there is a race condition in multi-threaded probe. In the case where 147 * more than one device is probing at the same time, it is possible for one 148 * probe to complete successfully while another is about to defer. If the second 149 * depends on the first, then it will get put on the pending list after the 150 * trigger event has already occurred and will be stuck there. 151 * 152 * The atomic 'deferred_trigger_count' is used to determine if a successful 153 * trigger has occurred in the midst of probing a driver. If the trigger count 154 * changes in the midst of a probe, then deferred processing should be triggered 155 * again. 156 */ 157 static void driver_deferred_probe_trigger(void) 158 { 159 if (!driver_deferred_probe_enable) 160 return; 161 162 /* 163 * A successful probe means that all the devices in the pending list 164 * should be triggered to be reprobed. Move all the deferred devices 165 * into the active list so they can be retried by the workqueue 166 */ 167 mutex_lock(&deferred_probe_mutex); 168 atomic_inc(&deferred_trigger_count); 169 list_splice_tail_init(&deferred_probe_pending_list, 170 &deferred_probe_active_list); 171 mutex_unlock(&deferred_probe_mutex); 172 173 /* 174 * Kick the re-probe thread. It may already be scheduled, but it is 175 * safe to kick it again. 176 */ 177 schedule_work(&deferred_probe_work); 178 } 179 180 /** 181 * device_block_probing() - Block/defere device's probes 182 * 183 * It will disable probing of devices and defer their probes instead. 184 */ 185 void device_block_probing(void) 186 { 187 defer_all_probes = true; 188 /* sync with probes to avoid races. */ 189 wait_for_device_probe(); 190 } 191 192 /** 193 * device_unblock_probing() - Unblock/enable device's probes 194 * 195 * It will restore normal behavior and trigger re-probing of deferred 196 * devices. 197 */ 198 void device_unblock_probing(void) 199 { 200 defer_all_probes = false; 201 driver_deferred_probe_trigger(); 202 } 203 204 /** 205 * deferred_probe_initcall() - Enable probing of deferred devices 206 * 207 * We don't want to get in the way when the bulk of drivers are getting probed. 208 * Instead, this initcall makes sure that deferred probing is delayed until 209 * late_initcall time. 210 */ 211 static int deferred_probe_initcall(void) 212 { 213 driver_deferred_probe_enable = true; 214 driver_deferred_probe_trigger(); 215 /* Sort as many dependencies as possible before exiting initcalls */ 216 flush_work(&deferred_probe_work); 217 return 0; 218 } 219 late_initcall(deferred_probe_initcall); 220 221 /** 222 * device_is_bound() - Check if device is bound to a driver 223 * @dev: device to check 224 * 225 * Returns true if passed device has already finished probing successfully 226 * against a driver. 227 * 228 * This function must be called with the device lock held. 229 */ 230 bool device_is_bound(struct device *dev) 231 { 232 return dev->p && klist_node_attached(&dev->p->knode_driver); 233 } 234 235 static void driver_bound(struct device *dev) 236 { 237 if (device_is_bound(dev)) { 238 printk(KERN_WARNING "%s: device %s already bound\n", 239 __func__, kobject_name(&dev->kobj)); 240 return; 241 } 242 243 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->driver->name, 244 __func__, dev_name(dev)); 245 246 klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices); 247 248 device_pm_check_callbacks(dev); 249 250 /* 251 * Make sure the device is no longer in one of the deferred lists and 252 * kick off retrying all pending devices 253 */ 254 driver_deferred_probe_del(dev); 255 driver_deferred_probe_trigger(); 256 257 if (dev->bus) 258 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 259 BUS_NOTIFY_BOUND_DRIVER, dev); 260 } 261 262 static int driver_sysfs_add(struct device *dev) 263 { 264 int ret; 265 266 if (dev->bus) 267 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 268 BUS_NOTIFY_BIND_DRIVER, dev); 269 270 ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj, 271 kobject_name(&dev->kobj)); 272 if (ret == 0) { 273 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj, 274 "driver"); 275 if (ret) 276 sysfs_remove_link(&dev->driver->p->kobj, 277 kobject_name(&dev->kobj)); 278 } 279 return ret; 280 } 281 282 static void driver_sysfs_remove(struct device *dev) 283 { 284 struct device_driver *drv = dev->driver; 285 286 if (drv) { 287 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj)); 288 sysfs_remove_link(&dev->kobj, "driver"); 289 } 290 } 291 292 /** 293 * device_bind_driver - bind a driver to one device. 294 * @dev: device. 295 * 296 * Allow manual attachment of a driver to a device. 297 * Caller must have already set @dev->driver. 298 * 299 * Note that this does not modify the bus reference count 300 * nor take the bus's rwsem. Please verify those are accounted 301 * for before calling this. (It is ok to call with no other effort 302 * from a driver's probe() method.) 303 * 304 * This function must be called with the device lock held. 305 */ 306 int device_bind_driver(struct device *dev) 307 { 308 int ret; 309 310 ret = driver_sysfs_add(dev); 311 if (!ret) 312 driver_bound(dev); 313 else if (dev->bus) 314 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 315 BUS_NOTIFY_DRIVER_NOT_BOUND, dev); 316 return ret; 317 } 318 EXPORT_SYMBOL_GPL(device_bind_driver); 319 320 static atomic_t probe_count = ATOMIC_INIT(0); 321 static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue); 322 323 static int really_probe(struct device *dev, struct device_driver *drv) 324 { 325 int ret = -EPROBE_DEFER; 326 int local_trigger_count = atomic_read(&deferred_trigger_count); 327 bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) && 328 !drv->suppress_bind_attrs; 329 330 if (defer_all_probes) { 331 /* 332 * Value of defer_all_probes can be set only by 333 * device_defer_all_probes_enable() which, in turn, will call 334 * wait_for_device_probe() right after that to avoid any races. 335 */ 336 dev_dbg(dev, "Driver %s force probe deferral\n", drv->name); 337 driver_deferred_probe_add(dev); 338 return ret; 339 } 340 341 atomic_inc(&probe_count); 342 pr_debug("bus: '%s': %s: probing driver %s with device %s\n", 343 drv->bus->name, __func__, drv->name, dev_name(dev)); 344 WARN_ON(!list_empty(&dev->devres_head)); 345 346 re_probe: 347 dev->driver = drv; 348 349 /* If using pinctrl, bind pins now before probing */ 350 ret = pinctrl_bind_pins(dev); 351 if (ret) 352 goto pinctrl_bind_failed; 353 354 if (driver_sysfs_add(dev)) { 355 printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n", 356 __func__, dev_name(dev)); 357 goto probe_failed; 358 } 359 360 if (dev->pm_domain && dev->pm_domain->activate) { 361 ret = dev->pm_domain->activate(dev); 362 if (ret) 363 goto probe_failed; 364 } 365 366 /* 367 * Ensure devices are listed in devices_kset in correct order 368 * It's important to move Dev to the end of devices_kset before 369 * calling .probe, because it could be recursive and parent Dev 370 * should always go first 371 */ 372 devices_kset_move_last(dev); 373 374 if (dev->bus->probe) { 375 ret = dev->bus->probe(dev); 376 if (ret) 377 goto probe_failed; 378 } else if (drv->probe) { 379 ret = drv->probe(dev); 380 if (ret) 381 goto probe_failed; 382 } 383 384 if (test_remove) { 385 test_remove = false; 386 387 if (dev->bus->remove) 388 dev->bus->remove(dev); 389 else if (drv->remove) 390 drv->remove(dev); 391 392 devres_release_all(dev); 393 driver_sysfs_remove(dev); 394 dev->driver = NULL; 395 dev_set_drvdata(dev, NULL); 396 if (dev->pm_domain && dev->pm_domain->dismiss) 397 dev->pm_domain->dismiss(dev); 398 pm_runtime_reinit(dev); 399 400 goto re_probe; 401 } 402 403 pinctrl_init_done(dev); 404 405 if (dev->pm_domain && dev->pm_domain->sync) 406 dev->pm_domain->sync(dev); 407 408 driver_bound(dev); 409 ret = 1; 410 pr_debug("bus: '%s': %s: bound device %s to driver %s\n", 411 drv->bus->name, __func__, dev_name(dev), drv->name); 412 goto done; 413 414 probe_failed: 415 if (dev->bus) 416 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 417 BUS_NOTIFY_DRIVER_NOT_BOUND, dev); 418 pinctrl_bind_failed: 419 devres_release_all(dev); 420 driver_sysfs_remove(dev); 421 dev->driver = NULL; 422 dev_set_drvdata(dev, NULL); 423 if (dev->pm_domain && dev->pm_domain->dismiss) 424 dev->pm_domain->dismiss(dev); 425 pm_runtime_reinit(dev); 426 427 switch (ret) { 428 case -EPROBE_DEFER: 429 /* Driver requested deferred probing */ 430 dev_dbg(dev, "Driver %s requests probe deferral\n", drv->name); 431 driver_deferred_probe_add(dev); 432 /* Did a trigger occur while probing? Need to re-trigger if yes */ 433 if (local_trigger_count != atomic_read(&deferred_trigger_count)) 434 driver_deferred_probe_trigger(); 435 break; 436 case -ENODEV: 437 case -ENXIO: 438 pr_debug("%s: probe of %s rejects match %d\n", 439 drv->name, dev_name(dev), ret); 440 break; 441 default: 442 /* driver matched but the probe failed */ 443 printk(KERN_WARNING 444 "%s: probe of %s failed with error %d\n", 445 drv->name, dev_name(dev), ret); 446 } 447 /* 448 * Ignore errors returned by ->probe so that the next driver can try 449 * its luck. 450 */ 451 ret = 0; 452 done: 453 atomic_dec(&probe_count); 454 wake_up(&probe_waitqueue); 455 return ret; 456 } 457 458 /** 459 * driver_probe_done 460 * Determine if the probe sequence is finished or not. 461 * 462 * Should somehow figure out how to use a semaphore, not an atomic variable... 463 */ 464 int driver_probe_done(void) 465 { 466 pr_debug("%s: probe_count = %d\n", __func__, 467 atomic_read(&probe_count)); 468 if (atomic_read(&probe_count)) 469 return -EBUSY; 470 return 0; 471 } 472 473 /** 474 * wait_for_device_probe 475 * Wait for device probing to be completed. 476 */ 477 void wait_for_device_probe(void) 478 { 479 /* wait for the deferred probe workqueue to finish */ 480 flush_work(&deferred_probe_work); 481 482 /* wait for the known devices to complete their probing */ 483 wait_event(probe_waitqueue, atomic_read(&probe_count) == 0); 484 async_synchronize_full(); 485 } 486 EXPORT_SYMBOL_GPL(wait_for_device_probe); 487 488 /** 489 * driver_probe_device - attempt to bind device & driver together 490 * @drv: driver to bind a device to 491 * @dev: device to try to bind to the driver 492 * 493 * This function returns -ENODEV if the device is not registered, 494 * 1 if the device is bound successfully and 0 otherwise. 495 * 496 * This function must be called with @dev lock held. When called for a 497 * USB interface, @dev->parent lock must be held as well. 498 * 499 * If the device has a parent, runtime-resume the parent before driver probing. 500 */ 501 int driver_probe_device(struct device_driver *drv, struct device *dev) 502 { 503 int ret = 0; 504 505 if (!device_is_registered(dev)) 506 return -ENODEV; 507 508 pr_debug("bus: '%s': %s: matched device %s with driver %s\n", 509 drv->bus->name, __func__, dev_name(dev), drv->name); 510 511 if (dev->parent) 512 pm_runtime_get_sync(dev->parent); 513 514 pm_runtime_barrier(dev); 515 ret = really_probe(dev, drv); 516 pm_request_idle(dev); 517 518 if (dev->parent) 519 pm_runtime_put(dev->parent); 520 521 return ret; 522 } 523 524 bool driver_allows_async_probing(struct device_driver *drv) 525 { 526 switch (drv->probe_type) { 527 case PROBE_PREFER_ASYNCHRONOUS: 528 return true; 529 530 case PROBE_FORCE_SYNCHRONOUS: 531 return false; 532 533 default: 534 if (module_requested_async_probing(drv->owner)) 535 return true; 536 537 return false; 538 } 539 } 540 541 struct device_attach_data { 542 struct device *dev; 543 544 /* 545 * Indicates whether we are are considering asynchronous probing or 546 * not. Only initial binding after device or driver registration 547 * (including deferral processing) may be done asynchronously, the 548 * rest is always synchronous, as we expect it is being done by 549 * request from userspace. 550 */ 551 bool check_async; 552 553 /* 554 * Indicates if we are binding synchronous or asynchronous drivers. 555 * When asynchronous probing is enabled we'll execute 2 passes 556 * over drivers: first pass doing synchronous probing and second 557 * doing asynchronous probing (if synchronous did not succeed - 558 * most likely because there was no driver requiring synchronous 559 * probing - and we found asynchronous driver during first pass). 560 * The 2 passes are done because we can't shoot asynchronous 561 * probe for given device and driver from bus_for_each_drv() since 562 * driver pointer is not guaranteed to stay valid once 563 * bus_for_each_drv() iterates to the next driver on the bus. 564 */ 565 bool want_async; 566 567 /* 568 * We'll set have_async to 'true' if, while scanning for matching 569 * driver, we'll encounter one that requests asynchronous probing. 570 */ 571 bool have_async; 572 }; 573 574 static int __device_attach_driver(struct device_driver *drv, void *_data) 575 { 576 struct device_attach_data *data = _data; 577 struct device *dev = data->dev; 578 bool async_allowed; 579 int ret; 580 581 /* 582 * Check if device has already been claimed. This may 583 * happen with driver loading, device discovery/registration, 584 * and deferred probe processing happens all at once with 585 * multiple threads. 586 */ 587 if (dev->driver) 588 return -EBUSY; 589 590 ret = driver_match_device(drv, dev); 591 if (ret == 0) { 592 /* no match */ 593 return 0; 594 } else if (ret == -EPROBE_DEFER) { 595 dev_dbg(dev, "Device match requests probe deferral\n"); 596 driver_deferred_probe_add(dev); 597 } else if (ret < 0) { 598 dev_dbg(dev, "Bus failed to match device: %d", ret); 599 return ret; 600 } /* ret > 0 means positive match */ 601 602 async_allowed = driver_allows_async_probing(drv); 603 604 if (async_allowed) 605 data->have_async = true; 606 607 if (data->check_async && async_allowed != data->want_async) 608 return 0; 609 610 return driver_probe_device(drv, dev); 611 } 612 613 static void __device_attach_async_helper(void *_dev, async_cookie_t cookie) 614 { 615 struct device *dev = _dev; 616 struct device_attach_data data = { 617 .dev = dev, 618 .check_async = true, 619 .want_async = true, 620 }; 621 622 device_lock(dev); 623 624 if (dev->parent) 625 pm_runtime_get_sync(dev->parent); 626 627 bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver); 628 dev_dbg(dev, "async probe completed\n"); 629 630 pm_request_idle(dev); 631 632 if (dev->parent) 633 pm_runtime_put(dev->parent); 634 635 device_unlock(dev); 636 637 put_device(dev); 638 } 639 640 static int __device_attach(struct device *dev, bool allow_async) 641 { 642 int ret = 0; 643 644 device_lock(dev); 645 if (dev->driver) { 646 if (device_is_bound(dev)) { 647 ret = 1; 648 goto out_unlock; 649 } 650 ret = device_bind_driver(dev); 651 if (ret == 0) 652 ret = 1; 653 else { 654 dev->driver = NULL; 655 ret = 0; 656 } 657 } else { 658 struct device_attach_data data = { 659 .dev = dev, 660 .check_async = allow_async, 661 .want_async = false, 662 }; 663 664 if (dev->parent) 665 pm_runtime_get_sync(dev->parent); 666 667 ret = bus_for_each_drv(dev->bus, NULL, &data, 668 __device_attach_driver); 669 if (!ret && allow_async && data.have_async) { 670 /* 671 * If we could not find appropriate driver 672 * synchronously and we are allowed to do 673 * async probes and there are drivers that 674 * want to probe asynchronously, we'll 675 * try them. 676 */ 677 dev_dbg(dev, "scheduling asynchronous probe\n"); 678 get_device(dev); 679 async_schedule(__device_attach_async_helper, dev); 680 } else { 681 pm_request_idle(dev); 682 } 683 684 if (dev->parent) 685 pm_runtime_put(dev->parent); 686 } 687 out_unlock: 688 device_unlock(dev); 689 return ret; 690 } 691 692 /** 693 * device_attach - try to attach device to a driver. 694 * @dev: device. 695 * 696 * Walk the list of drivers that the bus has and call 697 * driver_probe_device() for each pair. If a compatible 698 * pair is found, break out and return. 699 * 700 * Returns 1 if the device was bound to a driver; 701 * 0 if no matching driver was found; 702 * -ENODEV if the device is not registered. 703 * 704 * When called for a USB interface, @dev->parent lock must be held. 705 */ 706 int device_attach(struct device *dev) 707 { 708 return __device_attach(dev, false); 709 } 710 EXPORT_SYMBOL_GPL(device_attach); 711 712 void device_initial_probe(struct device *dev) 713 { 714 __device_attach(dev, true); 715 } 716 717 static int __driver_attach(struct device *dev, void *data) 718 { 719 struct device_driver *drv = data; 720 int ret; 721 722 /* 723 * Lock device and try to bind to it. We drop the error 724 * here and always return 0, because we need to keep trying 725 * to bind to devices and some drivers will return an error 726 * simply if it didn't support the device. 727 * 728 * driver_probe_device() will spit a warning if there 729 * is an error. 730 */ 731 732 ret = driver_match_device(drv, dev); 733 if (ret == 0) { 734 /* no match */ 735 return 0; 736 } else if (ret == -EPROBE_DEFER) { 737 dev_dbg(dev, "Device match requests probe deferral\n"); 738 driver_deferred_probe_add(dev); 739 } else if (ret < 0) { 740 dev_dbg(dev, "Bus failed to match device: %d", ret); 741 return ret; 742 } /* ret > 0 means positive match */ 743 744 if (dev->parent) /* Needed for USB */ 745 device_lock(dev->parent); 746 device_lock(dev); 747 if (!dev->driver) 748 driver_probe_device(drv, dev); 749 device_unlock(dev); 750 if (dev->parent) 751 device_unlock(dev->parent); 752 753 return 0; 754 } 755 756 /** 757 * driver_attach - try to bind driver to devices. 758 * @drv: driver. 759 * 760 * Walk the list of devices that the bus has on it and try to 761 * match the driver with each one. If driver_probe_device() 762 * returns 0 and the @dev->driver is set, we've found a 763 * compatible pair. 764 */ 765 int driver_attach(struct device_driver *drv) 766 { 767 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach); 768 } 769 EXPORT_SYMBOL_GPL(driver_attach); 770 771 /* 772 * __device_release_driver() must be called with @dev lock held. 773 * When called for a USB interface, @dev->parent lock must be held as well. 774 */ 775 static void __device_release_driver(struct device *dev) 776 { 777 struct device_driver *drv; 778 779 drv = dev->driver; 780 if (drv) { 781 if (driver_allows_async_probing(drv)) 782 async_synchronize_full(); 783 784 pm_runtime_get_sync(dev); 785 786 driver_sysfs_remove(dev); 787 788 if (dev->bus) 789 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 790 BUS_NOTIFY_UNBIND_DRIVER, 791 dev); 792 793 pm_runtime_put_sync(dev); 794 795 if (dev->bus && dev->bus->remove) 796 dev->bus->remove(dev); 797 else if (drv->remove) 798 drv->remove(dev); 799 devres_release_all(dev); 800 dev->driver = NULL; 801 dev_set_drvdata(dev, NULL); 802 if (dev->pm_domain && dev->pm_domain->dismiss) 803 dev->pm_domain->dismiss(dev); 804 pm_runtime_reinit(dev); 805 806 klist_remove(&dev->p->knode_driver); 807 device_pm_check_callbacks(dev); 808 if (dev->bus) 809 blocking_notifier_call_chain(&dev->bus->p->bus_notifier, 810 BUS_NOTIFY_UNBOUND_DRIVER, 811 dev); 812 } 813 } 814 815 /** 816 * device_release_driver - manually detach device from driver. 817 * @dev: device. 818 * 819 * Manually detach device from driver. 820 * When called for a USB interface, @dev->parent lock must be held. 821 */ 822 void device_release_driver(struct device *dev) 823 { 824 /* 825 * If anyone calls device_release_driver() recursively from 826 * within their ->remove callback for the same device, they 827 * will deadlock right here. 828 */ 829 device_lock(dev); 830 __device_release_driver(dev); 831 device_unlock(dev); 832 } 833 EXPORT_SYMBOL_GPL(device_release_driver); 834 835 /** 836 * driver_detach - detach driver from all devices it controls. 837 * @drv: driver. 838 */ 839 void driver_detach(struct device_driver *drv) 840 { 841 struct device_private *dev_prv; 842 struct device *dev; 843 844 for (;;) { 845 spin_lock(&drv->p->klist_devices.k_lock); 846 if (list_empty(&drv->p->klist_devices.k_list)) { 847 spin_unlock(&drv->p->klist_devices.k_lock); 848 break; 849 } 850 dev_prv = list_entry(drv->p->klist_devices.k_list.prev, 851 struct device_private, 852 knode_driver.n_node); 853 dev = dev_prv->device; 854 get_device(dev); 855 spin_unlock(&drv->p->klist_devices.k_lock); 856 857 if (dev->parent) /* Needed for USB */ 858 device_lock(dev->parent); 859 device_lock(dev); 860 if (dev->driver == drv) 861 __device_release_driver(dev); 862 device_unlock(dev); 863 if (dev->parent) 864 device_unlock(dev->parent); 865 put_device(dev); 866 } 867 } 868