// SPDX-License-Identifier: GPL-2.0/* * drivers/base/dd.c - The core device/driver interactions. * * This file contains the (sometimes tricky) code that controls the * interactions between devices and drivers, which primarily includes * driver binding and unbinding. * * All of this code used to exist in drivers/base/bus.c, but was * relocated to here in the name of compartmentalization (since it wasn't * strictly code just for the 'struct bus_type'. * * Copyright (c) 2002-5 Patrick Mochel * Copyright (c) 2002-3 Open Source Development Labs * Copyright (c) 2007-2009 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (c) 2007-2009 Novell Inc. */ #include <linux/debugfs.h>#include <linux/device.h>#include <linux/delay.h>#include <linux/dma-map-ops.h>#include <linux/init.h>#include <linux/module.h>#include <linux/kthread.h>#include <linux/wait.h>#include <linux/async.h>#include <linux/pm_runtime.h>#include <linux/pinctrl/devinfo.h>#include <linux/slab.h> #include "base.h"#include "power/power.h" /* * Deferred Probe infrastructure. * * Sometimes driver probe order matters, but the kernel doesn't always have * dependency information which means some drivers will get probed before a * resource it depends on is available.  For example, an SDHCI driver may * first need a GPIO line from an i2c GPIO controller before it can be * initialized.  If a required resource is not available yet, a driver can * request probing to be deferred by returning -EPROBE_DEFER from its probe hook * * Deferred probe maintains two lists of devices, a pending list and an active * list.  A driver returning -EPROBE_DEFER causes the device to be added to the * pending list.  A successful driver probe will trigger moving all devices * from the pending to the active list so that the workqueue will eventually * retry them. * * The deferred_probe_mutex must be held any time the deferred_probe_*_list * of the (struct device*)->p->deferred_probe pointers are manipulated */static DEFINE_MUTEX(deferred_probe_mutex);static LIST_HEAD(deferred_probe_pending_list);static LIST_HEAD(deferred_probe_active_list);static atomic_t deferred_trigger_count = ATOMIC_INIT(0);static bool initcalls_done; /* Save the async probe drivers' name from kernel cmdline */#define ASYNC_DRV_NAMES_MAX_LEN	256static char async_probe_drv_names[ASYNC_DRV_NAMES_MAX_LEN];static bool async_probe_default; /* * In some cases, like suspend to RAM or hibernation, It might be reasonable * to prohibit probing of devices as it could be unsafe. * Once defer_all_probes is true all drivers probes will be forcibly deferred. */static bool defer_all_probes; static void __device_set_deferred_probe_reason(const struct device *dev, char *reason){	kfree(dev->p->deferred_probe_reason);	dev->p->deferred_probe_reason = reason;} /* * deferred_probe_work_func() - Retry probing devices in the active list. */static void deferred_probe_work_func(struct work_struct *work){	struct device *dev;	struct device_private *private;	/*	 * This block processes every device in the deferred 'active' list.	 * Each device is removed from the active list and passed to	 * bus_probe_device() to re-attempt the probe.  The loop continues	 * until every device in the active list is removed and retried.	 *	 * Note: Once the device is removed from the list and the mutex is	 * released, it is possible for the device get freed by another thread	 * and cause a illegal pointer dereference.  This code uses	 * get/put_device() to ensure the device structure cannot disappear	 * from under our feet.	 */	mutex_lock(&deferred_probe_mutex);	while (!list_empty(&deferred_probe_active_list)) {		private = list_first_entry(&deferred_probe_active_list,					typeof(*dev->p), deferred_probe);		dev = private->device;		list_del_init(&private->deferred_probe); 		get_device(dev); 		__device_set_deferred_probe_reason(dev, NULL); 		/*		 * Drop the mutex while probing each device; the probe path may		 * manipulate the deferred list		 */		mutex_unlock(&deferred_probe_mutex); 		/*		 * Force the device to the end of the dpm_list since		 * the PM code assumes that the order we add things to		 * the list is a good order for suspend but deferred		 * probe makes that very unsafe.		 */		device_pm_move_to_tail(dev); 		dev_dbg(dev, "Retrying from deferred list\n");		bus_probe_device(dev);		mutex_lock(&deferred_probe_mutex); 		put_device(dev);	}	mutex_unlock(&deferred_probe_mutex);}static DECLARE_WORK(deferred_probe_work, deferred_probe_work_func); void driver_deferred_probe_add(struct device *dev){	if (!dev->can_match)		return; 	mutex_lock(&deferred_probe_mutex);	if (list_empty(&dev->p->deferred_probe)) {		dev_dbg(dev, "Added to deferred list\n");		list_add_tail(&dev->p->deferred_probe, &deferred_probe_pending_list);	}	mutex_unlock(&deferred_probe_mutex);} void driver_deferred_probe_del(struct device *dev){	mutex_lock(&deferred_probe_mutex);	if (!list_empty(&dev->p->deferred_probe)) {		dev_dbg(dev, "Removed from deferred list\n");		list_del_init(&dev->p->deferred_probe);		__device_set_deferred_probe_reason(dev, NULL);	}	mutex_unlock(&deferred_probe_mutex);} static bool driver_deferred_probe_enable;/** * driver_deferred_probe_trigger() - Kick off re-probing deferred devices * * This functions moves all devices from the pending list to the active * list and schedules the deferred probe workqueue to process them.  It * should be called anytime a driver is successfully bound to a device. * * Note, there is a race condition in multi-threaded probe. In the case where * more than one device is probing at the same time, it is possible for one * probe to complete successfully while another is about to defer. If the second * depends on the first, then it will get put on the pending list after the * trigger event has already occurred and will be stuck there. * * The atomic 'deferred_trigger_count' is used to determine if a successful * trigger has occurred in the midst of probing a driver. If the trigger count * changes in the midst of a probe, then deferred processing should be triggered * again. */void driver_deferred_probe_trigger(void){	if (!driver_deferred_probe_enable)		return; 	/*	 * A successful probe means that all the devices in the pending list	 * should be triggered to be reprobed.  Move all the deferred devices	 * into the active list so they can be retried by the workqueue	 */	mutex_lock(&deferred_probe_mutex);	atomic_inc(&deferred_trigger_count);	list_splice_tail_init(&deferred_probe_pending_list,			      &deferred_probe_active_list);	mutex_unlock(&deferred_probe_mutex); 	/*	 * Kick the re-probe thread.  It may already be scheduled, but it is	 * safe to kick it again.	 */	queue_work(system_unbound_wq, &deferred_probe_work);} /** * device_block_probing() - Block/defer device's probes * *	It will disable probing of devices and defer their probes instead. */void device_block_probing(void){	defer_all_probes = true;	/* sync with probes to avoid races. */	wait_for_device_probe();} /** * device_unblock_probing() - Unblock/enable device's probes * *	It will restore normal behavior and trigger re-probing of deferred * devices. */void device_unblock_probing(void){	defer_all_probes = false;	driver_deferred_probe_trigger();} /** * device_set_deferred_probe_reason() - Set defer probe reason message for device * @dev: the pointer to the struct device * @vaf: the pointer to va_format structure with message */void device_set_deferred_probe_reason(const struct device *dev, struct va_format *vaf){	const char *drv = dev_driver_string(dev);	char *reason; 	mutex_lock(&deferred_probe_mutex); 	reason = kasprintf(GFP_KERNEL, "%s: %pV", drv, vaf);	__device_set_deferred_probe_reason(dev, reason); 	mutex_unlock(&deferred_probe_mutex);} /* * deferred_devs_show() - Show the devices in the deferred probe pending list. */static int deferred_devs_show(struct seq_file *s, void *data){	struct device_private *curr; 	mutex_lock(&deferred_probe_mutex); 	list_for_each_entry(curr, &deferred_probe_pending_list, deferred_probe)		seq_printf(s, "%s\t%s", dev_name(curr->device),			   curr->deferred_probe_reason ?: "\n"); 	mutex_unlock(&deferred_probe_mutex); 	return 0;}DEFINE_SHOW_ATTRIBUTE(deferred_devs); #ifdef CONFIG_MODULESstatic int driver_deferred_probe_timeout = 10;#elsestatic int driver_deferred_probe_timeout;#endif static int __init deferred_probe_timeout_setup(char *str){	int timeout; 	if (!kstrtoint(str, 10, &timeout))		driver_deferred_probe_timeout = timeout;	return 1;}__setup("deferred_probe_timeout=", deferred_probe_timeout_setup); /** * driver_deferred_probe_check_state() - Check deferred probe state * @dev: device to check * * Return: * * -ENODEV if initcalls have completed and modules are disabled. * * -ETIMEDOUT if the deferred probe timeout was set and has expired *   and modules are enabled. * * -EPROBE_DEFER in other cases. * * Drivers or subsystems can opt-in to calling this function instead of directly * returning -EPROBE_DEFER. */int driver_deferred_probe_check_state(struct device *dev){	if (!IS_ENABLED(CONFIG_MODULES) && initcalls_done) {		dev_warn(dev, "ignoring dependency for device, assuming no driver\n");		return -ENODEV;	} 	if (!driver_deferred_probe_timeout && initcalls_done) {		dev_warn(dev, "deferred probe timeout, ignoring dependency\n");		return -ETIMEDOUT;	} 	return -EPROBE_DEFER;}EXPORT_SYMBOL_GPL(driver_deferred_probe_check_state); static void deferred_probe_timeout_work_func(struct work_struct *work){	struct device_private *p; 	fw_devlink_drivers_done(); 	driver_deferred_probe_timeout = 0;	driver_deferred_probe_trigger();	flush_work(&deferred_probe_work); 	mutex_lock(&deferred_probe_mutex);	list_for_each_entry(p, &deferred_probe_pending_list, deferred_probe)		dev_warn(p->device, "deferred probe pending: %s", p->deferred_probe_reason ?: "(reason unknown)\n");	mutex_unlock(&deferred_probe_mutex); 	fw_devlink_probing_done();}static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func); void deferred_probe_extend_timeout(void){	/*	 * If the work hasn't been queued yet or if the work expired, don't	 * start a new one.	 */	if (cancel_delayed_work(&deferred_probe_timeout_work)) {		schedule_delayed_work(&deferred_probe_timeout_work,				driver_deferred_probe_timeout * HZ);		pr_debug("Extended deferred probe timeout by %d secs\n",					driver_deferred_probe_timeout);	}} /** * deferred_probe_initcall() - Enable probing of deferred devices * * We don't want to get in the way when the bulk of drivers are getting probed. * Instead, this initcall makes sure that deferred probing is delayed until * late_initcall time. */static int deferred_probe_initcall(void){	debugfs_create_file("devices_deferred", 0444, NULL, NULL,			    &deferred_devs_fops); 	driver_deferred_probe_enable = true;	driver_deferred_probe_trigger();	/* Sort as many dependencies as possible before exiting initcalls */	flush_work(&deferred_probe_work);	initcalls_done = true; 	if (!IS_ENABLED(CONFIG_MODULES))		fw_devlink_drivers_done(); 	/*	 * Trigger deferred probe again, this time we won't defer anything	 * that is optional	 */	driver_deferred_probe_trigger();	flush_work(&deferred_probe_work); 	if (driver_deferred_probe_timeout > 0) {		schedule_delayed_work(&deferred_probe_timeout_work,			driver_deferred_probe_timeout * HZ);	} 	if (!IS_ENABLED(CONFIG_MODULES))		fw_devlink_probing_done(); 	return 0;}late_initcall(deferred_probe_initcall); static void __exit deferred_probe_exit(void){	debugfs_lookup_and_remove("devices_deferred", NULL);}__exitcall(deferred_probe_exit); /** * device_is_bound() - Check if device is bound to a driver * @dev: device to check * * Returns true if passed device has already finished probing successfully * against a driver. * * This function must be called with the device lock held. */bool device_is_bound(struct device *dev){	return dev->p && klist_node_attached(&dev->p->knode_driver);}EXPORT_SYMBOL_GPL(device_is_bound); static void driver_bound(struct device *dev){	if (device_is_bound(dev)) {		dev_warn(dev, "%s: device already bound\n", __func__);		return;	} 	dev_dbg(dev, "driver: '%s': %s: bound to device\n", dev->driver->name,		__func__); 	klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);	device_links_driver_bound(dev); 	device_pm_check_callbacks(dev); 	/*	 * Make sure the device is no longer in one of the deferred lists and	 * kick off retrying all pending devices	 */	driver_deferred_probe_del(dev);	driver_deferred_probe_trigger(); 	bus_notify(dev, BUS_NOTIFY_BOUND_DRIVER);	kobject_uevent(&dev->kobj, KOBJ_BIND);} static ssize_t coredump_store(struct device *dev, struct device_attribute *attr,			    const char *buf, size_t count){	device_lock(dev);	dev->driver->coredump(dev);	device_unlock(dev); 	return count;}static DEVICE_ATTR_WO(coredump); static int driver_sysfs_add(struct device *dev){	int ret; 	bus_notify(dev, BUS_NOTIFY_BIND_DRIVER); 	ret = sysfs_create_link(&dev->driver->p->kobj, &dev->kobj,				kobject_name(&dev->kobj));	if (ret)		goto fail; 	ret = sysfs_create_link(&dev->kobj, &dev->driver->p->kobj,				"driver");	if (ret)		goto rm_dev; 	if (!IS_ENABLED(CONFIG_DEV_COREDUMP) || !dev->driver->coredump)		return 0; 	ret = device_create_file(dev, &dev_attr_coredump);	if (!ret)		return 0; 	sysfs_remove_link(&dev->kobj, "driver"); rm_dev:	sysfs_remove_link(&dev->driver->p->kobj,			  kobject_name(&dev->kobj)); fail:	return ret;} static void driver_sysfs_remove(struct device *dev){	struct device_driver *drv = dev->driver; 	if (drv) {		if (drv->coredump)			device_remove_file(dev, &dev_attr_coredump);		sysfs_remove_link(&drv->p->kobj, kobject_name(&dev->kobj));		sysfs_remove_link(&dev->kobj, "driver");	}} /** * device_bind_driver - bind a driver to one device. * @dev: device. * * Allow manual attachment of a driver to a device. * Caller must have already set @dev->driver. * * Note that this does not modify the bus reference count. * Please verify that is accounted for before calling this. * (It is ok to call with no other effort from a driver's probe() method.) * * This function must be called with the device lock held. * * Callers should prefer to use device_driver_attach() instead. */int device_bind_driver(struct device *dev){	int ret; 	ret = driver_sysfs_add(dev);	if (!ret) {

Lines 1–500 of 1362. Load more