// 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/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. */ #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){	return srcu_read_lock(&device_links_srcu);} void device_links_read_unlock(int idx){	srcu_read_unlock(&device_links_srcu, idx);}#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);}#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->consumer == target)			return 1; 		ret = device_is_dependent(link->consumer, target);		if (ret)			break;	}	return ret;} 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)		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);} /** * 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 link is not going to be managed by * the driver core and, in particular, the caller of this function is expected * to drop the reference to the link acquired by it directly. * * 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 either DL_FLAG_AUTOREMOVE_CONSUMER * or DL_FLAG_AUTOREMOVE_SUPPLIER set in @flags at the same time is invalid and * will cause NULL to be returned upfront. * * 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_FLAG_STATELESS &&	     flags & (DL_FLAG_AUTOREMOVE_CONSUMER |		      DL_FLAG_AUTOREMOVE_SUPPLIER |		      DL_FLAG_AUTOPROBE_CONSUMER)) ||	    (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;		}	} 	device_links_write_lock();	device_pm_lock(); 	/*	 * If the supplier has not been fully registered yet or there is a	 * reverse dependency between the consumer and the supplier already in	 * the graph, return NULL.	 */	if (!device_pm_initialized(supplier)	    || 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; 		/*		 * Don't return a stateless link if the caller wants a stateful		 * one and vice versa.		 */		if (WARN_ON((flags & DL_FLAG_STATELESS) != (link->flags & DL_FLAG_STATELESS))) {			link = NULL;			goto out;		} 		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);			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);		}		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 {		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;		}	} 	/*	 * 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); 	/*	 * 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); 	list_add_tail_rcu(&link->s_node, &supplier->links.consumers);	list_add_tail_rcu(&link->c_node, &consumer->links.suppliers); 	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); static void device_link_free(struct device_link *link){	while (refcount_dec_not_one(&link->rpm_active))		pm_runtime_put(link->supplier); 	put_device(link->consumer);	put_device(link->supplier);	kfree(link);} #ifdef CONFIG_SRCUstatic void __device_link_free_srcu(struct rcu_head *rhead){	device_link_free(container_of(rhead, struct device_link, rcu_head));} static void __device_link_del(struct kref *kref){	struct device_link *link = container_of(kref, struct device_link, kref); 	dev_dbg(link->consumer, "Dropping the link to %s\n",		dev_name(link->supplier)); 	if (link->flags & DL_FLAG_PM_RUNTIME)		pm_runtime_drop_link(link->consumer); 	list_del_rcu(&link->s_node);	list_del_rcu(&link->c_node);	call_srcu(&device_links_srcu, &link->rcu_head, __device_link_free_srcu);}#else /* !CONFIG_SRCU */static void __device_link_del(struct kref *kref){	struct device_link *link = container_of(kref, struct device_link, kref); 	dev_info(link->consumer, "Dropping the link to %s\n",		 dev_name(link->supplier)); 	if (link->flags & DL_FLAG_PM_RUNTIME)		pm_runtime_drop_link(link->consumer); 	list_del(&link->s_node);	list_del(&link->c_node);	device_link_free(link);}#endif /* !CONFIG_SRCU */ static void device_link_put_kref(struct device_link *link){	if (link->flags & DL_FLAG_STATELESS)		kref_put(&link->kref, __device_link_del);	else		WARN(1, "Unable to drop a managed device link reference\n");} /** * device_link_del - Delete a stateless link between two devices. * @link: Device link to delete. * * The caller must ensure proper synchronization of this function with runtime * PM.  If the link was added multiple times, it needs to be deleted as often. * Care is required for hotplugged devices:  Their links are purged on removal * and calling device_link_del() is then no longer allowed. */void device_link_del(struct device_link *link){	device_links_write_lock();	device_pm_lock();	device_link_put_kref(link);	device_pm_unlock();	device_links_write_unlock();}EXPORT_SYMBOL_GPL(device_link_del); /** * device_link_remove - Delete a stateless link between two devices. * @consumer: Consumer end of the link. * @supplier: Supplier end of the link. * * The caller must ensure proper synchronization of this function with runtime * PM. */void device_link_remove(void *consumer, struct device *supplier){	struct device_link *link; 	if (WARN_ON(consumer == supplier))		return; 	device_links_write_lock();	device_pm_lock(); 	list_for_each_entry(link, &supplier->links.consumers, s_node) {		if (link->consumer == consumer) {			device_link_put_kref(link);			break;		}

Lines 1–500 of 3429. Load more