Merge tag 'driver-core-5.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core (f558b836) · Commits · 戴 / test

Documentation/driver-api/driver-model/driver.rst

+27 −5

Original line number	Diff line number	Diff line
		@@ -4,7 +4,6 @@ Device Drivers

		See the kerneldoc for the struct device_driver.


		Allocation
		~~~~~~~~~~

		@@ -167,7 +166,24 @@ the driver to that device.

		A driver's probe() may return a negative errno value to indicate that
		the driver did not bind to this device, in which case it should have
		released all resources it allocated::
		released all resources it allocated.

		Optionally, probe() may return -EPROBE_DEFER if the driver depends on
		resources that are not yet available (e.g., supplied by a driver that
		hasn't initialized yet). The driver core will put the device onto the
		deferred probe list and will try to call it again later. If a driver
		must defer, it should return -EPROBE_DEFER as early as possible to
		reduce the amount of time spent on setup work that will need to be
		unwound and reexecuted at a later time.

		.. warning::
		-EPROBE_DEFER must not be returned if probe() has already created
		child devices, even if those child devices are removed again
		in a cleanup path. If -EPROBE_DEFER is returned after a child
		device has been registered, it may result in an infinite loop of
		.probe() calls to the same driver.

		::

		void (sync_state) (struct device dev);

		@@ -212,6 +228,8 @@ over management of devices from the bootloader, the usage of sync_state() is
		not restricted to that. Use it whenever it makes sense to take an action after
		all the consumers of a device have probed::

		::

		int (remove) (struct device dev);

		remove is called to unbind a driver from a device. This may be
		@@ -224,11 +242,15 @@ not. It should free any resources allocated specifically for the
		device; i.e. anything in the device's driver_data field.

		If the device is still present, it should quiesce the device and place
		it into a supported low-power state::
		it into a supported low-power state.

		::

		int (suspend) (struct device dev, pm_message_t state);

		suspend is called to put the device in a low power state::
		suspend is called to put the device in a low power state.

		::

		int (resume) (struct device dev);

drivers/base/base.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -153,6 +153,7 @@ extern char make_class_name(const char name, struct kobject *kobj);
		extern int devres_release_all(struct device *dev);
		extern void device_block_probing(void);
		extern void device_unblock_probing(void);
		extern void driver_deferred_probe_force_trigger(void);

		/* /sys/devices directory */
		extern struct kset *devices_kset;

drivers/base/core.c

+179 −56

Original line number	Diff line number	Diff line
		@@ -49,6 +49,9 @@ static LIST_HEAD(wait_for_suppliers);
		static DEFINE_MUTEX(wfs_lock);
		static LIST_HEAD(deferred_sync);
		static unsigned int defer_sync_state_count = 1;
		static unsigned int defer_fw_devlink_count;
		static DEFINE_MUTEX(defer_fw_devlink_lock);
		static bool fw_devlink_is_permissive(void);

		#ifdef CONFIG_SRCU
		static DEFINE_MUTEX(device_links_lock);
		@@ -529,7 +532,7 @@ static void device_link_add_missing_supplier_links(void)
		int ret = fwnode_call_int_op(dev->fwnode, add_links, dev);
		if (!ret)
		list_del_init(&dev->links.needs_suppliers);
		else if (ret != -ENODEV)
		else if (ret != -ENODEV \|\| fw_devlink_is_permissive())
		dev->links.need_for_probe = false;
		}
		mutex_unlock(&wfs_lock);
		@@ -643,9 +646,17 @@ static void device_links_missing_supplier(struct device *dev)
		{
		struct device_link *link;

		list_for_each_entry(link, &dev->links.suppliers, c_node)
		if (link->status == DL_STATE_CONSUMER_PROBE)
		list_for_each_entry(link, &dev->links.suppliers, c_node) {
		if (link->status != DL_STATE_CONSUMER_PROBE)
		continue;

		if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) {
		WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
		} else {
		WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
		WRITE_ONCE(link->status, DL_STATE_DORMANT);
		}
		}
		}

		/**
		@@ -684,11 +695,11 @@ int device_links_check_suppliers(struct device *dev)
		device_links_write_lock();

		list_for_each_entry(link, &dev->links.suppliers, c_node) {
		if (!(link->flags & DL_FLAG_MANAGED) \|\|
		link->flags & DL_FLAG_SYNC_STATE_ONLY)
		if (!(link->flags & DL_FLAG_MANAGED))
		continue;

		if (link->status != DL_STATE_AVAILABLE) {
		if (link->status != DL_STATE_AVAILABLE &&
		!(link->flags & DL_FLAG_SYNC_STATE_ONLY)) {
		device_links_missing_supplier(dev);
		ret = -EPROBE_DEFER;
		break;
		@@ -949,11 +960,21 @@ static void __device_links_no_driver(struct device *dev)
		if (!(link->flags & DL_FLAG_MANAGED))
		continue;

		if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER)
		if (link->flags & DL_FLAG_AUTOREMOVE_CONSUMER) {
		device_link_drop_managed(link);
		else if (link->status == DL_STATE_CONSUMER_PROBE \|\|
		link->status == DL_STATE_ACTIVE)
		continue;
		}

		if (link->status != DL_STATE_CONSUMER_PROBE &&
		link->status != DL_STATE_ACTIVE)
		continue;

		if (link->supplier->links.status == DL_DEV_DRIVER_BOUND) {
		WRITE_ONCE(link->status, DL_STATE_AVAILABLE);
		} else {
		WARN_ON(!(link->flags & DL_FLAG_SYNC_STATE_ONLY));
		WRITE_ONCE(link->status, DL_STATE_DORMANT);
		}
		}

		dev->links.status = DL_DEV_NO_DRIVER;
		@@ -1162,6 +1183,150 @@ static void device_links_purge(struct device *dev)
		device_links_write_unlock();
		}

		static u32 fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY;
		static int __init fw_devlink_setup(char *arg)
		{
		if (!arg)
		return -EINVAL;

		if (strcmp(arg, "off") == 0) {
		fw_devlink_flags = 0;
		} else if (strcmp(arg, "permissive") == 0) {
		fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY;
		} else if (strcmp(arg, "on") == 0) {
		fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER;
		} else if (strcmp(arg, "rpm") == 0) {
		fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER \|
		DL_FLAG_PM_RUNTIME;
		}
		return 0;
		}
		early_param("fw_devlink", fw_devlink_setup);

		u32 fw_devlink_get_flags(void)
		{
		return fw_devlink_flags;
		}

		static bool fw_devlink_is_permissive(void)
		{
		return fw_devlink_flags == DL_FLAG_SYNC_STATE_ONLY;
		}

		static void fw_devlink_link_device(struct device *dev)
		{
		int fw_ret;

		if (!fw_devlink_flags)
		return;

		mutex_lock(&defer_fw_devlink_lock);
		if (!defer_fw_devlink_count)
		device_link_add_missing_supplier_links();

		/*
		* The device's fwnode not having add_links() doesn't affect if other
		* consumers can find this device as a supplier. So, this check is
		* intentionally placed after device_link_add_missing_supplier_links().
		*/
		if (!fwnode_has_op(dev->fwnode, add_links))
		goto out;

		/*
		* If fw_devlink is being deferred, assume all devices have mandatory
		* suppliers they need to link to later. Then, when the fw_devlink is
		* resumed, all these devices will get a chance to try and link to any
		* suppliers they have.
		*/
		if (!defer_fw_devlink_count) {
		fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev);
		if (fw_ret == -ENODEV && fw_devlink_is_permissive())
		fw_ret = -EAGAIN;
		} else {
		fw_ret = -ENODEV;
		}

		if (fw_ret == -ENODEV)
		device_link_wait_for_mandatory_supplier(dev);
		else if (fw_ret)
		device_link_wait_for_optional_supplier(dev);

		out:
		mutex_unlock(&defer_fw_devlink_lock);
		}

		/**
		* fw_devlink_pause - Pause parsing of fwnode to create device links
		*
		* Calling this function defers any fwnode parsing to create device links until
		* fw_devlink_resume() is called. Both these functions are ref counted and the
		* caller needs to match the calls.
		*
		* While fw_devlink is paused:
		* - Any device that is added won't have its fwnode parsed to create device
		* links.
		* - The probe of the device will also be deferred during this period.
		* - Any devices that were already added, but waiting for suppliers won't be
		* able to link to newly added devices.
		*
		* Once fw_devlink_resume():
		* - All the fwnodes that was not parsed will be parsed.
		* - All the devices that were deferred probing will be reattempted if they
		* aren't waiting for any more suppliers.
		*
		* This pair of functions, is mainly meant to optimize the parsing of fwnodes
		* when a lot of devices that need to link to each other are added in a short
		* interval of time. For example, adding all the top level devices in a system.
		*
		* For example, if N devices are added and:
		* - All the consumers are added before their suppliers
		* - All the suppliers of the N devices are part of the N devices
		*
		* Then:
		*
		* - With the use of fw_devlink_pause() and fw_devlink_resume(), each device
		* will only need one parsing of its fwnode because it is guaranteed to find
		* all the supplier devices already registered and ready to link to. It won't
		* have to do another pass later to find one or more suppliers it couldn't
		* find in the first parse of the fwnode. So, we'll only need O(N) fwnode
		* parses.
		*
		* - Without the use of fw_devlink_pause() and fw_devlink_resume(), we would
		* end up doing O(N^2) parses of fwnodes because every device that's added is
		* guaranteed to trigger a parse of the fwnode of every device added before
		* it. This O(N^2) parse is made worse by the fact that when a fwnode of a
		* device is parsed, all it descendant devices might need to have their
		* fwnodes parsed too (even if the devices themselves aren't added).
		*/
		void fw_devlink_pause(void)
		{
		mutex_lock(&defer_fw_devlink_lock);
		defer_fw_devlink_count++;
		mutex_unlock(&defer_fw_devlink_lock);
		}

		/** fw_devlink_resume - Resume parsing of fwnode to create device links
		*
		* This function is used in conjunction with fw_devlink_pause() and is ref
		* counted. See documentation for fw_devlink_pause() for more details.
		*/
		void fw_devlink_resume(void)
		{
		mutex_lock(&defer_fw_devlink_lock);
		if (!defer_fw_devlink_count) {
		WARN(true, "Unmatched fw_devlink pause/resume!");
		goto out;
		}

		defer_fw_devlink_count--;
		if (defer_fw_devlink_count)
		goto out;

		device_link_add_missing_supplier_links();
		driver_deferred_probe_force_trigger();
		out:
		mutex_unlock(&defer_fw_devlink_lock);
		}
		/* Device links support end. */

		int (platform_notify)(struct device dev) = NULL;
		@@ -2364,36 +2529,6 @@ static int device_private_init(struct device *dev)
		return 0;
		}

		static u32 fw_devlink_flags;
		static int __init fw_devlink_setup(char *arg)
		{
		if (!arg)
		return -EINVAL;

		if (strcmp(arg, "off") == 0) {
		fw_devlink_flags = 0;
		} else if (strcmp(arg, "permissive") == 0) {
		fw_devlink_flags = DL_FLAG_SYNC_STATE_ONLY;
		} else if (strcmp(arg, "on") == 0) {
		fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER;
		} else if (strcmp(arg, "rpm") == 0) {
		fw_devlink_flags = DL_FLAG_AUTOPROBE_CONSUMER \|
		DL_FLAG_PM_RUNTIME;
		}
		return 0;
		}
		early_param("fw_devlink", fw_devlink_setup);

		u32 fw_devlink_get_flags(void)
		{
		return fw_devlink_flags;
		}

		static bool fw_devlink_is_permissive(void)
		{
		return fw_devlink_flags == DL_FLAG_SYNC_STATE_ONLY;
		}

		/**
		* device_add - add device to device hierarchy.
		* @dev: device.
		@@ -2426,9 +2561,8 @@ int device_add(struct device *dev)
		struct device *parent;
		struct kobject *kobj;
		struct class_interface *class_intf;
		int error = -EINVAL, fw_ret;
		int error = -EINVAL;
		struct kobject *glue_dir = NULL;
		bool is_fwnode_dev = false;

		dev = get_device(dev);
		if (!dev)
		@@ -2526,11 +2660,6 @@ int device_add(struct device *dev)

		kobject_uevent(&dev->kobj, KOBJ_ADD);

		if (dev->fwnode && !dev->fwnode->dev) {
		dev->fwnode->dev = dev;
		is_fwnode_dev = true;
		}

		/*
		* Check if any of the other devices (consumers) have been waiting for
		* this device (supplier) to be added so that they can create a device
		@@ -2539,19 +2668,13 @@ int device_add(struct device *dev)
		* This needs to happen after device_pm_add() because device_link_add()
		* requires the supplier be registered before it's called.
		*
		* But this also needs to happe before bus_probe_device() to make sure
		* But this also needs to happen before bus_probe_device() to make sure
		* waiting consumers can link to it before the driver is bound to the
		* device and the driver sync_state callback is called for this device.
		*/
		device_link_add_missing_supplier_links();

		if (fw_devlink_flags && is_fwnode_dev &&
		fwnode_has_op(dev->fwnode, add_links)) {
		fw_ret = fwnode_call_int_op(dev->fwnode, add_links, dev);
		if (fw_ret == -ENODEV && !fw_devlink_is_permissive())
		device_link_wait_for_mandatory_supplier(dev);
		else if (fw_ret)
		device_link_wait_for_optional_supplier(dev);
		if (dev->fwnode && !dev->fwnode->dev) {
		dev->fwnode->dev = dev;
		fw_devlink_link_device(dev);
		}

		bus_probe_device(dev);

drivers/base/dd.c

+18 −15

Original line number	Diff line number	Diff line
		@@ -164,6 +164,11 @@ static void driver_deferred_probe_trigger(void)
		if (!driver_deferred_probe_enable)
		return;

		driver_deferred_probe_force_trigger();
		}

		void driver_deferred_probe_force_trigger(void)
		{
		/*
		* A successful probe means that all the devices in the pending list
		* should be triggered to be reprobed. Move all the deferred devices
		@@ -254,12 +259,12 @@ __setup("deferred_probe_timeout=", deferred_probe_timeout_setup);
		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");
		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");
		dev_warn(dev, "deferred probe timeout, ignoring dependency\n");
		return -ETIMEDOUT;
		}

		@@ -275,7 +280,7 @@ static void deferred_probe_timeout_work_func(struct work_struct *work)
		flush_work(&deferred_probe_work);

		list_for_each_entry_safe(private, p, &deferred_probe_pending_list, deferred_probe)
		dev_info(private->device, "deferred probe pending");
		dev_info(private->device, "deferred probe pending\n");
		wake_up(&probe_timeout_waitqueue);
		}
		static DECLARE_DELAYED_WORK(deferred_probe_timeout_work, deferred_probe_timeout_work_func);
		@@ -336,7 +341,7 @@ bool device_is_bound(struct device *dev)
		static void driver_bound(struct device *dev)
		{
		if (device_is_bound(dev)) {
		printk(KERN_WARNING "%s: device %s already bound\n",
		pr_warn("%s: device %s already bound\n",
		__func__, kobject_name(&dev->kobj));
		return;
		}
		@@ -505,7 +510,7 @@ re_probe:
		}

		if (driver_sysfs_add(dev)) {
		printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
		pr_err("%s: driver_sysfs_add(%s) failed\n",
		__func__, dev_name(dev));
		goto probe_failed;
		}
		@@ -597,8 +602,7 @@ pinctrl_bind_failed:
		break;
		default:
		/* driver matched but the probe failed */
		printk(KERN_WARNING
		"%s: probe of %s failed with error %d\n",
		pr_warn("%s: probe of %s failed with error %d\n",
		drv->name, dev_name(dev), ret);
		}
		/*
		@@ -624,7 +628,7 @@ static int really_probe_debug(struct device dev, struct device_driver drv)
		ret = really_probe(dev, drv);
		rettime = ktime_get();
		delta = ktime_sub(rettime, calltime);
		printk(KERN_DEBUG "probe of %s returned %d after %lld usecs\n",
		pr_debug("probe of %s returned %d after %lld usecs\n",
		dev_name(dev), ret, (s64) ktime_to_us(delta));
		return ret;
		}
		@@ -713,8 +717,7 @@ static inline bool cmdline_requested_async_probing(const char *drv_name)
		static int __init save_async_options(char *buf)
		{
		if (strlen(buf) >= ASYNC_DRV_NAMES_MAX_LEN)
		printk(KERN_WARNING
		"Too long list of driver names for 'driver_async_probe'!\n");
		pr_warn("Too long list of driver names for 'driver_async_probe'!\n");

		strlcpy(async_probe_drv_names, buf, ASYNC_DRV_NAMES_MAX_LEN);
		return 0;
		@@ -789,7 +792,7 @@ static int __device_attach_driver(struct device_driver drv, void _data)
		dev_dbg(dev, "Device match requests probe deferral\n");
		driver_deferred_probe_add(dev);
		} else if (ret < 0) {
		dev_dbg(dev, "Bus failed to match device: %d", ret);
		dev_dbg(dev, "Bus failed to match device: %d\n", ret);
		return ret;
		} /* ret > 0 means positive match */

		@@ -1022,7 +1025,7 @@ static int __driver_attach(struct device dev, void data)
		dev_dbg(dev, "Device match requests probe deferral\n");
		driver_deferred_probe_add(dev);
		} else if (ret < 0) {
		dev_dbg(dev, "Bus failed to match device: %d", ret);
		dev_dbg(dev, "Bus failed to match device: %d\n", ret);
		return ret;
		} /* ret > 0 means positive match */

