// SPDX-License-Identifier: GPL-2.0/* * drivers/base/core.c - core driver model code (device registration, etc) * * Copyright (c) 2002-3 Patrick Mochel * Copyright (c) 2002-3 Open Source Development Labs * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (c) 2006 Novell, Inc. */ #include <linux/acpi.h>#include <linux/cpufreq.h>#include <linux/device.h>#include <linux/err.h>#include <linux/fwnode.h>#include <linux/init.h>#include <linux/module.h>#include <linux/slab.h>#include <linux/string.h>#include <linux/kdev_t.h>#include <linux/notifier.h>#include <linux/of.h>#include <linux/of_device.h>#include <linux/genhd.h>#include <linux/mutex.h>#include <linux/pm_runtime.h>#include <linux/netdevice.h>#include <linux/sched/signal.h>#include <linux/sysfs.h> #include "base.h"#include "power/power.h" #ifdef CONFIG_SYSFS_DEPRECATED#ifdef CONFIG_SYSFS_DEPRECATED_V2long sysfs_deprecated = 1;#elselong sysfs_deprecated = 0;#endifstatic int __init sysfs_deprecated_setup(char *arg){	return kstrtol(arg, 10, &sysfs_deprecated);}early_param("sysfs.deprecated", sysfs_deprecated_setup);#endif /* Device links support. */static LIST_HEAD(wait_for_suppliers);static DEFINE_MUTEX(wfs_lock);static LIST_HEAD(deferred_sync);static unsigned int defer_sync_state_count = 1; #ifdef CONFIG_SRCUstatic DEFINE_MUTEX(device_links_lock);DEFINE_STATIC_SRCU(device_links_srcu); static inline void device_links_write_lock(void){	mutex_lock(&device_links_lock);} static inline void device_links_write_unlock(void){	mutex_unlock(&device_links_lock);} int device_links_read_lock(void) __acquires(&device_links_srcu){	return srcu_read_lock(&device_links_srcu);} void device_links_read_unlock(int idx) __releases(&device_links_srcu){	srcu_read_unlock(&device_links_srcu, idx);} int device_links_read_lock_held(void){	return srcu_read_lock_held(&device_links_srcu);}#else /* !CONFIG_SRCU */static DECLARE_RWSEM(device_links_lock); static inline void device_links_write_lock(void){	down_write(&device_links_lock);} static inline void device_links_write_unlock(void){	up_write(&device_links_lock);} int device_links_read_lock(void){	down_read(&device_links_lock);	return 0;} void device_links_read_unlock(int not_used){	up_read(&device_links_lock);} #ifdef CONFIG_DEBUG_LOCK_ALLOCint device_links_read_lock_held(void){	return lockdep_is_held(&device_links_lock);}#endif#endif /* !CONFIG_SRCU */ /** * device_is_dependent - Check if one device depends on another one * @dev: Device to check dependencies for. * @target: Device to check against. * * Check if @target depends on @dev or any device dependent on it (its child or * its consumer etc).  Return 1 if that is the case or 0 otherwise. */static int device_is_dependent(struct device *dev, void *target){	struct device_link *link;	int ret; 	if (dev == target)		return 1; 	ret = device_for_each_child(dev, target, device_is_dependent);	if (ret)		return ret; 	list_for_each_entry(link, &dev->links.consumers, s_node) {		if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED))			continue; 		if (link->consumer == target)			return 1; 		ret = device_is_dependent(link->consumer, target);		if (ret)			break;	}	return ret;} static void device_link_init_status(struct device_link *link,				    struct device *consumer,				    struct device *supplier){	switch (supplier->links.status) {	case DL_DEV_PROBING:		switch (consumer->links.status) {		case DL_DEV_PROBING:			/*			 * A consumer driver can create a link to a supplier			 * that has not completed its probing yet as long as it			 * knows that the supplier is already functional (for			 * example, it has just acquired some resources from the			 * supplier).			 */			link->status = DL_STATE_CONSUMER_PROBE;			break;		default:			link->status = DL_STATE_DORMANT;			break;		}		break;	case DL_DEV_DRIVER_BOUND:		switch (consumer->links.status) {		case DL_DEV_PROBING:			link->status = DL_STATE_CONSUMER_PROBE;			break;		case DL_DEV_DRIVER_BOUND:			link->status = DL_STATE_ACTIVE;			break;		default:			link->status = DL_STATE_AVAILABLE;			break;		}		break;	case DL_DEV_UNBINDING:		link->status = DL_STATE_SUPPLIER_UNBIND;		break;	default:		link->status = DL_STATE_DORMANT;		break;	}} static int device_reorder_to_tail(struct device *dev, void *not_used){	struct device_link *link; 	/*	 * Devices that have not been registered yet will be put to the ends	 * of the lists during the registration, so skip them here.	 */	if (device_is_registered(dev))		devices_kset_move_last(dev); 	if (device_pm_initialized(dev))		device_pm_move_last(dev); 	device_for_each_child(dev, NULL, device_reorder_to_tail);	list_for_each_entry(link, &dev->links.consumers, s_node) {		if (link->flags == (DL_FLAG_SYNC_STATE_ONLY | DL_FLAG_MANAGED))			continue;		device_reorder_to_tail(link->consumer, NULL);	} 	return 0;} /** * device_pm_move_to_tail - Move set of devices to the end of device lists * @dev: Device to move * * This is a device_reorder_to_tail() wrapper taking the requisite locks. * * It moves the @dev along with all of its children and all of its consumers * to the ends of the device_kset and dpm_list, recursively. */void device_pm_move_to_tail(struct device *dev){	int idx; 	idx = device_links_read_lock();	device_pm_lock();	device_reorder_to_tail(dev, NULL);	device_pm_unlock();	device_links_read_unlock(idx);} #define DL_MANAGED_LINK_FLAGS (DL_FLAG_AUTOREMOVE_CONSUMER | \			       DL_FLAG_AUTOREMOVE_SUPPLIER | \			       DL_FLAG_AUTOPROBE_CONSUMER  | \			       DL_FLAG_SYNC_STATE_ONLY) #define DL_ADD_VALID_FLAGS (DL_MANAGED_LINK_FLAGS | DL_FLAG_STATELESS | \			    DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE) /** * device_link_add - Create a link between two devices. * @consumer: Consumer end of the link. * @supplier: Supplier end of the link. * @flags: Link flags. * * The caller is responsible for the proper synchronization of the link creation * with runtime PM.  First, setting the DL_FLAG_PM_RUNTIME flag will cause the * runtime PM framework to take the link into account.  Second, if the * DL_FLAG_RPM_ACTIVE flag is set in addition to it, the supplier devices will * be forced into the active metastate and reference-counted upon the creation * of the link.  If DL_FLAG_PM_RUNTIME is not set, DL_FLAG_RPM_ACTIVE will be * ignored. * * If DL_FLAG_STATELESS is set in @flags, the caller of this function is * expected to release the link returned by it directly with the help of either * device_link_del() or device_link_remove(). * * If that flag is not set, however, the caller of this function is handing the * management of the link over to the driver core entirely and its return value * can only be used to check whether or not the link is present.  In that case, * the DL_FLAG_AUTOREMOVE_CONSUMER and DL_FLAG_AUTOREMOVE_SUPPLIER device link * flags can be used to indicate to the driver core when the link can be safely * deleted.  Namely, setting one of them in @flags indicates to the driver core * that the link is not going to be used (by the given caller of this function) * after unbinding the consumer or supplier driver, respectively, from its * device, so the link can be deleted at that point.  If none of them is set, * the link will be maintained until one of the devices pointed to by it (either * the consumer or the supplier) is unregistered. * * Also, if DL_FLAG_STATELESS, DL_FLAG_AUTOREMOVE_CONSUMER and * DL_FLAG_AUTOREMOVE_SUPPLIER are not set in @flags (that is, a persistent * managed device link is being added), the DL_FLAG_AUTOPROBE_CONSUMER flag can * be used to request the driver core to automaticall probe for a consmer * driver after successfully binding a driver to the supplier device. * * The combination of DL_FLAG_STATELESS and one of DL_FLAG_AUTOREMOVE_CONSUMER, * DL_FLAG_AUTOREMOVE_SUPPLIER, or DL_FLAG_AUTOPROBE_CONSUMER set in @flags at * the same time is invalid and will cause NULL to be returned upfront. * However, if a device link between the given @consumer and @supplier pair * exists already when this function is called for them, the existing link will * be returned regardless of its current type and status (the link's flags may * be modified then).  The caller of this function is then expected to treat * the link as though it has just been created, so (in particular) if * DL_FLAG_STATELESS was passed in @flags, the link needs to be released * explicitly when not needed any more (as stated above). * * A side effect of the link creation is re-ordering of dpm_list and the * devices_kset list by moving the consumer device and all devices depending * on it to the ends of these lists (that does not happen to devices that have * not been registered when this function is called). * * The supplier device is required to be registered when this function is called * and NULL will be returned if that is not the case.  The consumer device need * not be registered, however. */struct device_link *device_link_add(struct device *consumer,				    struct device *supplier, u32 flags){	struct device_link *link; 	if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS ||	    (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) ||	    (flags & DL_FLAG_SYNC_STATE_ONLY &&	     flags != DL_FLAG_SYNC_STATE_ONLY) ||	    (flags & DL_FLAG_AUTOPROBE_CONSUMER &&	     flags & (DL_FLAG_AUTOREMOVE_CONSUMER |		      DL_FLAG_AUTOREMOVE_SUPPLIER)))		return NULL; 	if (flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) {		if (pm_runtime_get_sync(supplier) < 0) {			pm_runtime_put_noidle(supplier);			return NULL;		}	} 	if (!(flags & DL_FLAG_STATELESS))		flags |= DL_FLAG_MANAGED; 	device_links_write_lock();	device_pm_lock(); 	/*	 * If the supplier has not been fully registered yet or there is a	 * reverse (non-SYNC_STATE_ONLY) dependency between the consumer and	 * the supplier already in the graph, return NULL. If the link is a	 * SYNC_STATE_ONLY link, we don't check for reverse dependencies	 * because it only affects sync_state() callbacks.	 */	if (!device_pm_initialized(supplier)	    || (!(flags & DL_FLAG_SYNC_STATE_ONLY) &&		  device_is_dependent(consumer, supplier))) {		link = NULL;		goto out;	} 	/*	 * DL_FLAG_AUTOREMOVE_SUPPLIER indicates that the link will be needed	 * longer than for DL_FLAG_AUTOREMOVE_CONSUMER and setting them both	 * together doesn't make sense, so prefer DL_FLAG_AUTOREMOVE_SUPPLIER.	 */	if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER)		flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER; 	list_for_each_entry(link, &supplier->links.consumers, s_node) {		if (link->consumer != consumer)			continue; 		if (flags & DL_FLAG_PM_RUNTIME) {			if (!(link->flags & DL_FLAG_PM_RUNTIME)) {				pm_runtime_new_link(consumer);				link->flags |= DL_FLAG_PM_RUNTIME;			}			if (flags & DL_FLAG_RPM_ACTIVE)				refcount_inc(&link->rpm_active);		} 		if (flags & DL_FLAG_STATELESS) {			kref_get(&link->kref);			if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&			    !(link->flags & DL_FLAG_STATELESS)) {				link->flags |= DL_FLAG_STATELESS;				goto reorder;			} else {				link->flags |= DL_FLAG_STATELESS;				goto out;			}		} 		/*		 * If the life time of the link following from the new flags is		 * longer than indicated by the flags of the existing link,		 * update the existing link to stay around longer.		 */		if (flags & DL_FLAG_AUTOREMOVE_SUPPLIER) {			if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {				link->flags &= ~DL_FLAG_AUTOREMOVE_CONSUMER;				link->flags |= DL_FLAG_AUTOREMOVE_SUPPLIER;			}		} else if (!(flags & DL_FLAG_AUTOREMOVE_CONSUMER)) {			link->flags &= ~(DL_FLAG_AUTOREMOVE_CONSUMER |					 DL_FLAG_AUTOREMOVE_SUPPLIER);		}		if (!(link->flags & DL_FLAG_MANAGED)) {			kref_get(&link->kref);			link->flags |= DL_FLAG_MANAGED;			device_link_init_status(link, consumer, supplier);		}		if (link->flags & DL_FLAG_SYNC_STATE_ONLY &&		    !(flags & DL_FLAG_SYNC_STATE_ONLY)) {			link->flags &= ~DL_FLAG_SYNC_STATE_ONLY;			goto reorder;		} 		goto out;	} 	link = kzalloc(sizeof(*link), GFP_KERNEL);	if (!link)		goto out; 	refcount_set(&link->rpm_active, 1); 	if (flags & DL_FLAG_PM_RUNTIME) {		if (flags & DL_FLAG_RPM_ACTIVE)			refcount_inc(&link->rpm_active); 		pm_runtime_new_link(consumer);	} 	get_device(supplier);	link->supplier = supplier;	INIT_LIST_HEAD(&link->s_node);	get_device(consumer);	link->consumer = consumer;	INIT_LIST_HEAD(&link->c_node);	link->flags = flags;	kref_init(&link->kref); 	/* Determine the initial link state. */	if (flags & DL_FLAG_STATELESS)		link->status = DL_STATE_NONE;	else		device_link_init_status(link, consumer, supplier); 	/*	 * Some callers expect the link creation during consumer driver probe to	 * resume the supplier even without DL_FLAG_RPM_ACTIVE.	 */	if (link->status == DL_STATE_CONSUMER_PROBE &&	    flags & DL_FLAG_PM_RUNTIME)		pm_runtime_resume(supplier); 	list_add_tail_rcu(&link->s_node, &supplier->links.consumers);	list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 	if (flags & DL_FLAG_SYNC_STATE_ONLY) {		dev_dbg(consumer,			"Linked as a sync state only consumer to %s\n",			dev_name(supplier));		goto out;	} reorder:	/*	 * Move the consumer and all of the devices depending on it to the end	 * of dpm_list and the devices_kset list.	 *	 * It is necessary to hold dpm_list locked throughout all that or else	 * we may end up suspending with a wrong ordering of it.	 */	device_reorder_to_tail(consumer, NULL); 	dev_dbg(consumer, "Linked as a consumer to %s\n", dev_name(supplier)); out:	device_pm_unlock();	device_links_write_unlock(); 	if ((flags & DL_FLAG_PM_RUNTIME && flags & DL_FLAG_RPM_ACTIVE) && !link)		pm_runtime_put(supplier); 	return link;}EXPORT_SYMBOL_GPL(device_link_add); /** * device_link_wait_for_supplier - Add device to wait_for_suppliers list * @consumer: Consumer device * * Marks the @consumer device as waiting for suppliers to become available by * adding it to the wait_for_suppliers list. The consumer device will never be * probed until it's removed from the wait_for_suppliers list. * * The caller is responsible for adding the links to the supplier devices once * they are available and removing the @consumer device from the * wait_for_suppliers list once links to all the suppliers have been created. * * This function is NOT meant to be called from the probe function of the * consumer but rather from code that creates/adds the consumer device. */static void device_link_wait_for_supplier(struct device *consumer,					  bool need_for_probe){	mutex_lock(&wfs_lock);	list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers);	consumer->links.need_for_probe = need_for_probe;	mutex_unlock(&wfs_lock);} static void device_link_wait_for_mandatory_supplier(struct device *consumer){	device_link_wait_for_supplier(consumer, true);} static void device_link_wait_for_optional_supplier(struct device *consumer){

Lines 1–500 of 3969. Load more