LCOV - code coverage report
Current view: top level - drivers/base - dd.c (source / functions) Hit Total Coverage
Test: Real Lines: 193 350 55.1 %
Date: 2020-10-17 15:46:43 Functions: 0 44 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14