drivers/base/firmware_loader/fallback.c

+9 −6

Original line number	Diff line number	Diff line
		@@ -9,6 +9,7 @@
		#include <linux/umh.h>
		#include <linux/sysctl.h>
		#include <linux/vmalloc.h>
		#include <linux/module.h>

		#include "fallback.h"
		#include "firmware.h"
		@@ -17,6 +18,8 @@
		* firmware fallback mechanism
		*/

		MODULE_IMPORT_NS(FIRMWARE_LOADER_PRIVATE);

		extern struct firmware_fallback_config fw_fallback_config;

		/* These getters are vetted to use int properly */
		@@ -460,7 +463,7 @@ static const struct attribute_group *fw_dev_attr_groups[] = {

		static struct fw_sysfs *
		fw_create_instance(struct firmware firmware, const char fw_name,
		struct device *device, enum fw_opt opt_flags)
		struct device *device, u32 opt_flags)
		{
		struct fw_sysfs *fw_sysfs;
		struct device *f_dev;
		@@ -493,7 +496,7 @@ exit:
		* In charge of constructing a sysfs fallback interface for firmware loading.
		**/
		static int fw_load_sysfs_fallback(struct fw_sysfs *fw_sysfs,
		enum fw_opt opt_flags, long timeout)
		u32 opt_flags, long timeout)
		{
		int retval = 0;
		struct device *f_dev = &fw_sysfs->dev;
		@@ -547,7 +550,7 @@ err_put_dev:

		static int fw_load_from_user_helper(struct firmware *firmware,
		const char name, struct device device,
		enum fw_opt opt_flags)
		u32 opt_flags)
		{
		struct fw_sysfs *fw_sysfs;
		long timeout;
		@@ -588,7 +591,7 @@ out_unlock:
		return ret;
		}

		static bool fw_force_sysfs_fallback(enum fw_opt opt_flags)
		static bool fw_force_sysfs_fallback(u32 opt_flags)
		{
		if (fw_fallback_config.force_sysfs_fallback)
		return true;
		@@ -597,7 +600,7 @@ static bool fw_force_sysfs_fallback(enum fw_opt opt_flags)
		return true;
		}

		static bool fw_run_sysfs_fallback(enum fw_opt opt_flags)
		static bool fw_run_sysfs_fallback(u32 opt_flags)
		{
		int ret;

		@@ -640,7 +643,7 @@ static bool fw_run_sysfs_fallback(enum fw_opt opt_flags)
		**/
		int firmware_fallback_sysfs(struct firmware fw, const char name,
		struct device *device,
		enum fw_opt opt_flags,
		u32 opt_flags,
		int ret)
		{
		if (!fw_run_sysfs_fallback(opt_flags))

Admin message