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