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