blob: 8def2ba08a8211fa0e2bc94ee8d3529b1889999f [file] [log] [blame]
Greg Kroah-Hartman989d42e2017-11-07 17:30:07 +01001// SPDX-License-Identifier: GPL-2.0
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08002/*
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08003 * drivers/base/dd.c - The core device/driver interactions.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08004 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08005 * This file contains the (sometimes tricky) code that controls the
6 * interactions between devices and drivers, which primarily includes
7 * driver binding and unbinding.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08008 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08009 * 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'.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080012 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -080013 * Copyright (c) 2002-5 Patrick Mochel
14 * Copyright (c) 2002-3 Open Source Development Labs
Greg Kroah-Hartmanb4028432009-05-11 14:16:57 -070015 * Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de>
16 * Copyright (c) 2007-2009 Novell Inc.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080017 */
18
Javier Martinez Canillas28af109a2018-07-08 15:34:59 +020019#include <linux/debugfs.h>
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080020#include <linux/device.h>
Arjan van de Ven216773a2009-02-14 01:59:06 +010021#include <linux/delay.h>
Christoph Hellwig0a0f0d82020-09-22 15:31:03 +020022#include <linux/dma-map-ops.h>
Todd Poynor1f5000b2017-07-25 16:31:59 -070023#include <linux/init.h>
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080024#include <linux/module.h>
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -070025#include <linux/kthread.h>
Andrew Morton735a7ff2006-10-27 11:42:37 -070026#include <linux/wait.h>
Arjan van de Ven216773a2009-02-14 01:59:06 +010027#include <linux/async.h>
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +020028#include <linux/pm_runtime.h>
Linus Walleijab780292013-01-22 10:56:14 -070029#include <linux/pinctrl/devinfo.h>
Andrzej Hajdad090b702020-07-13 16:43:22 +020030#include <linux/slab.h>
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -080031
32#include "base.h"
33#include "power/power.h"
34
Grant Likelyd1c34142012-03-05 08:47:41 -070035/*
36 * Deferred Probe infrastructure.
37 *
38 * Sometimes driver probe order matters, but the kernel doesn't always have
39 * dependency information which means some drivers will get probed before a
40 * resource it depends on is available. For example, an SDHCI driver may
41 * first need a GPIO line from an i2c GPIO controller before it can be
42 * initialized. If a required resource is not available yet, a driver can
43 * request probing to be deferred by returning -EPROBE_DEFER from its probe hook
44 *
45 * Deferred probe maintains two lists of devices, a pending list and an active
46 * list. A driver returning -EPROBE_DEFER causes the device to be added to the
47 * pending list. A successful driver probe will trigger moving all devices
48 * from the pending to the active list so that the workqueue will eventually
49 * retry them.
50 *
51 * The deferred_probe_mutex must be held any time the deferred_probe_*_list
Greg Kroah-Hartmanef8a3fd2012-03-08 12:17:22 -080052 * of the (struct device*)->p->deferred_probe pointers are manipulated
Grant Likelyd1c34142012-03-05 08:47:41 -070053 */
54static DEFINE_MUTEX(deferred_probe_mutex);
55static LIST_HEAD(deferred_probe_pending_list);
56static LIST_HEAD(deferred_probe_active_list);
Grant Likely58b116b2014-04-29 12:05:22 +010057static atomic_t deferred_trigger_count = ATOMIC_INIT(0);
Rob Herring25b4e702018-07-09 09:41:48 -060058static bool initcalls_done;
Grant Likelyd1c34142012-03-05 08:47:41 -070059
Feng Tang1ea61b62019-02-13 15:47:36 +080060/* Save the async probe drivers' name from kernel cmdline */
61#define ASYNC_DRV_NAMES_MAX_LEN 256
62static char async_probe_drv_names[ASYNC_DRV_NAMES_MAX_LEN];
Saravana Kannanf79f662e2022-05-03 17:53:43 -070063static bool async_probe_default;
Feng Tang1ea61b62019-02-13 15:47:36 +080064
Thierry Reding41575332014-08-08 15:56:36 +020065/*
Strashko, Grygorii013c0742015-11-10 11:42:34 +020066 * In some cases, like suspend to RAM or hibernation, It might be reasonable
67 * to prohibit probing of devices as it could be unsafe.
68 * Once defer_all_probes is true all drivers probes will be forcibly deferred.
69 */
70static bool defer_all_probes;
71
Ahmad Fatoum72a91f12021-03-23 16:37:13 +010072static void __device_set_deferred_probe_reason(const struct device *dev, char *reason)
73{
74 kfree(dev->p->deferred_probe_reason);
75 dev->p->deferred_probe_reason = reason;
76}
77
Strashko, Grygorii013c0742015-11-10 11:42:34 +020078/*
Grant Likelyd1c34142012-03-05 08:47:41 -070079 * deferred_probe_work_func() - Retry probing devices in the active list.
80 */
81static void deferred_probe_work_func(struct work_struct *work)
82{
83 struct device *dev;
Greg Kroah-Hartmanef8a3fd2012-03-08 12:17:22 -080084 struct device_private *private;
Grant Likelyd1c34142012-03-05 08:47:41 -070085 /*
86 * This block processes every device in the deferred 'active' list.
87 * Each device is removed from the active list and passed to
88 * bus_probe_device() to re-attempt the probe. The loop continues
89 * until every device in the active list is removed and retried.
90 *
91 * Note: Once the device is removed from the list and the mutex is
92 * released, it is possible for the device get freed by another thread
93 * and cause a illegal pointer dereference. This code uses
94 * get/put_device() to ensure the device structure cannot disappear
95 * from under our feet.
96 */
97 mutex_lock(&deferred_probe_mutex);
98 while (!list_empty(&deferred_probe_active_list)) {
Greg Kroah-Hartmanef8a3fd2012-03-08 12:17:22 -080099 private = list_first_entry(&deferred_probe_active_list,
100 typeof(*dev->p), deferred_probe);
101 dev = private->device;
102 list_del_init(&private->deferred_probe);
Grant Likelyd1c34142012-03-05 08:47:41 -0700103
104 get_device(dev);
105
Ahmad Fatoum72a91f12021-03-23 16:37:13 +0100106 __device_set_deferred_probe_reason(dev, NULL);
Ahmad Fatoumf0acf632021-03-19 12:04:57 +0100107
Greg Kroah-Hartman8b0372a2012-03-08 12:20:37 -0800108 /*
109 * Drop the mutex while probing each device; the probe path may
110 * manipulate the deferred list
111 */
Grant Likelyd1c34142012-03-05 08:47:41 -0700112 mutex_unlock(&deferred_probe_mutex);
Mark Brown81535842012-07-05 14:04:44 +0100113
114 /*
115 * Force the device to the end of the dpm_list since
116 * the PM code assumes that the order we add things to
117 * the list is a good order for suspend but deferred
118 * probe makes that very unsafe.
119 */
Feng Kan494fd7b2018-04-10 16:57:06 -0700120 device_pm_move_to_tail(dev);
Mark Brown81535842012-07-05 14:04:44 +0100121
Grant Likelyd1c34142012-03-05 08:47:41 -0700122 dev_dbg(dev, "Retrying from deferred list\n");
Todd Poynor0a50f612018-06-20 17:35:56 -0700123 bus_probe_device(dev);
Grant Likelyd1c34142012-03-05 08:47:41 -0700124 mutex_lock(&deferred_probe_mutex);
125
126 put_device(dev);
127 }
128 mutex_unlock(&deferred_probe_mutex);
129}
130static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func);
131
Rafael J. Wysockie7dd4012019-02-01 01:59:42 +0100132void driver_deferred_probe_add(struct device *dev)
Grant Likelyd1c34142012-03-05 08:47:41 -0700133{
Saravana Kannanf2db85b2021-03-02 13:11:30 -0800134 if (!dev->can_match)
135 return;
136
Grant Likelyd1c34142012-03-05 08:47:41 -0700137 mutex_lock(&deferred_probe_mutex);
Greg Kroah-Hartmanef8a3fd2012-03-08 12:17:22 -0800138 if (list_empty(&dev->p->deferred_probe)) {
Grant Likelyd1c34142012-03-05 08:47:41 -0700139 dev_dbg(dev, "Added to deferred list\n");
Kuninori Morimoto1d29cfa2012-05-29 18:46:06 -0700140 list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list);
Grant Likelyd1c34142012-03-05 08:47:41 -0700141 }
142 mutex_unlock(&deferred_probe_mutex);
143}
144
145void driver_deferred_probe_del(struct device *dev)
146{
147 mutex_lock(&deferred_probe_mutex);
Greg Kroah-Hartmanef8a3fd2012-03-08 12:17:22 -0800148 if (!list_empty(&dev->p->deferred_probe)) {
Grant Likelyd1c34142012-03-05 08:47:41 -0700149 dev_dbg(dev, "Removed from deferred list\n");
Greg Kroah-Hartmanef8a3fd2012-03-08 12:17:22 -0800150 list_del_init(&dev->p->deferred_probe);
Ahmad Fatoum72a91f12021-03-23 16:37:13 +0100151 __device_set_deferred_probe_reason(dev, NULL);
Grant Likelyd1c34142012-03-05 08:47:41 -0700152 }
153 mutex_unlock(&deferred_probe_mutex);
154}
155
lizhe90158132022-03-09 05:54:18 -0800156static bool driver_deferred_probe_enable;
Grant Likelyd1c34142012-03-05 08:47:41 -0700157/**
158 * driver_deferred_probe_trigger() - Kick off re-probing deferred devices
159 *
160 * This functions moves all devices from the pending list to the active
161 * list and schedules the deferred probe workqueue to process them. It
162 * should be called anytime a driver is successfully bound to a device.
Grant Likely58b116b2014-04-29 12:05:22 +0100163 *
164 * Note, there is a race condition in multi-threaded probe. In the case where
165 * more than one device is probing at the same time, it is possible for one
166 * probe to complete successfully while another is about to defer. If the second
167 * depends on the first, then it will get put on the pending list after the
Shailendra Verma9ba8af62015-05-25 23:46:11 +0530168 * trigger event has already occurred and will be stuck there.
Grant Likely58b116b2014-04-29 12:05:22 +0100169 *
170 * The atomic 'deferred_trigger_count' is used to determine if a successful
171 * trigger has occurred in the midst of probing a driver. If the trigger count
172 * changes in the midst of a probe, then deferred processing should be triggered
173 * again.
Grant Likelyd1c34142012-03-05 08:47:41 -0700174 */
Saravana Kannan2f8c3ae2022-06-01 00:07:00 -0700175void driver_deferred_probe_trigger(void)
Grant Likelyd1c34142012-03-05 08:47:41 -0700176{
177 if (!driver_deferred_probe_enable)
178 return;
179
Greg Kroah-Hartman8b0372a2012-03-08 12:20:37 -0800180 /*
181 * A successful probe means that all the devices in the pending list
Grant Likelyd1c34142012-03-05 08:47:41 -0700182 * should be triggered to be reprobed. Move all the deferred devices
Greg Kroah-Hartman8b0372a2012-03-08 12:20:37 -0800183 * into the active list so they can be retried by the workqueue
184 */
Grant Likelyd1c34142012-03-05 08:47:41 -0700185 mutex_lock(&deferred_probe_mutex);
Grant Likely58b116b2014-04-29 12:05:22 +0100186 atomic_inc(&deferred_trigger_count);
Grant Likelyd1c34142012-03-05 08:47:41 -0700187 list_splice_tail_init(&deferred_probe_pending_list,
188 &deferred_probe_active_list);
189 mutex_unlock(&deferred_probe_mutex);
190
Greg Kroah-Hartman8b0372a2012-03-08 12:20:37 -0800191 /*
192 * Kick the re-probe thread. It may already be scheduled, but it is
193 * safe to kick it again.
194 */
Yogesh Lale611f8c2021-03-24 16:31:38 +0530195 queue_work(system_unbound_wq, &deferred_probe_work);
Grant Likelyd1c34142012-03-05 08:47:41 -0700196}
197
198/**
Randy Dunlapdbf03d6562018-11-05 23:41:27 -0800199 * device_block_probing() - Block/defer device's probes
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200200 *
201 * It will disable probing of devices and defer their probes instead.
202 */
203void device_block_probing(void)
204{
205 defer_all_probes = true;
206 /* sync with probes to avoid races. */
207 wait_for_device_probe();
208}
209
210/**
211 * device_unblock_probing() - Unblock/enable device's probes
212 *
213 * It will restore normal behavior and trigger re-probing of deferred
214 * devices.
215 */
216void device_unblock_probing(void)
217{
218 defer_all_probes = false;
219 driver_deferred_probe_trigger();
220}
221
Andrzej Hajdad090b702020-07-13 16:43:22 +0200222/**
223 * device_set_deferred_probe_reason() - Set defer probe reason message for device
224 * @dev: the pointer to the struct device
225 * @vaf: the pointer to va_format structure with message
226 */
227void device_set_deferred_probe_reason(const struct device *dev, struct va_format *vaf)
228{
229 const char *drv = dev_driver_string(dev);
Ahmad Fatoum72a91f12021-03-23 16:37:13 +0100230 char *reason;
Andrzej Hajdad090b702020-07-13 16:43:22 +0200231
232 mutex_lock(&deferred_probe_mutex);
233
Ahmad Fatoum72a91f12021-03-23 16:37:13 +0100234 reason = kasprintf(GFP_KERNEL, "%s: %pV", drv, vaf);
235 __device_set_deferred_probe_reason(dev, reason);
Andrzej Hajdad090b702020-07-13 16:43:22 +0200236
237 mutex_unlock(&deferred_probe_mutex);
238}
239
Javier Martinez Canillas28af109a2018-07-08 15:34:59 +0200240/*
241 * deferred_devs_show() - Show the devices in the deferred probe pending list.
242 */
243static int deferred_devs_show(struct seq_file *s, void *data)
244{
245 struct device_private *curr;
246
247 mutex_lock(&deferred_probe_mutex);
248
249 list_for_each_entry(curr, &deferred_probe_pending_list, deferred_probe)
Andrzej Hajdad090b702020-07-13 16:43:22 +0200250 seq_printf(s, "%s\t%s", dev_name(curr->device),
251 curr->device->p->deferred_probe_reason ?: "\n");
Javier Martinez Canillas28af109a2018-07-08 15:34:59 +0200252
253 mutex_unlock(&deferred_probe_mutex);
254
255 return 0;
256}
257DEFINE_SHOW_ATTRIBUTE(deferred_devs);
258
Saravana Kannanf516d012022-06-01 00:07:02 -0700259#ifdef CONFIG_MODULES
Javier Martinez Canillas504fa212022-12-28 00:21:52 +0100260static int driver_deferred_probe_timeout = 10;
Saravana Kannanf516d012022-06-01 00:07:02 -0700261#else
Javier Martinez Canillas504fa212022-12-28 00:21:52 +0100262static int driver_deferred_probe_timeout;
Saravana Kannanf516d012022-06-01 00:07:02 -0700263#endif
264
Rob Herring25b4e702018-07-09 09:41:48 -0600265static int __init deferred_probe_timeout_setup(char *str)
266{
Muchun Song63c98042018-10-28 14:39:11 +0800267 int timeout;
268
269 if (!kstrtoint(str, 10, &timeout))
John Stultz64c775f2020-02-25 05:08:27 +0000270 driver_deferred_probe_timeout = timeout;
Rob Herring25b4e702018-07-09 09:41:48 -0600271 return 1;
272}
273__setup("deferred_probe_timeout=", deferred_probe_timeout_setup);
274
Saravana Kannan13a8e0f2022-08-19 15:16:11 -0700275/**
276 * driver_deferred_probe_check_state() - Check deferred probe state
277 * @dev: device to check
278 *
279 * Return:
280 * * -ENODEV if initcalls have completed and modules are disabled.
281 * * -ETIMEDOUT if the deferred probe timeout was set and has expired
282 * and modules are enabled.
283 * * -EPROBE_DEFER in other cases.
284 *
285 * Drivers or subsystems can opt-in to calling this function instead of directly
286 * returning -EPROBE_DEFER.
287 */
288int driver_deferred_probe_check_state(struct device *dev)
289{
290 if (!IS_ENABLED(CONFIG_MODULES) && initcalls_done) {
291 dev_warn(dev, "ignoring dependency for device, assuming no driver\n");
292 return -ENODEV;
293 }
294
295 if (!driver_deferred_probe_timeout && initcalls_done) {
296 dev_warn(dev, "deferred probe timeout, ignoring dependency\n");
297 return -ETIMEDOUT;
298 }
299
300 return -EPROBE_DEFER;
301}
302EXPORT_SYMBOL_GPL(driver_deferred_probe_check_state);
303
Rob Herring25b4e702018-07-09 09:41:48 -0600304static void deferred_probe_timeout_work_func(struct work_struct *work)
305{
Saravana Kannaneed6e412021-04-01 21:03:40 -0700306 struct device_private *p;
Rob Herring25b4e702018-07-09 09:41:48 -0600307
Saravana Kannand46f3e32021-04-01 21:03:41 -0700308 fw_devlink_drivers_done();
309
Saravana Kannan13a8e0f2022-08-19 15:16:11 -0700310 driver_deferred_probe_timeout = 0;
Rob Herring25b4e702018-07-09 09:41:48 -0600311 driver_deferred_probe_trigger();
312 flush_work(&deferred_probe_work);
313
Saravana Kannaneed6e412021-04-01 21:03:40 -0700314 mutex_lock(&deferred_probe_mutex);
315 list_for_each_entry(p, &deferred_probe_pending_list, deferred_probe)
316 dev_info(p->device, "deferred probe pending\n");
317 mutex_unlock(&deferred_probe_mutex);
Rob Herring25b4e702018-07-09 09:41:48 -0600318}
319static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func);
320
Saravana Kannan2b28a1a2022-04-29 15:09:32 -0700321void deferred_probe_extend_timeout(void)
322{
323 /*
324 * If the work hasn't been queued yet or if the work expired, don't
325 * start a new one.
326 */
327 if (cancel_delayed_work(&deferred_probe_timeout_work)) {
328 schedule_delayed_work(&deferred_probe_timeout_work,
329 driver_deferred_probe_timeout * HZ);
330 pr_debug("Extended deferred probe timeout by %d secs\n",
331 driver_deferred_probe_timeout);
332 }
333}
334
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200335/**
Grant Likelyd1c34142012-03-05 08:47:41 -0700336 * deferred_probe_initcall() - Enable probing of deferred devices
337 *
338 * We don't want to get in the way when the bulk of drivers are getting probed.
339 * Instead, this initcall makes sure that deferred probing is delayed until
340 * late_initcall time.
341 */
342static int deferred_probe_initcall(void)
343{
Greg Kroah-Hartman2942df672021-02-16 15:24:00 +0100344 debugfs_create_file("devices_deferred", 0444, NULL, NULL,
345 &deferred_devs_fops);
Javier Martinez Canillas28af109a2018-07-08 15:34:59 +0200346
Grant Likelyd1c34142012-03-05 08:47:41 -0700347 driver_deferred_probe_enable = true;
348 driver_deferred_probe_trigger();
Grant Likelyd72cca12013-02-14 18:14:27 +0000349 /* Sort as many dependencies as possible before exiting initcalls */
Bhaktipriya Shridhar2c507e42016-08-30 22:45:34 +0530350 flush_work(&deferred_probe_work);
Rob Herring25b4e702018-07-09 09:41:48 -0600351 initcalls_done = true;
352
Saravana Kannand46f3e32021-04-01 21:03:41 -0700353 if (!IS_ENABLED(CONFIG_MODULES))
354 fw_devlink_drivers_done();
355
Rob Herring25b4e702018-07-09 09:41:48 -0600356 /*
357 * Trigger deferred probe again, this time we won't defer anything
358 * that is optional
359 */
360 driver_deferred_probe_trigger();
361 flush_work(&deferred_probe_work);
362
John Stultz64c775f2020-02-25 05:08:27 +0000363 if (driver_deferred_probe_timeout > 0) {
Rob Herring25b4e702018-07-09 09:41:48 -0600364 schedule_delayed_work(&deferred_probe_timeout_work,
John Stultz64c775f2020-02-25 05:08:27 +0000365 driver_deferred_probe_timeout * HZ);
Rob Herring25b4e702018-07-09 09:41:48 -0600366 }
Grant Likelyd1c34142012-03-05 08:47:41 -0700367 return 0;
368}
369late_initcall(deferred_probe_initcall);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800370
Javier Martinez Canillas28af109a2018-07-08 15:34:59 +0200371static void __exit deferred_probe_exit(void)
372{
Greg Kroah-Hartman36c893d2023-02-02 15:16:21 +0100373 debugfs_lookup_and_remove("devices_deferred", NULL);
Javier Martinez Canillas28af109a2018-07-08 15:34:59 +0200374}
375__exitcall(deferred_probe_exit);
376
Tomeu Vizoso6b9cb422016-01-07 16:46:12 +0100377/**
378 * device_is_bound() - Check if device is bound to a driver
379 * @dev: device to check
380 *
381 * Returns true if passed device has already finished probing successfully
382 * against a driver.
383 *
384 * This function must be called with the device lock held.
385 */
386bool device_is_bound(struct device *dev)
387{
Rafael J. Wysocki3ded9102016-01-12 01:51:44 +0100388 return dev->p && klist_node_attached(&dev->p->knode_driver);
Tomeu Vizoso6b9cb422016-01-07 16:46:12 +0100389}
390
Kay Sievers1901fb22006-10-07 21:55:55 +0200391static void driver_bound(struct device *dev)
392{
Tomeu Vizoso6b9cb422016-01-07 16:46:12 +0100393 if (device_is_bound(dev)) {
Christophe JAILLETeb7fbc92020-04-11 15:31:58 +0200394 pr_warn("%s: device %s already bound\n",
Harvey Harrison2b3a3022008-03-04 16:41:05 -0800395 __func__, kobject_name(&dev->kobj));
Kay Sievers1901fb22006-10-07 21:55:55 +0200396 return;
397 }
398
Frank Rowand94f8cc02014-04-16 17:12:30 -0700399 pr_debug("driver: '%s': %s: bound to device '%s'\n", dev->driver->name,
400 __func__, dev_name(dev));
Kay Sievers1901fb22006-10-07 21:55:55 +0200401
Stefani Seiboldfbb88fa2010-03-06 17:50:14 +0100402 klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +0100403 device_links_driver_bound(dev);
Stefani Seiboldfbb88fa2010-03-06 17:50:14 +0100404
Tomeu Vizosoaa8e54b52016-01-07 16:46:14 +0100405 device_pm_check_callbacks(dev);
406
Greg Kroah-Hartman8b0372a2012-03-08 12:20:37 -0800407 /*
408 * Make sure the device is no longer in one of the deferred lists and
409 * kick off retrying all pending devices
410 */
Grant Likelyd1c34142012-03-05 08:47:41 -0700411 driver_deferred_probe_del(dev);
412 driver_deferred_probe_trigger();
413
Greg Kroah-Hartmaned9f9182023-01-11 10:23:31 +0100414 bus_notify(dev, BUS_NOTIFY_BOUND_DRIVER);
Dmitry Torokhov1455cf82017-07-19 17:24:30 -0700415 kobject_uevent(&dev->kobj, KOBJ_BIND);
Kay Sievers1901fb22006-10-07 21:55:55 +0200416}
417
Arend van Spriel3c47d192018-01-11 09:36:38 +0100418static ssize_t coredump_store(struct device *dev, struct device_attribute *attr,
419 const char *buf, size_t count)
420{
421 device_lock(dev);
Arend van Spriel1fe56e02018-03-15 10:55:25 +0100422 dev->driver->coredump(dev);
Arend van Spriel3c47d192018-01-11 09:36:38 +0100423 device_unlock(dev);
424
425 return count;
426}
427static DEVICE_ATTR_WO(coredump);
428
Kay Sievers1901fb22006-10-07 21:55:55 +0200429static int driver_sysfs_add(struct device *dev)
430{
431 int ret;
432
Greg Kroah-Hartmaned9f9182023-01-11 10:23:31 +0100433 bus_notify(dev, BUS_NOTIFY_BIND_DRIVER);
Magnus Damm45daef02010-07-23 19:56:18 +0900434
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800435 ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,
Arend van Spriel3c47d192018-01-11 09:36:38 +0100436 kobject_name(&dev->kobj));
437 if (ret)
438 goto fail;
439
440 ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,
441 "driver");
442 if (ret)
443 goto rm_dev;
444
Jia-Ju Baid225ef62021-03-23 19:34:05 -0700445 if (!IS_ENABLED(CONFIG_DEV_COREDUMP) || !dev->driver->coredump)
446 return 0;
447
448 ret = device_create_file(dev, &dev_attr_coredump);
449 if (!ret)
Arend van Spriel3c47d192018-01-11 09:36:38 +0100450 return 0;
451
452 sysfs_remove_link(&dev->kobj, "driver");
453
454rm_dev:
455 sysfs_remove_link(&dev->driver->p->kobj,
Kay Sievers1901fb22006-10-07 21:55:55 +0200456 kobject_name(&dev->kobj));
Arend van Spriel3c47d192018-01-11 09:36:38 +0100457
458fail:
Kay Sievers1901fb22006-10-07 21:55:55 +0200459 return ret;
460}
461
462static void driver_sysfs_remove(struct device *dev)
463{
464 struct device_driver *drv = dev->driver;
465
466 if (drv) {
Arend van Spriel3c47d192018-01-11 09:36:38 +0100467 if (drv->coredump)
468 device_remove_file(dev, &dev_attr_coredump);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800469 sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));
Kay Sievers1901fb22006-10-07 21:55:55 +0200470 sysfs_remove_link(&dev->kobj, "driver");
471 }
472}
473
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800474/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800475 * device_bind_driver - bind a driver to one device.
476 * @dev: device.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800477 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800478 * Allow manual attachment of a driver to a device.
479 * Caller must have already set @dev->driver.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800480 *
Lukas Wunnerfe940d72020-07-08 14:12:22 +0200481 * Note that this does not modify the bus reference count.
482 * Please verify that is accounted for before calling this.
483 * (It is ok to call with no other effort from a driver's probe() method.)
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700484 *
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800485 * This function must be called with the device lock held.
Jason Gunthorpe0d9f8372021-06-17 16:22:13 +0200486 *
487 * Callers should prefer to use device_driver_attach() instead.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800488 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700489int device_bind_driver(struct device *dev)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800490{
Cornelia Huckcb986b72006-11-27 10:35:12 +0100491 int ret;
492
493 ret = driver_sysfs_add(dev);
Saravana Kannanb6f617d2021-03-02 13:11:31 -0800494 if (!ret) {
495 device_links_force_bind(dev);
Cornelia Huckcb986b72006-11-27 10:35:12 +0100496 driver_bound(dev);
Saravana Kannanb6f617d2021-03-02 13:11:31 -0800497 }
Greg Kroah-Hartmaned9f9182023-01-11 10:23:31 +0100498 else
499 bus_notify(dev, BUS_NOTIFY_DRIVER_NOT_BOUND);
Cornelia Huckcb986b72006-11-27 10:35:12 +0100500 return ret;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800501}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800502EXPORT_SYMBOL_GPL(device_bind_driver);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800503
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700504static atomic_t probe_count = ATOMIC_INIT(0);
Andrew Morton735a7ff2006-10-27 11:42:37 -0700505static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
506
Saravana Kannan8fd456e2020-05-21 12:17:59 -0700507static ssize_t state_synced_show(struct device *dev,
508 struct device_attribute *attr, char *buf)
509{
510 bool val;
511
512 device_lock(dev);
513 val = dev->state_synced;
514 device_unlock(dev);
Joe Perches948b3ed2020-09-16 13:40:42 -0700515
Joe Perchesaa838892020-09-16 13:40:39 -0700516 return sysfs_emit(buf, "%u\n", val);
Saravana Kannan8fd456e2020-05-21 12:17:59 -0700517}
518static DEVICE_ATTR_RO(state_synced);
519
Rob Herring9ad30722022-02-23 16:52:56 -0600520static void device_unbind_cleanup(struct device *dev)
521{
522 devres_release_all(dev);
523 arch_teardown_dma_ops(dev);
524 kfree(dev->dma_range_map);
525 dev->dma_range_map = NULL;
526 dev->driver = NULL;
527 dev_set_drvdata(dev, NULL);
528 if (dev->pm_domain && dev->pm_domain->dismiss)
529 dev->pm_domain->dismiss(dev);
530 pm_runtime_reinit(dev);
531 dev_pm_set_driver_flags(dev, 0);
532}
Christoph Hellwige1499642021-06-17 16:22:10 +0200533
Rob Herring4b775aa2022-02-23 16:52:57 -0600534static void device_remove(struct device *dev)
535{
536 device_remove_file(dev, &dev_attr_state_synced);
537 device_remove_groups(dev, dev->driver->dev_groups);
538
539 if (dev->bus && dev->bus->remove)
540 dev->bus->remove(dev);
541 else if (dev->driver->remove)
542 dev->driver->remove(dev);
543}
544
Christoph Hellwige1499642021-06-17 16:22:10 +0200545static int call_driver_probe(struct device *dev, struct device_driver *drv)
546{
547 int ret = 0;
548
549 if (dev->bus->probe)
550 ret = dev->bus->probe(dev);
551 else if (drv->probe)
552 ret = drv->probe(dev);
553
554 switch (ret) {
555 case 0:
556 break;
557 case -EPROBE_DEFER:
558 /* Driver requested deferred probing */
559 dev_dbg(dev, "Driver %s requests probe deferral\n", drv->name);
560 break;
561 case -ENODEV:
562 case -ENXIO:
563 pr_debug("%s: probe of %s rejects match %d\n",
564 drv->name, dev_name(dev), ret);
565 break;
566 default:
567 /* driver matched but the probe failed */
568 pr_warn("%s: probe of %s failed with error %d\n",
569 drv->name, dev_name(dev), ret);
570 break;
571 }
572
573 return ret;
574}
575
Cornelia Huck21c7f302007-02-05 16:15:25 -0800576static int really_probe(struct device *dev, struct device_driver *drv)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800577{
Rob Herringc5f06272016-10-11 13:41:02 -0500578 bool test_remove = IS_ENABLED(CONFIG_DEBUG_TEST_DRIVER_REMOVE) &&
579 !drv->suppress_bind_attrs;
Saravana Kannan2f8c3ae2022-06-01 00:07:00 -0700580 int ret, link_ret;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800581
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200582 if (defer_all_probes) {
583 /*
584 * Value of defer_all_probes can be set only by
Randy Dunlapdbf03d6562018-11-05 23:41:27 -0800585 * device_block_probing() which, in turn, will call
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200586 * wait_for_device_probe() right after that to avoid any races.
587 */
588 dev_dbg(dev, "Driver %s force probe deferral\n", drv->name);
Christoph Hellwig45ddcb42021-06-17 16:22:12 +0200589 return -EPROBE_DEFER;
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200590 }
591
Saravana Kannan2f8c3ae2022-06-01 00:07:00 -0700592 link_ret = device_links_check_suppliers(dev);
593 if (link_ret == -EPROBE_DEFER)
594 return link_ret;
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +0100595
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -0800596 pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100597 drv->bus->name, __func__, drv->name, dev_name(dev));
Geert Uytterhoeven7c35e692019-12-06 14:22:19 +0100598 if (!list_empty(&dev->devres_head)) {
599 dev_crit(dev, "Resources present before probing\n");
Tetsuo Handab292b502020-07-13 11:12:54 +0900600 ret = -EBUSY;
601 goto done;
Geert Uytterhoeven7c35e692019-12-06 14:22:19 +0100602 }
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800603
Rob Herringbea5b152016-08-11 10:20:58 -0500604re_probe:
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800605 dev->driver = drv;
Linus Walleijab780292013-01-22 10:56:14 -0700606
607 /* If using pinctrl, bind pins now before probing */
608 ret = pinctrl_bind_pins(dev);
609 if (ret)
Andy Shevchenko14b62572015-12-04 23:49:17 +0200610 goto pinctrl_bind_failed;
Linus Walleijab780292013-01-22 10:56:14 -0700611
Christoph Hellwigccf640f2018-08-24 09:40:24 +0200612 if (dev->bus->dma_configure) {
613 ret = dev->bus->dma_configure(dev);
614 if (ret)
Lu Baolu00eb74e2021-12-31 11:39:01 +0800615 goto pinctrl_bind_failed;
Christoph Hellwigccf640f2018-08-24 09:40:24 +0200616 }
Sricharan R09515ef2017-04-10 16:51:01 +0530617
Zhen Leif04948d2021-07-07 15:43:01 +0800618 ret = driver_sysfs_add(dev);
619 if (ret) {
Christophe JAILLETeb7fbc92020-04-11 15:31:58 +0200620 pr_err("%s: driver_sysfs_add(%s) failed\n",
621 __func__, dev_name(dev));
Lu Baolu885e5022021-12-31 11:39:00 +0800622 goto sysfs_failed;
Kay Sievers1901fb22006-10-07 21:55:55 +0200623 }
624
Rafael J. Wysockie90d5532015-03-20 13:59:27 +0100625 if (dev->pm_domain && dev->pm_domain->activate) {
626 ret = dev->pm_domain->activate(dev);
627 if (ret)
628 goto probe_failed;
629 }
630
Christoph Hellwig45ddcb42021-06-17 16:22:12 +0200631 ret = call_driver_probe(dev, drv);
632 if (ret) {
Christoph Hellwige1499642021-06-17 16:22:10 +0200633 /*
Saravana Kannan2f8c3ae2022-06-01 00:07:00 -0700634 * If fw_devlink_best_effort is active (denoted by -EAGAIN), the
635 * device might actually probe properly once some of its missing
636 * suppliers have probed. So, treat this as if the driver
637 * returned -EPROBE_DEFER.
638 */
639 if (link_ret == -EAGAIN)
640 ret = -EPROBE_DEFER;
641
642 /*
Christoph Hellwigef6dcbd2021-06-17 16:22:11 +0200643 * Return probe errors as positive values so that the callers
644 * can distinguish them from other errors.
Christoph Hellwige1499642021-06-17 16:22:10 +0200645 */
Christoph Hellwig45ddcb42021-06-17 16:22:12 +0200646 ret = -ret;
Christoph Hellwige1499642021-06-17 16:22:10 +0200647 goto probe_failed;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800648 }
Kay Sievers1901fb22006-10-07 21:55:55 +0200649
Zhen Leif04948d2021-07-07 15:43:01 +0800650 ret = device_add_groups(dev, drv->dev_groups);
651 if (ret) {
Dmitry Torokhov23b69042019-07-31 14:43:40 +0200652 dev_err(dev, "device_add_groups() failed\n");
653 goto dev_groups_failed;
654 }
655
Zhen Leif04948d2021-07-07 15:43:01 +0800656 if (dev_has_sync_state(dev)) {
657 ret = device_create_file(dev, &dev_attr_state_synced);
658 if (ret) {
659 dev_err(dev, "state_synced sysfs add failed\n");
660 goto dev_sysfs_state_synced_failed;
661 }
Saravana Kannan8fd456e2020-05-21 12:17:59 -0700662 }
663
Rob Herringbea5b152016-08-11 10:20:58 -0500664 if (test_remove) {
665 test_remove = false;
666
Rob Herring4b775aa2022-02-23 16:52:57 -0600667 device_remove(dev);
Rob Herringbea5b152016-08-11 10:20:58 -0500668 driver_sysfs_remove(dev);
Rob Herring9ad30722022-02-23 16:52:56 -0600669 device_unbind_cleanup(dev);
Rob Herringbea5b152016-08-11 10:20:58 -0500670
671 goto re_probe;
672 }
673
Douglas Andersonef0eebc2015-10-20 21:15:06 -0700674 pinctrl_init_done(dev);
675
Rafael J. Wysockie90d5532015-03-20 13:59:27 +0100676 if (dev->pm_domain && dev->pm_domain->sync)
677 dev->pm_domain->sync(dev);
678
Kay Sievers1901fb22006-10-07 21:55:55 +0200679 driver_bound(dev);
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -0800680 pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100681 drv->bus->name, __func__, dev_name(dev), drv->name);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700682 goto done;
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700683
Saravana Kannan8fd456e2020-05-21 12:17:59 -0700684dev_sysfs_state_synced_failed:
Dmitry Torokhov23b69042019-07-31 14:43:40 +0200685dev_groups_failed:
Rob Herring4b775aa2022-02-23 16:52:57 -0600686 device_remove(dev);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700687probe_failed:
Lu Baolu885e5022021-12-31 11:39:00 +0800688 driver_sysfs_remove(dev);
689sysfs_failed:
Greg Kroah-Hartmaned9f9182023-01-11 10:23:31 +0100690 bus_notify(dev, BUS_NOTIFY_DRIVER_NOT_BOUND);
Lu Baolu25f3bcf2022-04-18 08:49:51 +0800691 if (dev->bus && dev->bus->dma_cleanup)
692 dev->bus->dma_cleanup(dev);
Andy Shevchenko14b62572015-12-04 23:49:17 +0200693pinctrl_bind_failed:
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +0100694 device_links_no_driver(dev);
Rob Herring9ad30722022-02-23 16:52:56 -0600695 device_unbind_cleanup(dev);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700696done:
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700697 return ret;
698}
699
Todd Poynor0a50f612018-06-20 17:35:56 -0700700/*
701 * For initcall_debug, show the driver probe time.
702 */
703static int really_probe_debug(struct device *dev, struct device_driver *drv)
704{
Zenghui Yue3aa7452020-08-03 11:33:43 +0800705 ktime_t calltime, rettime;
Todd Poynor0a50f612018-06-20 17:35:56 -0700706 int ret;
707
708 calltime = ktime_get();
709 ret = really_probe(dev, drv);
710 rettime = ktime_get();
Christophe JAILLETeb7fbc92020-04-11 15:31:58 +0200711 pr_debug("probe of %s returned %d after %lld usecs\n",
Zenghui Yue3aa7452020-08-03 11:33:43 +0800712 dev_name(dev), ret, ktime_us_delta(rettime, calltime));
Todd Poynor0a50f612018-06-20 17:35:56 -0700713 return ret;
714}
715
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700716/**
717 * driver_probe_done
718 * Determine if the probe sequence is finished or not.
719 *
720 * Should somehow figure out how to use a semaphore, not an atomic variable...
721 */
722int driver_probe_done(void)
723{
Andy Shevchenko927f8282020-03-24 14:20:22 +0200724 int local_probe_count = atomic_read(&probe_count);
725
726 pr_debug("%s: probe_count = %d\n", __func__, local_probe_count);
727 if (local_probe_count)
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700728 return -EBUSY;
729 return 0;
730}
731
732/**
Arjan van de Ven216773a2009-02-14 01:59:06 +0100733 * wait_for_device_probe
734 * Wait for device probing to be completed.
Arjan van de Ven216773a2009-02-14 01:59:06 +0100735 */
Ming Leib23530e2009-02-21 16:45:07 +0800736void wait_for_device_probe(void)
Arjan van de Ven216773a2009-02-14 01:59:06 +0100737{
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200738 /* wait for the deferred probe workqueue to finish */
Bhaktipriya Shridhar2c507e42016-08-30 22:45:34 +0530739 flush_work(&deferred_probe_work);
Strashko, Grygorii013c0742015-11-10 11:42:34 +0200740
Arjan van de Ven216773a2009-02-14 01:59:06 +0100741 /* wait for the known devices to complete their probing */
Ming Leib23530e2009-02-21 16:45:07 +0800742 wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
Arjan van de Ven216773a2009-02-14 01:59:06 +0100743 async_synchronize_full();
Arjan van de Ven216773a2009-02-14 01:59:06 +0100744}
Arjan van de Vend4d52912009-04-21 13:32:54 -0700745EXPORT_SYMBOL_GPL(wait_for_device_probe);
Arjan van de Ven216773a2009-02-14 01:59:06 +0100746
Christoph Hellwig45ddcb42021-06-17 16:22:12 +0200747static int __driver_probe_device(struct device_driver *drv, struct device *dev)
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700748{
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700749 int ret = 0;
750
Jason Gunthorpe204db602021-06-17 16:22:09 +0200751 if (dev->p->dead || !device_is_registered(dev))
Alan Sternf2eaae12006-09-18 16:22:34 -0400752 return -ENODEV;
Jason Gunthorpe204db602021-06-17 16:22:09 +0200753 if (dev->driver)
754 return -EBUSY;
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700755
Saravana Kannanf2db85b2021-03-02 13:11:30 -0800756 dev->can_match = true;
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -0800757 pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100758 drv->bus->name, __func__, dev_name(dev), drv->name);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700759
Rafael J. Wysockib06c0b2f2018-06-12 10:24:13 +0200760 pm_runtime_get_suppliers(dev);
Rafael J. Wysockiddef08d2015-07-27 18:03:58 +0300761 if (dev->parent)
762 pm_runtime_get_sync(dev->parent);
763
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200764 pm_runtime_barrier(dev);
Todd Poynor0a50f612018-06-20 17:35:56 -0700765 if (initcall_debug)
766 ret = really_probe_debug(dev, drv);
767 else
768 ret = really_probe(dev, drv);
Ulf Hanssonfa180eb2013-04-10 17:00:48 +0200769 pm_request_idle(dev);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700770
Rafael J. Wysockiddef08d2015-07-27 18:03:58 +0300771 if (dev->parent)
772 pm_runtime_put(dev->parent);
773
Rafael J. Wysockib06c0b2f2018-06-12 10:24:13 +0200774 pm_runtime_put_suppliers(dev);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -0700775 return ret;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -0800776}
777
Christoph Hellwig45ddcb42021-06-17 16:22:12 +0200778/**
779 * driver_probe_device - attempt to bind device & driver together
780 * @drv: driver to bind a device to
781 * @dev: device to try to bind to the driver
782 *
783 * This function returns -ENODEV if the device is not registered, -EBUSY if it
784 * already has a driver, 0 if the device is bound successfully and a positive
785 * (inverted) error code for failures from the ->probe method.
786 *
787 * This function must be called with @dev lock held. When called for a
788 * USB interface, @dev->parent lock must be held as well.
789 *
790 * If the device has a parent, runtime-resume the parent before driver probing.
791 */
792static int driver_probe_device(struct device_driver *drv, struct device *dev)
793{
794 int trigger_count = atomic_read(&deferred_trigger_count);
795 int ret;
796
797 atomic_inc(&probe_count);
798 ret = __driver_probe_device(drv, dev);
799 if (ret == -EPROBE_DEFER || ret == EPROBE_DEFER) {
800 driver_deferred_probe_add(dev);
801
802 /*
803 * Did a trigger occur while probing? Need to re-trigger if yes
804 */
805 if (trigger_count != atomic_read(&deferred_trigger_count) &&
806 !defer_all_probes)
807 driver_deferred_probe_trigger();
808 }
809 atomic_dec(&probe_count);
810 wake_up_all(&probe_waitqueue);
811 return ret;
812}
813
Feng Tang1ea61b62019-02-13 15:47:36 +0800814static inline bool cmdline_requested_async_probing(const char *drv_name)
815{
Saravana Kannanf79f662e2022-05-03 17:53:43 -0700816 bool async_drv;
817
818 async_drv = parse_option_str(async_probe_drv_names, drv_name);
819
820 return (async_probe_default != async_drv);
Feng Tang1ea61b62019-02-13 15:47:36 +0800821}
822
823/* The option format is "driver_async_probe=drv_name1,drv_name2,..." */
824static int __init save_async_options(char *buf)
825{
826 if (strlen(buf) >= ASYNC_DRV_NAMES_MAX_LEN)
Christophe JAILLETeb7fbc92020-04-11 15:31:58 +0200827 pr_warn("Too long list of driver names for 'driver_async_probe'!\n");
Feng Tang1ea61b62019-02-13 15:47:36 +0800828
Wolfram Sang07b7b882022-08-18 22:59:56 +0200829 strscpy(async_probe_drv_names, buf, ASYNC_DRV_NAMES_MAX_LEN);
Saravana Kannanf79f662e2022-05-03 17:53:43 -0700830 async_probe_default = parse_option_str(async_probe_drv_names, "*");
831
Randy Dunlapf2aad542022-02-28 20:18:29 -0800832 return 1;
Feng Tang1ea61b62019-02-13 15:47:36 +0800833}
834__setup("driver_async_probe=", save_async_options);
835
Christoph Hellwig189a87f2022-10-30 10:22:55 +0100836static bool driver_allows_async_probing(struct device_driver *drv)
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -0800837{
Luis R. Rodriguezd173a132015-03-30 16:20:06 -0700838 switch (drv->probe_type) {
839 case PROBE_PREFER_ASYNCHRONOUS:
Luis R. Rodriguezf2411da2015-03-30 16:20:05 -0700840 return true;
841
Luis R. Rodriguezd173a132015-03-30 16:20:06 -0700842 case PROBE_FORCE_SYNCHRONOUS:
843 return false;
Luis R. Rodriguezf2411da2015-03-30 16:20:05 -0700844
Luis R. Rodriguezd173a132015-03-30 16:20:06 -0700845 default:
Feng Tang1ea61b62019-02-13 15:47:36 +0800846 if (cmdline_requested_async_probing(drv->name))
847 return true;
848
Dmitry Torokhov80c6e142015-05-21 15:49:37 -0700849 if (module_requested_async_probing(drv->owner))
Luis R. Rodriguezd173a132015-03-30 16:20:06 -0700850 return true;
851
852 return false;
853 }
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700854}
855
856struct device_attach_data {
857 struct device *dev;
858
859 /*
Tom Rixb4ae8c22022-02-12 06:32:33 -0800860 * Indicates whether we are considering asynchronous probing or
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700861 * not. Only initial binding after device or driver registration
862 * (including deferral processing) may be done asynchronously, the
863 * rest is always synchronous, as we expect it is being done by
864 * request from userspace.
865 */
866 bool check_async;
867
868 /*
869 * Indicates if we are binding synchronous or asynchronous drivers.
870 * When asynchronous probing is enabled we'll execute 2 passes
871 * over drivers: first pass doing synchronous probing and second
872 * doing asynchronous probing (if synchronous did not succeed -
873 * most likely because there was no driver requiring synchronous
874 * probing - and we found asynchronous driver during first pass).
875 * The 2 passes are done because we can't shoot asynchronous
876 * probe for given device and driver from bus_for_each_drv() since
877 * driver pointer is not guaranteed to stay valid once
878 * bus_for_each_drv() iterates to the next driver on the bus.
879 */
880 bool want_async;
881
882 /*
883 * We'll set have_async to 'true' if, while scanning for matching
884 * driver, we'll encounter one that requests asynchronous probing.
885 */
886 bool have_async;
887};
888
889static int __device_attach_driver(struct device_driver *drv, void *_data)
890{
891 struct device_attach_data *data = _data;
892 struct device *dev = data->dev;
893 bool async_allowed;
Tomeu Vizoso656b8032016-02-15 09:25:06 +0100894 int ret;
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700895
Tomeu Vizoso656b8032016-02-15 09:25:06 +0100896 ret = driver_match_device(drv, dev);
897 if (ret == 0) {
898 /* no match */
Ming Lei49b420a2009-01-21 23:27:47 +0800899 return 0;
Tomeu Vizoso656b8032016-02-15 09:25:06 +0100900 } else if (ret == -EPROBE_DEFER) {
901 dev_dbg(dev, "Device match requests probe deferral\n");
Saravana Kannanf2db85b2021-03-02 13:11:30 -0800902 dev->can_match = true;
Tomeu Vizoso656b8032016-02-15 09:25:06 +0100903 driver_deferred_probe_add(dev);
Isaac J. Manjarres25e9fbf2022-08-17 11:40:26 -0700904 /*
905 * Device can't match with a driver right now, so don't attempt
906 * to match or bind with other drivers on the bus.
907 */
908 return ret;
Tomeu Vizoso656b8032016-02-15 09:25:06 +0100909 } else if (ret < 0) {
Christophe JAILLETeb7fbc92020-04-11 15:31:58 +0200910 dev_dbg(dev, "Bus failed to match device: %d\n", ret);
Tomeu Vizoso656b8032016-02-15 09:25:06 +0100911 return ret;
912 } /* ret > 0 means positive match */
Ming Lei49b420a2009-01-21 23:27:47 +0800913
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700914 async_allowed = driver_allows_async_probing(drv);
915
916 if (async_allowed)
917 data->have_async = true;
918
919 if (data->check_async && async_allowed != data->want_async)
920 return 0;
921
Christoph Hellwigef6dcbd2021-06-17 16:22:11 +0200922 /*
923 * Ignore errors returned by ->probe so that the next driver can try
924 * its luck.
925 */
926 ret = driver_probe_device(drv, dev);
927 if (ret < 0)
928 return ret;
929 return ret == 0;
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -0800930}
931
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700932static void __device_attach_async_helper(void *_dev, async_cookie_t cookie)
933{
934 struct device *dev = _dev;
935 struct device_attach_data data = {
936 .dev = dev,
937 .check_async = true,
938 .want_async = true,
939 };
940
941 device_lock(dev);
942
Alexander Duyck3451a492019-01-22 10:39:10 -0800943 /*
944 * Check if device has already been removed or claimed. This may
945 * happen with driver loading, device discovery/registration,
946 * and deferred probe processing happens all at once with
947 * multiple threads.
948 */
949 if (dev->p->dead || dev->driver)
950 goto out_unlock;
951
Rafael J. Wysockiddef08d2015-07-27 18:03:58 +0300952 if (dev->parent)
953 pm_runtime_get_sync(dev->parent);
954
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700955 bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver);
956 dev_dbg(dev, "async probe completed\n");
957
958 pm_request_idle(dev);
959
Rafael J. Wysockiddef08d2015-07-27 18:03:58 +0300960 if (dev->parent)
961 pm_runtime_put(dev->parent);
Alexander Duyck3451a492019-01-22 10:39:10 -0800962out_unlock:
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700963 device_unlock(dev);
964
965 put_device(dev);
966}
967
Dmitry Torokhov802a87f2015-05-20 16:36:31 -0700968static int __device_attach(struct device *dev, bool allow_async)
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700969{
970 int ret = 0;
Zhang Wenshengb232b022022-05-18 15:45:16 +0800971 bool async = false;
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700972
973 device_lock(dev);
Lukas Wunner65488832020-07-08 15:27:01 +0200974 if (dev->p->dead) {
975 goto out_unlock;
976 } else if (dev->driver) {
Tomeu Vizoso6b9cb422016-01-07 16:46:12 +0100977 if (device_is_bound(dev)) {
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700978 ret = 1;
979 goto out_unlock;
980 }
981 ret = device_bind_driver(dev);
982 if (ret == 0)
983 ret = 1;
984 else {
985 dev->driver = NULL;
986 ret = 0;
987 }
988 } else {
989 struct device_attach_data data = {
990 .dev = dev,
991 .check_async = allow_async,
992 .want_async = false,
993 };
994
Rafael J. Wysockiddef08d2015-07-27 18:03:58 +0300995 if (dev->parent)
996 pm_runtime_get_sync(dev->parent);
997
Dmitry Torokhov765230b2015-03-30 16:20:04 -0700998 ret = bus_for_each_drv(dev->bus, NULL, &data,
999 __device_attach_driver);
1000 if (!ret && allow_async && data.have_async) {
1001 /*
1002 * If we could not find appropriate driver
1003 * synchronously and we are allowed to do
1004 * async probes and there are drivers that
1005 * want to probe asynchronously, we'll
1006 * try them.
1007 */
1008 dev_dbg(dev, "scheduling asynchronous probe\n");
1009 get_device(dev);
Zhang Wenshengb232b022022-05-18 15:45:16 +08001010 async = true;
Dmitry Torokhov765230b2015-03-30 16:20:04 -07001011 } else {
1012 pm_request_idle(dev);
1013 }
Rafael J. Wysockiddef08d2015-07-27 18:03:58 +03001014
1015 if (dev->parent)
1016 pm_runtime_put(dev->parent);
Dmitry Torokhov765230b2015-03-30 16:20:04 -07001017 }
1018out_unlock:
1019 device_unlock(dev);
Zhang Wenshengb232b022022-05-18 15:45:16 +08001020 if (async)
1021 async_schedule_dev(__device_attach_async_helper, dev);
Dmitry Torokhov765230b2015-03-30 16:20:04 -07001022 return ret;
1023}
1024
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001025/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001026 * device_attach - try to attach device to a driver.
1027 * @dev: device.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001028 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001029 * Walk the list of drivers that the bus has and call
1030 * driver_probe_device() for each pair. If a compatible
1031 * pair is found, break out and return.
Patrick Mochel0d3e5a22005-04-05 23:46:33 -07001032 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001033 * Returns 1 if the device was bound to a driver;
Dmitry Torokhov59a3cd72009-05-05 20:38:28 -07001034 * 0 if no matching driver was found;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001035 * -ENODEV if the device is not registered.
Alan Sternbf74ad52005-11-17 16:54:12 -05001036 *
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -08001037 * When called for a USB interface, @dev->parent lock must be held.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001038 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001039int device_attach(struct device *dev)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001040{
Dmitry Torokhov765230b2015-03-30 16:20:04 -07001041 return __device_attach(dev, false);
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -08001042}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001043EXPORT_SYMBOL_GPL(device_attach);
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -08001044
Dmitry Torokhov765230b2015-03-30 16:20:04 -07001045void device_initial_probe(struct device *dev)
1046{
1047 __device_attach(dev, true);
1048}
1049
Alexander Duycked887472019-01-22 10:39:16 -08001050/*
1051 * __device_driver_lock - acquire locks needed to manipulate dev->drv
1052 * @dev: Device we will update driver info for
1053 * @parent: Parent device. Needed if the bus requires parent lock
1054 *
1055 * This function will take the required locks for manipulating dev->drv.
1056 * Normally this will just be the @dev lock, but when called for a USB
1057 * interface, @parent lock will be held as well.
1058 */
1059static void __device_driver_lock(struct device *dev, struct device *parent)
1060{
1061 if (parent && dev->bus->need_parent_lock)
1062 device_lock(parent);
1063 device_lock(dev);
1064}
1065
1066/*
1067 * __device_driver_unlock - release locks needed to manipulate dev->drv
1068 * @dev: Device we will update driver info for
1069 * @parent: Parent device. Needed if the bus requires parent lock
1070 *
1071 * This function will release the required locks for manipulating dev->drv.
Tom Rixb4ae8c22022-02-12 06:32:33 -08001072 * Normally this will just be the @dev lock, but when called for a
Alexander Duycked887472019-01-22 10:39:16 -08001073 * USB interface, @parent lock will be released as well.
1074 */
1075static void __device_driver_unlock(struct device *dev, struct device *parent)
1076{
1077 device_unlock(dev);
1078 if (parent && dev->bus->need_parent_lock)
1079 device_unlock(parent);
1080}
1081
1082/**
1083 * device_driver_attach - attach a specific driver to a specific device
1084 * @drv: Driver to attach
1085 * @dev: Device to attach it to
1086 *
1087 * Manually attach driver to a device. Will acquire both @dev lock and
Christoph Hellwigef6dcbd2021-06-17 16:22:11 +02001088 * @dev->parent lock if needed. Returns 0 on success, -ERR on failure.
Alexander Duycked887472019-01-22 10:39:16 -08001089 */
1090int device_driver_attach(struct device_driver *drv, struct device *dev)
1091{
Jason Gunthorpe204db602021-06-17 16:22:09 +02001092 int ret;
Alexander Duycked887472019-01-22 10:39:16 -08001093
1094 __device_driver_lock(dev, dev->parent);
Christoph Hellwig45ddcb42021-06-17 16:22:12 +02001095 ret = __driver_probe_device(drv, dev);
Alexander Duycked887472019-01-22 10:39:16 -08001096 __device_driver_unlock(dev, dev->parent);
1097
Christoph Hellwigef6dcbd2021-06-17 16:22:11 +02001098 /* also return probe errors as normal negative errnos */
1099 if (ret > 0)
1100 ret = -ret;
Christoph Hellwig45ddcb42021-06-17 16:22:12 +02001101 if (ret == -EPROBE_DEFER)
1102 return -EAGAIN;
Alexander Duycked887472019-01-22 10:39:16 -08001103 return ret;
1104}
Jason Gunthorpe0d9f8372021-06-17 16:22:13 +02001105EXPORT_SYMBOL_GPL(device_driver_attach);
Alexander Duycked887472019-01-22 10:39:16 -08001106
Alexander Duyckef0ff682019-01-22 10:39:21 -08001107static void __driver_attach_async_helper(void *_dev, async_cookie_t cookie)
1108{
1109 struct device *dev = _dev;
1110 struct device_driver *drv;
Jason Gunthorpe204db602021-06-17 16:22:09 +02001111 int ret;
Alexander Duyckef0ff682019-01-22 10:39:21 -08001112
1113 __device_driver_lock(dev, dev->parent);
Alexander Duyckef0ff682019-01-22 10:39:21 -08001114 drv = dev->p->async_driver;
Mark-PK Tsai84e7c672022-03-16 15:43:28 +08001115 dev->p->async_driver = NULL;
Jason Gunthorpe204db602021-06-17 16:22:09 +02001116 ret = driver_probe_device(drv, dev);
Alexander Duyckef0ff682019-01-22 10:39:21 -08001117 __device_driver_unlock(dev, dev->parent);
1118
1119 dev_dbg(dev, "driver %s async attach completed: %d\n", drv->name, ret);
1120
1121 put_device(dev);
1122}
1123
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001124static int __driver_attach(struct device *dev, void *data)
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -08001125{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001126 struct device_driver *drv = data;
Zhang Wensheng70fe7582022-06-22 15:43:27 +08001127 bool async = false;
Tomeu Vizoso656b8032016-02-15 09:25:06 +01001128 int ret;
mochel@digitalimplant.org2287c322005-03-24 10:50:24 -08001129
Patrick Mochel0d3e5a22005-04-05 23:46:33 -07001130 /*
1131 * Lock device and try to bind to it. We drop the error
1132 * here and always return 0, because we need to keep trying
1133 * to bind to devices and some drivers will return an error
1134 * simply if it didn't support the device.
1135 *
1136 * driver_probe_device() will spit a warning if there
1137 * is an error.
1138 */
1139
Tomeu Vizoso656b8032016-02-15 09:25:06 +01001140 ret = driver_match_device(drv, dev);
1141 if (ret == 0) {
1142 /* no match */
Arjan van de Ven6cd49582008-09-14 08:32:06 -07001143 return 0;
Tomeu Vizoso656b8032016-02-15 09:25:06 +01001144 } else if (ret == -EPROBE_DEFER) {
1145 dev_dbg(dev, "Device match requests probe deferral\n");
Saravana Kannanf2db85b2021-03-02 13:11:30 -08001146 dev->can_match = true;
Tomeu Vizoso656b8032016-02-15 09:25:06 +01001147 driver_deferred_probe_add(dev);
Isaac J. Manjarres25e9fbf2022-08-17 11:40:26 -07001148 /*
1149 * Driver could not match with device, but may match with
1150 * another device on the bus.
1151 */
1152 return 0;
Tomeu Vizoso656b8032016-02-15 09:25:06 +01001153 } else if (ret < 0) {
Christophe JAILLETeb7fbc92020-04-11 15:31:58 +02001154 dev_dbg(dev, "Bus failed to match device: %d\n", ret);
Isaac J. Manjarres27c0d212022-09-20 17:14:13 -07001155 /*
1156 * Driver could not match with device, but may match with
1157 * another device on the bus.
1158 */
1159 return 0;
Tomeu Vizoso656b8032016-02-15 09:25:06 +01001160 } /* ret > 0 means positive match */
Arjan van de Ven6cd49582008-09-14 08:32:06 -07001161
Alexander Duyckef0ff682019-01-22 10:39:21 -08001162 if (driver_allows_async_probing(drv)) {
1163 /*
1164 * Instead of probing the device synchronously we will
1165 * probe it asynchronously to allow for more parallelism.
1166 *
1167 * We only take the device lock here in order to guarantee
1168 * that the dev->driver and async_driver fields are protected
1169 */
1170 dev_dbg(dev, "probing driver %s asynchronously\n", drv->name);
1171 device_lock(dev);
Mark-PK Tsai84e7c672022-03-16 15:43:28 +08001172 if (!dev->driver && !dev->p->async_driver) {
Alexander Duyckef0ff682019-01-22 10:39:21 -08001173 get_device(dev);
1174 dev->p->async_driver = drv;
Zhang Wensheng70fe7582022-06-22 15:43:27 +08001175 async = true;
Alexander Duyckef0ff682019-01-22 10:39:21 -08001176 }
1177 device_unlock(dev);
Zhang Wensheng70fe7582022-06-22 15:43:27 +08001178 if (async)
1179 async_schedule_dev(__driver_attach_async_helper, dev);
Alexander Duyckef0ff682019-01-22 10:39:21 -08001180 return 0;
1181 }
1182
Christoph Hellwigef6dcbd2021-06-17 16:22:11 +02001183 __device_driver_lock(dev, dev->parent);
1184 driver_probe_device(drv, dev);
1185 __device_driver_unlock(dev, dev->parent);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -07001186
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001187 return 0;
1188}
1189
1190/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001191 * driver_attach - try to bind driver to devices.
1192 * @drv: driver.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001193 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001194 * Walk the list of devices that the bus has on it and try to
1195 * match the driver with each one. If driver_probe_device()
1196 * returns 0 and the @dev->driver is set, we've found a
1197 * compatible pair.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001198 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001199int driver_attach(struct device_driver *drv)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001200{
Andrew Mortonf86db392006-08-14 22:43:20 -07001201 return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001202}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001203EXPORT_SYMBOL_GPL(driver_attach);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001204
Stefan Richterab71c6f2007-06-17 11:02:12 +02001205/*
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -08001206 * __device_release_driver() must be called with @dev lock held.
1207 * When called for a USB interface, @dev->parent lock must be held as well.
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001208 */
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001209static void __device_release_driver(struct device *dev, struct device *parent)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001210{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001211 struct device_driver *drv;
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001212
Alan Sternef2c5172007-11-16 11:57:28 -05001213 drv = dev->driver;
Alan Sternc95a6b02005-05-06 15:38:33 -04001214 if (drv) {
Rafael J. Wysocki9226c502020-10-22 17:38:22 +02001215 pm_runtime_get_sync(dev);
1216
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001217 while (device_links_busy(dev)) {
Alexander Duycked887472019-01-22 10:39:16 -08001218 __device_driver_unlock(dev, parent);
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001219
1220 device_links_unbind_consumers(dev);
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001221
Alexander Duycked887472019-01-22 10:39:16 -08001222 __device_driver_lock(dev, parent);
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001223 /*
1224 * A concurrent invocation of the same function might
1225 * have released the driver successfully while this one
1226 * was waiting, so check for that.
1227 */
Rafael J. Wysocki9226c502020-10-22 17:38:22 +02001228 if (dev->driver != drv) {
1229 pm_runtime_put(dev);
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001230 return;
Rafael J. Wysocki9226c502020-10-22 17:38:22 +02001231 }
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001232 }
1233
Kay Sievers1901fb22006-10-07 21:55:55 +02001234 driver_sysfs_remove(dev);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -07001235
Greg Kroah-Hartmaned9f9182023-01-11 10:23:31 +01001236 bus_notify(dev, BUS_NOTIFY_UNBIND_DRIVER);
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +10001237
Rafael J. Wysockibaab52d2013-11-07 01:51:15 +01001238 pm_runtime_put_sync(dev);
Rafael J. Wysockie1866b32011-04-29 00:33:45 +02001239
Rob Herring4b775aa2022-02-23 16:52:57 -06001240 device_remove(dev);
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001241
Lu Baolu25f3bcf2022-04-18 08:49:51 +08001242 if (dev->bus && dev->bus->dma_cleanup)
1243 dev->bus->dma_cleanup(dev);
1244
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001245 device_links_driver_cleanup(dev);
Rob Herring9ad30722022-02-23 16:52:56 -06001246 device_unbind_cleanup(dev);
Rafael J. Wysockie90d5532015-03-20 13:59:27 +01001247
Greg Kroah-Hartman8940b4f2008-12-16 12:25:49 -08001248 klist_remove(&dev->p->knode_driver);
Tomeu Vizosoaa8e54b52016-01-07 16:46:14 +01001249 device_pm_check_callbacks(dev);
Dmitry Torokhov1455cf82017-07-19 17:24:30 -07001250
Greg Kroah-Hartmaned9f9182023-01-11 10:23:31 +01001251 bus_notify(dev, BUS_NOTIFY_UNBOUND_DRIVER);
Dmitry Torokhov1455cf82017-07-19 17:24:30 -07001252 kobject_uevent(&dev->kobj, KOBJ_UNBIND);
Patrick Mochel0d3e5a22005-04-05 23:46:33 -07001253 }
Alan Sternc95a6b02005-05-06 15:38:33 -04001254}
1255
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001256void device_release_driver_internal(struct device *dev,
1257 struct device_driver *drv,
1258 struct device *parent)
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001259{
Alexander Duycked887472019-01-22 10:39:16 -08001260 __device_driver_lock(dev, parent);
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001261
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001262 if (!drv || drv == dev->driver)
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001263 __device_release_driver(dev, parent);
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001264
Alexander Duycked887472019-01-22 10:39:16 -08001265 __device_driver_unlock(dev, parent);
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001266}
1267
Stefan Richterab71c6f2007-06-17 11:02:12 +02001268/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001269 * device_release_driver - manually detach device from driver.
1270 * @dev: device.
Stefan Richterab71c6f2007-06-17 11:02:12 +02001271 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001272 * Manually detach device from driver.
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -08001273 * When called for a USB interface, @dev->parent lock must be held.
Rafael J. Wysocki9ed98952016-10-30 17:32:16 +01001274 *
1275 * If this function is to be called with @dev->parent lock held, ensure that
1276 * the device's consumers are unbound in advance or that their locks can be
1277 * acquired under the @dev->parent lock.
Stefan Richterab71c6f2007-06-17 11:02:12 +02001278 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001279void device_release_driver(struct device *dev)
Alan Sternc95a6b02005-05-06 15:38:33 -04001280{
1281 /*
1282 * If anyone calls device_release_driver() recursively from
1283 * within their ->remove callback for the same device, they
1284 * will deadlock right here.
1285 */
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001286 device_release_driver_internal(dev, NULL, NULL);
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001287}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001288EXPORT_SYMBOL_GPL(device_release_driver);
mochel@digitalimplant.org94e7b1c52005-03-21 12:25:36 -08001289
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001290/**
Alexander Duycked887472019-01-22 10:39:16 -08001291 * device_driver_detach - detach driver from a specific device
1292 * @dev: device to detach driver from
1293 *
1294 * Detach driver from device. Will acquire both @dev lock and @dev->parent
1295 * lock if needed.
1296 */
1297void device_driver_detach(struct device *dev)
1298{
1299 device_release_driver_internal(dev, NULL, dev->parent);
1300}
1301
1302/**
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001303 * driver_detach - detach driver from all devices it controls.
1304 * @drv: driver.
1305 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001306void driver_detach(struct device_driver *drv)
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001307{
Greg Kroah-Hartman8940b4f2008-12-16 12:25:49 -08001308 struct device_private *dev_prv;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001309 struct device *dev;
Alan Sternc95a6b02005-05-06 15:38:33 -04001310
Alexander Duyckc37d7212018-11-28 16:32:11 -08001311 if (driver_allows_async_probing(drv))
1312 async_synchronize_full();
1313
Alan Sternc95a6b02005-05-06 15:38:33 -04001314 for (;;) {
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -08001315 spin_lock(&drv->p->klist_devices.k_lock);
1316 if (list_empty(&drv->p->klist_devices.k_list)) {
1317 spin_unlock(&drv->p->klist_devices.k_lock);
Alan Sternc95a6b02005-05-06 15:38:33 -04001318 break;
1319 }
Andy Shevchenkoa3a87d62020-03-24 14:20:23 +02001320 dev_prv = list_last_entry(&drv->p->klist_devices.k_list,
Greg Kroah-Hartman8940b4f2008-12-16 12:25:49 -08001321 struct device_private,
1322 knode_driver.n_node);
1323 dev = dev_prv->device;
Alan Sternc95a6b02005-05-06 15:38:33 -04001324 get_device(dev);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -08001325 spin_unlock(&drv->p->klist_devices.k_lock);
Rafael J. Wysocki4bdb3552016-10-10 14:37:56 +02001326 device_release_driver_internal(dev, drv, dev->parent);
Alan Sternc95a6b02005-05-06 15:38:33 -04001327 put_device(dev);
1328 }
mochel@digitalimplant.org07e4a3e2005-03-21 10:52:54 -08001329}