mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Paul Cercueil <paul@crapouillou.net>
To: James Hilliard <james.hilliard1@gmail.com>,
	Miquel Raynal <miquel.raynal@bootlin.com>,
	Richard Weinberger <richard@nod.at>,
	Vignesh Raghavendra <vigneshr@ti.com>
Cc: linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org,
	Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
	Srinivas Kandagatla <srini@kernel.org>,
	Tze Yee Ng	 <tze.yee.ng@altera.com>
Subject: Re: [PATCH v5 01/58] nvmem: disconnect provider callbacks before unregister returns
Date: Tue, 17 Nov 2026 12:25:56 +0100	[thread overview]
Message-ID: <9c247830067d2192acfe08080d1c5f2bb366cf1a.camel@crapouillou.net> (raw)
In-Reply-To: <20261115-submit-rawnand-retained-handle-lifetime-v1-v5-1-cbc49c5c5e74@gmail.com>

Hi James,

Le dimanche 15 novembre 2026 à 23:29 -0700, James Hilliard a écrit :
> An NVMEM consumer or device reference can outlive provider unbind. The
> reference retains the NVMEM allocation, but not the private data or
> hardware resources that the provider releases during remove. Pinning the
> provider module also does not prevent unbind from freeing that state.
> 
> Reject new callback access once unregister starts and drain admitted
> accesses with SRCU before returning to the provider. Cover register
> access, keepout handling, cell post-processing and device matching.
> Existing consumers retain core-owned metadata and return -ENODEV after
> disconnection. Release the write-protect GPIO after the drain so
> retained references do not prevent a new provider from requesting it.
> The final device release frees only core-owned data.
> 
> Give cell entries their own references and retire layout cells when
> their driver is unbound. Remove and drain cell attributes and callbacks
> before layout-owned state is freed. Rebinding creates new entries; held
> old cells remain disconnected. Remove partially added cells when a
> layout probe fails, and destroy the layout during provider unregister
> rather than at the final consumer put.
> 
> Track layout ownership explicitly so provider cells added after layout
> creation survive its unbind. Rebuild sysfs cell attributes when layouts
> bind or unbind, retaining cell entries until their attributes have been
> removed. Free partial attribute allocations on failure and remove the
> group before device deletion. Only notify provider removal after a
> successful registration notification.
> 
> Preserve the existing exporter-module references and allow providers
> to specify an explicit NULL owner when their operations are built in.
> Providers remain responsible for unregistering before releasing
> callback state.
> 
> Retain the firmware node explicitly and serialize consumer-reference
> acquisition with disconnection. This lets MTD unregister an OTP provider
> before freeing its backing object without requiring a release callback
> into the departing provider module.

The fact that you have 5 paragraphs listing everything that the patch does makes
me think it should not be one patch, but a dozen of them.

This is just impossible to review, to be honest.

Cheers,
-Paul

> Cc: Srinivas Kandagatla <srini@kernel.org>
> Cc: Tze Yee Ng <tze.yee.ng@altera.com>
> Signed-off-by: James Hilliard <james.hilliard1@gmail.com>
> ---
>  drivers/nvmem/Kconfig                |   1 +
>  drivers/nvmem/core.c                 | 463 +++++++++++++++++++++++-----------
> -
>  drivers/nvmem/internals.h            |  16 +-
>  drivers/nvmem/layouts.c              |   2 +
>  drivers/nvmem/layouts/fixed-layout.c |   2 +-
>  drivers/nvmem/layouts/onie-tlv.c     |  20 +-
>  drivers/nvmem/layouts/sl28vpd.c      |   3 +-
>  drivers/nvmem/layouts/u-boot-env.c   |  25 +-
>  include/linux/nvmem-provider.h       |  16 +-
>  9 files changed, 373 insertions(+), 175 deletions(-)
> 
> diff --git a/drivers/nvmem/Kconfig b/drivers/nvmem/Kconfig
> index c36c2a4c2a0b..550f3118071a 100644
> --- a/drivers/nvmem/Kconfig
> +++ b/drivers/nvmem/Kconfig
> @@ -1,6 +1,7 @@
>  # SPDX-License-Identifier: GPL-2.0-only
>  menuconfig NVMEM
>  	bool "NVMEM Support"
> +	select SRCU
>  	imply NVMEM_LAYOUTS
>  	help
>  	  Support for NVMEM(Non Volatile Memory) devices like EEPROM,
> EFUSES...
> diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c
> index 0556d140170a..b71d80d140dd 100644
> --- a/drivers/nvmem/core.c
> +++ b/drivers/nvmem/core.c
> @@ -13,6 +13,7 @@
>  #include <linux/idr.h>
>  #include <linux/init.h>
>  #include <linux/kref.h>
> +#include <linux/lockdep.h>
>  #include <linux/module.h>
>  #include <linux/mutex.h>
>  #include <linux/nvmem-consumer.h>
> @@ -26,7 +27,11 @@
>  #define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
>  
>  #define FLAG_COMPAT		BIT(0)
> +#define FLAG_REGISTERED		BIT(1)
>  struct nvmem_cell_entry {
> +	struct kref		refcnt;
> +	bool			disconnected;
> +	struct nvmem_layout	*layout;
>  	const char		*name;
>  	int			offset;
>  	size_t			raw_len;
> @@ -54,31 +59,30 @@ static LIST_HEAD(nvmem_lookup_list);
>  
>  static BLOCKING_NOTIFIER_HEAD(nvmem_notifier);
>  
> +static void nvmem_cell_entry_put(struct nvmem_cell_entry *cell);
> +
>  static int __nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
>  			    void *val, size_t bytes)
>  {
> -	struct nvmem_operations *ops = nvmem->ops;
> -
> -	if (!ops->reg_read)
> +	if (!nvmem->reg_read)
>  		return -EOPNOTSUPP;
>  
> -	return ops->reg_read(nvmem->priv, offset, val, bytes);
> +	return nvmem->reg_read(nvmem->priv, offset, val, bytes);
>  }
>  
>  static int __nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
>  			     void *val, size_t bytes)
>  {
> -	struct nvmem_operations *ops = nvmem->ops;
>  	int ret, wr_ok;
>  
> -	if (!ops->reg_write)
> +	if (!nvmem->reg_write)
>  		return -EOPNOTSUPP;
>  
>  	ret = gpiod_set_value_cansleep(nvmem->wp_gpio, 0);
>  	if (ret)
>  		return ret;
>  
> -	wr_ok = ops->reg_write(nvmem->priv, offset, val, bytes);
> +	wr_ok = nvmem->reg_write(nvmem->priv, offset, val, bytes);
>  
>  	ret = gpiod_set_value_cansleep(nvmem->wp_gpio, 1);
>  	if (ret)
> @@ -154,6 +158,10 @@ static int nvmem_access_with_keepouts(struct nvmem_device
> *nvmem,
>  static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
>  			  void *val, size_t bytes)
>  {
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected))
> +		return -ENODEV;
> +
>  	if (!nvmem->nkeepout)
>  		return __nvmem_reg_read(nvmem, offset, val, bytes);
>  
> @@ -163,6 +171,10 @@ static int nvmem_reg_read(struct nvmem_device *nvmem,
> unsigned int offset,
>  static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
>  			   void *val, size_t bytes)
>  {
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected))
> +		return -ENODEV;
> +
>  	if (!nvmem->nkeepout)
>  		return __nvmem_reg_write(nvmem, offset, val, bytes);
>  
> @@ -289,8 +301,6 @@ static ssize_t bin_attr_nvmem_write(struct file *filp,
> struct kobject *kobj,
>  
>  static umode_t nvmem_bin_attr_get_umode(struct nvmem_device *nvmem)
>  {
> -	struct nvmem_operations *ops = nvmem->ops;
> -
>  	umode_t mode = 0400;
>  
>  	if (!nvmem->root_only)
> @@ -299,10 +309,10 @@ static umode_t nvmem_bin_attr_get_umode(struct
> nvmem_device *nvmem)
>  	if (!nvmem->read_only)
>  		mode |= 0200;
>  
> -	if (!ops->reg_write)
> +	if (!nvmem->reg_write)
>  		mode &= ~0200;
>  
> -	if (!ops->reg_read)
> +	if (!nvmem->reg_read)
>  		mode &= ~0444;
>  
>  	return mode;
> @@ -333,7 +343,6 @@ static umode_t nvmem_attr_is_visible(struct kobject *kobj,
>  {
>  	struct device *dev = kobj_to_dev(kobj);
>  	struct nvmem_device *nvmem = to_nvmem_device(dev);
> -	struct nvmem_operations *ops = nvmem->ops;
>  
>  	/*
>  	 * If the device has no .reg_write operation, do not allow
> @@ -342,7 +351,7 @@ static umode_t nvmem_attr_is_visible(struct kobject *kobj,
>  	 * can be forced into read-write mode using the 'force_ro'
>  	 * attribute.
>  	 */
> -	if (attr == &dev_attr_force_ro.attr && !ops->reg_write)
> +	if (attr == &dev_attr_force_ro.attr && !nvmem->reg_write)
>  		return 0;	/* Attribute not visible */
>  
>  	return attr->mode;
> @@ -466,59 +475,102 @@ static void nvmem_sysfs_remove_compat(struct
> nvmem_device *nvmem)
>  		device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
>  }
>  
> -static int nvmem_populate_sysfs_cells(struct nvmem_device *nvmem)
> +static void nvmem_sysfs_free_cell_attrs(const struct bin_attribute * const
> *attrs)
>  {
> -	struct attribute_group group = {
> -		.name	= "cells",
> -	};
> -	struct nvmem_cell_entry *entry;
> -	const struct bin_attribute **pattrs;
> -	struct bin_attribute *attrs;
> -	unsigned int ncells = 0, i = 0;
> -	int ret;
> +	if (!attrs)
> +		return;
>  
> -	guard(mutex)(&nvmem_mutex);
> +	for (int i = 0; attrs[i]; i++) {
> +		nvmem_cell_entry_put(attrs[i]->private);
> +		kfree(attrs[i]->attr.name);
> +		kfree(attrs[i]);
> +	}
> +	kfree(attrs);
> +}
>  
> -	if (list_empty(&nvmem->cells) || nvmem->sysfs_cells_populated)
> -		return 0;
> +static void __nvmem_sysfs_remove_cells(struct nvmem_device *nvmem)
> +{
> +	lockdep_assert_held(&nvmem->sysfs_mutex);
>  
> -	/* Allocate an array of attributes with a sentinel */
> -	ncells = list_count_nodes(&nvmem->cells);
> -	pattrs = devm_kcalloc(&nvmem->dev, ncells + 1,
> -			      sizeof(struct bin_attribute *), GFP_KERNEL);
> -	if (!pattrs)
> -		return -ENOMEM;
> +	if (!nvmem->sysfs_cells_populated)
> +		return;
>  
> -	attrs = devm_kcalloc(&nvmem->dev, ncells, sizeof(struct
> bin_attribute), GFP_KERNEL);
> -	if (!attrs)
> -		return -ENOMEM;
> +	device_remove_group(&nvmem->dev, &nvmem->cells_group);
> +	nvmem_sysfs_free_cell_attrs(nvmem->cells_group.bin_attrs);
> +	nvmem->cells_group.bin_attrs = NULL;
> +	nvmem->sysfs_cells_populated = false;
> +}
> +
> +static void nvmem_sysfs_remove_cells(struct nvmem_device *nvmem)
> +{
> +	guard(mutex)(&nvmem->sysfs_mutex);
> +	__nvmem_sysfs_remove_cells(nvmem);
> +}
> +
> +static int nvmem_populate_sysfs_cells(struct nvmem_device *nvmem)
> +{
> +	struct nvmem_cell_entry *entry;
> +	const struct bin_attribute **attrs = NULL;
> +	unsigned int i = 0;
> +	int ret = 0;
>  
> -	/* Initialize each attribute to take the name and size of the cell */
> -	list_for_each_entry(entry, &nvmem->cells, node) {
> -		sysfs_bin_attr_init(&attrs[i]);
> -		attrs[i].attr.name = devm_kasprintf(&nvmem->dev, GFP_KERNEL,
> -						    "%s@%x,%x", entry->name,
> -						    entry->offset,
> -						    entry->bit_offset);
> -		attrs[i].attr.mode = 0444 & nvmem_bin_attr_get_umode(nvmem);
> -		attrs[i].size = entry->bytes;
> -		attrs[i].read = &nvmem_cell_attr_read;
> -		attrs[i].private = entry;
> -		if (!attrs[i].attr.name)
> +	guard(mutex)(&nvmem->sysfs_mutex);
> +
> +	__nvmem_sysfs_remove_cells(nvmem);
> +
> +	scoped_guard(mutex, &nvmem_mutex) {
> +		if (nvmem->disconnected)
> +			return -ENODEV;
> +		if (list_empty(&nvmem->cells))
> +			return 0;
> +
> +		attrs = kcalloc(list_count_nodes(&nvmem->cells) + 1,
> +				sizeof(*attrs), GFP_KERNEL);
> +		if (!attrs)
>  			return -ENOMEM;
>  
> -		pattrs[i] = &attrs[i];
> -		i++;
> +		list_for_each_entry(entry, &nvmem->cells, node) {
> +			struct bin_attribute *attr;
> +
> +			attr = kzalloc_obj(*attr);
> +			if (!attr) {
> +				ret = -ENOMEM;
> +				break;
> +			}
> +			sysfs_bin_attr_init(attr);
> +			attr->attr.name = kasprintf(GFP_KERNEL, "%s@%x,%x",
> +						   entry->name, entry-
> >offset,
> +						   entry->bit_offset);
> +			if (!attr->attr.name) {
> +				kfree(attr);
> +				ret = -ENOMEM;
> +				break;
> +			}
> +			attr->attr.mode = 0444 &
> nvmem_bin_attr_get_umode(nvmem);
> +			attr->size = entry->bytes;
> +			attr->read = nvmem_cell_attr_read;
> +			attr->private = entry;
> +			kref_get(&entry->refcnt);
> +			attrs[i++] = attr;
> +		}
>  	}
> +	if (ret)
> +		goto err_free;
>  
> -	group.bin_attrs = pattrs;
> +	nvmem->cells_group.name = "cells";
> +	nvmem->cells_group.bin_attrs = attrs;
>  
> -	ret = device_add_group(&nvmem->dev, &group);
> -	if (ret)
> -		return ret;
> +	ret = device_add_group(&nvmem->dev, &nvmem->cells_group);
> +	if (ret) {
> +		nvmem->cells_group.bin_attrs = NULL;
> +		goto err_free;
> +	}
>  
>  	nvmem->sysfs_cells_populated = true;
> +	return 0;
>  
> +err_free:
> +	nvmem_sysfs_free_cell_attrs(attrs);
>  	return ret;
>  }
>  
> @@ -533,6 +585,10 @@ static void nvmem_sysfs_remove_compat(struct nvmem_device
> *nvmem)
>  {
>  }
>  
> +static void nvmem_sysfs_remove_cells(struct nvmem_device *nvmem)
> +{
> +}
> +
>  #endif /* CONFIG_NVMEM_SYSFS */
>  
>  static void nvmem_release(struct device *dev)
> @@ -540,8 +596,8 @@ static void nvmem_release(struct device *dev)
>  	struct nvmem_device *nvmem = to_nvmem_device(dev);
>  
>  	ida_free(&nvmem_ida, nvmem->id);
> -	gpiod_put(nvmem->wp_gpio);
> -	kfree(nvmem->ops);
> +	of_node_put(nvmem->dev.of_node);
> +	cleanup_srcu_struct(&nvmem->srcu);
>  	kfree(nvmem);
>  }
>  
> @@ -553,22 +609,30 @@ static const struct bus_type nvmem_bus_type = {
>  	.name		= "nvmem",
>  };
>  
> -static void nvmem_cell_entry_drop(struct nvmem_cell_entry *cell)
> +static void nvmem_cell_entry_release(struct kref *ref)
>  {
> -	blocking_notifier_call_chain(&nvmem_notifier, NVMEM_CELL_REMOVE,
> cell);
> -	scoped_guard(mutex, &nvmem_mutex)
> -		list_del(&cell->node);
> +	struct nvmem_cell_entry *cell = container_of(ref, struct
> nvmem_cell_entry, refcnt);
> +
>  	of_node_put(cell->np);
>  	kfree_const(cell->name);
>  	kfree(cell);
>  }
>  
> +static void nvmem_cell_entry_put(struct nvmem_cell_entry *cell)
> +{
> +	kref_put(&cell->refcnt, nvmem_cell_entry_release);
> +}
> +
>  static void nvmem_device_remove_all_cells(const struct nvmem_device *nvmem)
>  {
>  	struct nvmem_cell_entry *cell, *p;
>  
> -	list_for_each_entry_safe(cell, p, &nvmem->cells, node)
> -		nvmem_cell_entry_drop(cell);
> +	list_for_each_entry_safe(cell, p, &nvmem->cells, node) {
> +		blocking_notifier_call_chain(&nvmem_notifier,
> NVMEM_CELL_REMOVE, cell);
> +		scoped_guard(mutex, &nvmem_mutex)
> +			list_del(&cell->node);
> +		nvmem_cell_entry_put(cell);
> +	}
>  }
>  
>  static void nvmem_cell_entry_add(struct nvmem_cell_entry *cell)
> @@ -583,6 +647,7 @@ static int
> nvmem_cell_info_to_nvmem_cell_entry_nodup(struct nvmem_device *nvmem,
>  						     struct nvmem_cell_entry
> *cell)
>  {
>  	cell->nvmem = nvmem;
> +	cell->disconnected = false;
>  	cell->offset = info->offset;
>  	cell->raw_len = info->raw_len ?: info->bytes;
>  	cell->bytes = info->bytes;
> @@ -639,20 +704,17 @@ static int nvmem_cell_info_to_nvmem_cell_entry(struct
> nvmem_device *nvmem,
>  	return 0;
>  }
>  
> -/**
> - * nvmem_add_one_cell() - Add one cell information to an nvmem device
> - *
> - * @nvmem: nvmem device to add cells to.
> - * @info: nvmem cell info to add to the device
> - *
> - * Return: 0 or negative error code on failure.
> - */
> -int nvmem_add_one_cell(struct nvmem_device *nvmem,
> -		       const struct nvmem_cell_info *info)
> +static int __nvmem_add_one_cell(struct nvmem_device *nvmem,
> +				const struct nvmem_cell_info *info,
> +				struct nvmem_layout *layout)
>  {
>  	struct nvmem_cell_entry *cell;
>  	int rval;
>  
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected))
> +		return -ENODEV;
> +
>  	cell = kzalloc_obj(*cell);
>  	if (!cell)
>  		return -ENOMEM;
> @@ -663,12 +725,45 @@ int nvmem_add_one_cell(struct nvmem_device *nvmem,
>  		return rval;
>  	}
>  
> +	kref_init(&cell->refcnt);
> +	cell->layout = layout;
>  	nvmem_cell_entry_add(cell);
>  
>  	return 0;
>  }
> +
> +/**
> + * nvmem_add_one_cell() - Add one cell information to an nvmem device
> + *
> + * @nvmem: nvmem device to add cells to.
> + * @info: nvmem cell info to add to the device
> + *
> + * Return: 0 or negative error code on failure.
> + */
> +int nvmem_add_one_cell(struct nvmem_device *nvmem,
> +		       const struct nvmem_cell_info *info)
> +{
> +	return __nvmem_add_one_cell(nvmem, info, NULL);
> +}
>  EXPORT_SYMBOL_GPL(nvmem_add_one_cell);
>  
> +/**
> + * nvmem_layout_add_cell() - Add a cell owned by an NVMEM layout
> + * @layout: Layout registering the cell from its add_cells callback.
> + * @info: Cell description.
> + *
> + * The cell and its post-processing callback are disconnected when the layout
> + * is unregistered. Provider cells added with nvmem_add_one_cell() are
> retained.
> + *
> + * Return: 0 or a negative error code.
> + */
> +int nvmem_layout_add_cell(struct nvmem_layout *layout,
> +			  const struct nvmem_cell_info *info)
> +{
> +	return __nvmem_add_one_cell(layout->nvmem, info, layout);
> +}
> +EXPORT_SYMBOL_GPL(nvmem_layout_add_cell);
> +
>  /**
>   * nvmem_add_cells() - Add cell information to an nvmem device
>   *
> @@ -729,6 +824,7 @@ nvmem_find_cell_entry_by_name(struct nvmem_device *nvmem,
> const char *cell_id)
>  	list_for_each_entry(iter, &nvmem->cells, node) {
>  		if (strcmp(cell_id, iter->name) == 0) {
>  			cell = iter;
> +			kref_get(&cell->refcnt);
>  			break;
>  		}
>  	}
> @@ -789,12 +885,17 @@ static int nvmem_validate_keepouts(struct nvmem_device
> *nvmem)
>  	return 0;
>  }
>  
> -int nvmem_add_cells_from_dt(struct nvmem_device *nvmem, struct device_node
> *np)
> +static int __nvmem_add_cells_from_dt(struct nvmem_device *nvmem, struct
> device_node *np,
> +				     struct nvmem_layout *layout)
>  {
>  	struct device *dev = &nvmem->dev;
>  	const __be32 *addr;
>  	int len, ret;
>  
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected))
> +		return -ENODEV;
> +
>  	for_each_child_of_node_scoped(np, child) {
>  		struct nvmem_cell_info info = {0};
>  
> @@ -827,7 +928,7 @@ int nvmem_add_cells_from_dt(struct nvmem_device *nvmem,
> struct device_node *np)
>  		if (nvmem->fixup_dt_cell_info)
>  			nvmem->fixup_dt_cell_info(nvmem, &info);
>  
> -		ret = nvmem_add_one_cell(nvmem, &info);
> +		ret = __nvmem_add_one_cell(nvmem, &info, layout);
>  		kfree(info.name);
>  		if (ret) {
>  			of_node_put(info.np);
> @@ -837,8 +938,19 @@ int nvmem_add_cells_from_dt(struct nvmem_device *nvmem,
> struct device_node *np)
>  
>  	return 0;
>  }
> +
> +int nvmem_add_cells_from_dt(struct nvmem_device *nvmem, struct device_node
> *np)
> +{
> +	return __nvmem_add_cells_from_dt(nvmem, np, NULL);
> +}
>  EXPORT_SYMBOL_GPL(nvmem_add_cells_from_dt);
>  
> +int nvmem_layout_add_cells_from_dt(struct nvmem_layout *layout, struct
> device_node *np)
> +{
> +	return __nvmem_add_cells_from_dt(layout->nvmem, np, layout);
> +}
> +EXPORT_SYMBOL_GPL(nvmem_layout_add_cells_from_dt);
> +
>  static int nvmem_add_cells_from_legacy_of(struct nvmem_device *nvmem)
>  {
>  	return nvmem_add_cells_from_dt(nvmem, nvmem->dev.of_node);
> @@ -851,29 +963,68 @@ int nvmem_layout_register(struct nvmem_layout *layout)
>  	if (!layout->add_cells)
>  		return -EINVAL;
>  
> -	/* Populate the cells */
> -	ret = layout->add_cells(layout);
> +	scoped_guard(srcu, &layout->nvmem->srcu) {
> +		if (READ_ONCE(layout->nvmem->disconnected))
> +			return -ENODEV;
> +		ret = layout->add_cells(layout);
> +	}
>  	if (ret)
> -		return ret;
> +		goto err_unregister;
>  
>  #ifdef CONFIG_NVMEM_SYSFS
>  	ret = nvmem_populate_sysfs_cells(layout->nvmem);
> -	if (ret) {
> -		nvmem_device_remove_all_cells(layout->nvmem);
> -		return ret;
> -	}
> +	if (ret)
> +		goto err_unregister;
>  #endif
>  
>  	return 0;
> +
> +err_unregister:
> +	nvmem_layout_unregister(layout);
> +	return ret;
>  }
>  EXPORT_SYMBOL_GPL(nvmem_layout_register);
>  
>  void nvmem_layout_unregister(struct nvmem_layout *layout)
>  {
> -	/* Keep the API even with an empty stub in case we need it later */
> +	struct nvmem_device *nvmem = layout->nvmem;
> +	struct nvmem_cell_entry *cell, *next;
> +	LIST_HEAD(cells);
> +
> +	scoped_guard(mutex, &nvmem_mutex) {
> +		list_for_each_entry_safe(cell, next, &nvmem->cells, node) {
> +			if (cell->layout != layout)
> +				continue;
> +			WRITE_ONCE(cell->disconnected, true);
> +			list_move_tail(&cell->node, &cells);
> +		}
> +	}
> +
> +	nvmem_sysfs_remove_cells(nvmem);
> +
> +	/* Old cell handles retain data, never a departing layout's
> callbacks. */
> +	synchronize_srcu(&nvmem->srcu);
> +	list_for_each_entry_safe(cell, next, &cells, node) {
> +		blocking_notifier_call_chain(&nvmem_notifier,
> NVMEM_CELL_REMOVE, cell);
> +		list_del(&cell->node);
> +		nvmem_cell_entry_put(cell);
> +	}
> +#ifdef CONFIG_NVMEM_SYSFS
> +	if (!READ_ONCE(nvmem->disconnected) &&
> nvmem_populate_sysfs_cells(nvmem))
> +		dev_warn(&nvmem->dev, "Failed to restore provider cell
> attributes\n");
> +#endif
>  }
>  EXPORT_SYMBOL_GPL(nvmem_layout_unregister);
>  
> +static void nvmem_disconnect(struct nvmem_device *nvmem)
> +{
> +	scoped_guard(mutex, &nvmem_mutex)
> +		WRITE_ONCE(nvmem->disconnected, true);
> +	synchronize_srcu(&nvmem->srcu);
> +	gpiod_put(nvmem->wp_gpio);
> +	nvmem->wp_gpio = NULL;
> +}
> +
>  /**
>   * nvmem_register() - Register a nvmem device for given nvmem_config.
>   * Also creates a binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
> @@ -883,10 +1034,8 @@ EXPORT_SYMBOL_GPL(nvmem_layout_unregister);
>   * Return: Will be an ERR_PTR() on error or a valid pointer to nvmem_device
>   * on success.
>   */
> -
>  struct nvmem_device *nvmem_register(const struct nvmem_config *config)
>  {
> -	struct nvmem_operations *ops;
>  	struct nvmem_device *nvmem;
>  	int rval;
>  
> @@ -900,15 +1049,15 @@ struct nvmem_device *nvmem_register(const struct
> nvmem_config *config)
>  	if (!nvmem)
>  		return ERR_PTR(-ENOMEM);
>  
> -	ops = kzalloc_obj(*ops);
> -	if (!ops) {
> +	rval = init_srcu_struct(&nvmem->srcu);
> +	if (rval) {
>  		kfree(nvmem);
> -		return ERR_PTR(-ENOMEM);
> +		return ERR_PTR(rval);
>  	}
>  
>  	rval = ida_alloc(&nvmem_ida, GFP_KERNEL);
>  	if (rval < 0) {
> -		kfree(ops);
> +		cleanup_srcu_struct(&nvmem->srcu);
>  		kfree(nvmem);
>  		return ERR_PTR(rval);
>  	}
> @@ -918,9 +1067,11 @@ struct nvmem_device *nvmem_register(const struct
> nvmem_config *config)
>  	nvmem->dev.type = &nvmem_provider_type;
>  	nvmem->dev.bus = &nvmem_bus_type;
>  	nvmem->dev.parent = config->dev;
> -	nvmem->ops = ops;
>  
>  	device_initialize(&nvmem->dev);
> +	mutex_init(&nvmem->sysfs_mutex);
> +
> +	nvmem->priv = config->priv;
>  
>  	if (!config->ignore_wp)
>  		nvmem->wp_gpio = gpiod_get_optional(config->dev, "wp",
> @@ -935,24 +1086,23 @@ struct nvmem_device *nvmem_register(const struct
> nvmem_config *config)
>  	INIT_LIST_HEAD(&nvmem->cells);
>  	nvmem->fixup_dt_cell_info = config->fixup_dt_cell_info;
>  
> -	ops->reg_read = config->reg_read;
> -	ops->reg_write = config->reg_write;
> +	nvmem->reg_read = config->reg_read;
> +	nvmem->reg_write = config->reg_write;
>  
>  	nvmem->owner = config->owner;
> -	if (!nvmem->owner && config->dev->driver)
> +	if (!nvmem->owner && !config->owner_is_explicit && config->dev-
> >driver)
>  		nvmem->owner = config->dev->driver->owner;
>  	nvmem->stride = config->stride ?: 1;
>  	nvmem->word_size = config->word_size ?: 1;
>  	nvmem->size = config->size;
>  	nvmem->root_only = config->root_only;
> -	nvmem->priv = config->priv;
>  	nvmem->type = config->type;
>  	nvmem->keepout = config->keepout;
>  	nvmem->nkeepout = config->nkeepout;
>  	if (config->of_node)
> -		nvmem->dev.of_node = config->of_node;
> +		nvmem->dev.of_node = of_node_get(config->of_node);
>  	else
> -		nvmem->dev.of_node = config->dev->of_node;
> +		nvmem->dev.of_node = of_node_get(config->dev->of_node);
>  
>  	switch (config->id) {
>  	case NVMEM_DEVID_NONE:
> @@ -972,7 +1122,7 @@ struct nvmem_device *nvmem_register(const struct
> nvmem_config *config)
>  		goto err_put_device;
>  
>  	nvmem->read_only = device_property_present(config->dev, "read-only")
> ||
> -			   config->read_only || !ops->reg_write;
> +			   config->read_only || !nvmem->reg_write;
>  
>  #ifdef CONFIG_NVMEM_SYSFS
>  	nvmem->dev.groups = nvmem_dev_groups;
> @@ -1010,7 +1160,7 @@ struct nvmem_device *nvmem_register(const struct
> nvmem_config *config)
>  
>  	rval = nvmem_populate_layout(nvmem);
>  	if (rval)
> -		goto err_remove_dev;
> +		goto err_unregister;
>  
>  	/* If the device has WP GPIO, default to read-only */
>  	if (nvmem->wp_gpio)
> @@ -1019,23 +1169,25 @@ struct nvmem_device *nvmem_register(const struct
> nvmem_config *config)
>  #ifdef CONFIG_NVMEM_SYSFS
>  	rval = nvmem_populate_sysfs_cells(nvmem);
>  	if (rval)
> -		goto err_destroy_layout;
> +		goto err_unregister;
>  #endif
>  
> +	nvmem->flags |= FLAG_REGISTERED;
>  	blocking_notifier_call_chain(&nvmem_notifier, NVMEM_ADD, nvmem);
>  
>  	return nvmem;
>  
> -#ifdef CONFIG_NVMEM_SYSFS
> -err_destroy_layout:
> -	nvmem_destroy_layout(nvmem);
> -#endif
> -err_remove_dev:
> -	device_del(&nvmem->dev);
> +err_unregister:
> +	nvmem_unregister(nvmem);
> +	return ERR_PTR(rval);
>  err_remove_cells:
> +	nvmem_disconnect(nvmem);
>  	nvmem_device_remove_all_cells(nvmem);
>  	nvmem_sysfs_remove_compat(nvmem);
> +	goto err_put_disconnected;
>  err_put_device:
> +	nvmem_disconnect(nvmem);
> +err_put_disconnected:
>  	put_device(&nvmem->dev);
>  
>  	return ERR_PTR(rval);
> @@ -1048,24 +1200,31 @@ static void nvmem_device_release(struct kref *kref)
>  
>  	nvmem = container_of(kref, struct nvmem_device, refcnt);
>  
> -	blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE, nvmem);
> -
> -	nvmem_sysfs_remove_compat(nvmem);
> -
> -	nvmem_device_remove_all_cells(nvmem);
> -	nvmem_destroy_layout(nvmem);
> -	device_unregister(&nvmem->dev);
> +	put_device(&nvmem->dev);
>  }
>  
>  /**
>   * nvmem_unregister() - Unregister previously registered nvmem device
>   *
>   * @nvmem: Pointer to previously registered nvmem device.
> + *
> + * Stop and drain provider callbacks before returning. Existing consumers
> keep
> + * their core-owned metadata, but further access returns -ENODEV.
>   */
>  void nvmem_unregister(struct nvmem_device *nvmem)
>  {
> -	if (nvmem)
> -		kref_put(&nvmem->refcnt, nvmem_device_release);
> +	if (!nvmem)
> +		return;
> +
> +	nvmem_disconnect(nvmem);
> +	nvmem_destroy_layout(nvmem);
> +	if (nvmem->flags & FLAG_REGISTERED)
> +		blocking_notifier_call_chain(&nvmem_notifier, NVMEM_REMOVE,
> nvmem);
> +	nvmem_sysfs_remove_compat(nvmem);
> +	nvmem_sysfs_remove_cells(nvmem);
> +	device_del(&nvmem->dev);
> +	nvmem_device_remove_all_cells(nvmem);
> +	kref_put(&nvmem->refcnt, nvmem_device_release);
>  }
>  EXPORT_SYMBOL_GPL(nvmem_unregister);
>  
> @@ -1103,17 +1262,33 @@ struct nvmem_device *devm_nvmem_register(struct device
> *dev,
>  }
>  EXPORT_SYMBOL_GPL(devm_nvmem_register);
>  
> +struct nvmem_match_data {
> +	void *data;
> +	int (*match)(struct device *dev, const void *data);
> +};
> +
> +static int nvmem_match_device(struct device *dev, const void *data)
> +{
> +	const struct nvmem_match_data *match = data;
> +	struct nvmem_device *nvmem = to_nvmem_device(dev);
> +
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected))
> +		return 0;
> +	return match->match(dev, match->data);
> +}
> +
>  static struct nvmem_device *nvmem_device_match(void *data,
>  			int (*match)(struct device *dev, const void *data))
>  {
> +	struct nvmem_match_data match_data = { .data = data, .match = match
> };
>  	struct nvmem_device *nvmem = NULL;
>  	struct device *dev;
>  
> -	scoped_guard(mutex, &nvmem_mutex) {
> -		dev = bus_find_device(&nvmem_bus_type, NULL, data, match);
> -		if (dev)
> -			nvmem = to_nvmem_device(dev);
> -	}
> +	guard(mutex)(&nvmem_mutex);
> +	dev = bus_find_device(&nvmem_bus_type, NULL, &match_data,
> nvmem_match_device);
> +	if (dev)
> +		nvmem = to_nvmem_device(dev);
>  	if (!nvmem)
>  		return ERR_PTR(-EPROBE_DEFER);
>  
> @@ -1121,8 +1296,7 @@ static struct nvmem_device *nvmem_device_match(void
> *data,
>  		dev_err(&nvmem->dev,
>  			"could not increase module refcount for cell %s\n",
>  			nvmem_dev_name(nvmem));
> -
> -		put_device(&nvmem->dev);
> +		put_device(dev);
>  		return ERR_PTR(-EINVAL);
>  	}
>  
> @@ -1337,8 +1511,10 @@ nvmem_cell_get_from_lookup(struct device *dev, const
> char *con_id)
>  				cell = ERR_PTR(-ENOENT);
>  			} else {
>  				cell = nvmem_create_cell(cell_entry, con_id,
> 0);
> -				if (IS_ERR(cell))
> +				if (IS_ERR(cell)) {
> +					nvmem_cell_entry_put(cell_entry);
>  					nvmem_device_put(nvmem);
> +				}
>  			}
>  			break;
>  		}
> @@ -1347,12 +1523,6 @@ nvmem_cell_get_from_lookup(struct device *dev, const
> char *con_id)
>  	return cell;
>  }
>  
> -static void nvmem_layout_module_put(struct nvmem_device *nvmem)
> -{
> -	if (nvmem->layout && nvmem->layout->dev.driver)
> -		module_put(nvmem->layout->dev.driver->owner);
> -}
> -
>  #if IS_ENABLED(CONFIG_OF)
>  static struct nvmem_cell_entry *
>  nvmem_find_cell_entry_by_node(struct nvmem_device *nvmem, struct device_node
> *np)
> @@ -1362,25 +1532,15 @@ nvmem_find_cell_entry_by_node(struct nvmem_device
> *nvmem, struct device_node *np
>  	guard(mutex)(&nvmem_mutex);
>  
>  	list_for_each_entry(cell, &nvmem->cells, node) {
> -		if (np == cell->np)
> +		if (np == cell->np) {
> +			kref_get(&cell->refcnt);
>  			return cell;
> +		}
>  	}
>  
>  	return NULL;
>  }
>  
> -static int nvmem_layout_module_get_optional(struct nvmem_device *nvmem)
> -{
> -	if (!nvmem->layout)
> -		return 0;
> -
> -	if (!nvmem->layout->dev.driver ||
> -	    !try_module_get(nvmem->layout->dev.driver->owner))
> -		return -EPROBE_DEFER;
> -
> -	return 0;
> -}
> -
>  /**
>   * of_nvmem_cell_get() - Get a nvmem cell from given device node and cell id
>   *
> @@ -1443,25 +1603,17 @@ struct nvmem_cell *of_nvmem_cell_get(struct
> device_node *np, const char *id)
>  		return ERR_CAST(nvmem);
>  	}
>  
> -	ret = nvmem_layout_module_get_optional(nvmem);
> -	if (ret) {
> -		of_node_put(cell_np);
> -		nvmem_device_put(nvmem);
> -		return ERR_PTR(ret);
> -	}
> -
>  	cell_entry = nvmem_find_cell_entry_by_node(nvmem, cell_np);
>  	of_node_put(cell_np);
>  	if (!cell_entry) {
> -		nvmem_layout_module_put(nvmem);
> -		ret = nvmem->layout ? -EPROBE_DEFER : -ENOENT;
> +		ret = READ_ONCE(nvmem->layout) ? -EPROBE_DEFER : -ENOENT;
>  		nvmem_device_put(nvmem);
>  		return ERR_PTR(ret);
>  	}
>  
>  	cell = nvmem_create_cell(cell_entry, id, cell_index);
>  	if (IS_ERR(cell)) {
> -		nvmem_layout_module_put(nvmem);
> +		nvmem_cell_entry_put(cell_entry);
>  		nvmem_device_put(nvmem);
>  	}
>  
> @@ -1575,8 +1727,8 @@ void nvmem_cell_put(struct nvmem_cell *cell)
>  	if (cell->id)
>  		kfree_const(cell->id);
>  
> +	nvmem_cell_entry_put(cell->entry);
>  	kfree(cell);
> -	nvmem_layout_module_put(nvmem);
>  	nvmem_device_put(nvmem);
>  }
>  EXPORT_SYMBOL_GPL(nvmem_cell_put);
> @@ -1628,6 +1780,10 @@ static int __nvmem_cell_read(struct nvmem_device
> *nvmem,
>  {
>  	int rc;
>  
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected) || READ_ONCE(cell->disconnected))
> +		return -ENODEV;
> +
>  	rc = nvmem_reg_read(nvmem, cell->offset, buf, cell->raw_len);
>  
>  	if (rc)
> @@ -1742,7 +1898,14 @@ static int __nvmem_cell_entry_write(struct
> nvmem_cell_entry *cell, void *buf, si
>  	struct nvmem_device *nvmem = cell->nvmem;
>  	int rc;
>  
> -	if (!nvmem || nvmem->read_only ||
> +	if (!nvmem)
> +		return -EINVAL;
> +
> +	guard(srcu)(&nvmem->srcu);
> +	if (READ_ONCE(nvmem->disconnected) || READ_ONCE(cell->disconnected))
> +		return -ENODEV;
> +
> +	if (nvmem->read_only ||
>  	    (cell->bit_offset == 0 && len != cell->bytes))
>  		return -EINVAL;
>  
> diff --git a/drivers/nvmem/internals.h b/drivers/nvmem/internals.h
> index 4e610deeaa7b..6c6d4a690e8f 100644
> --- a/drivers/nvmem/internals.h
> +++ b/drivers/nvmem/internals.h
> @@ -4,14 +4,10 @@
>  #define _LINUX_NVMEM_INTERNALS_H
>  
>  #include <linux/device.h>
> +#include <linux/mutex.h>
>  #include <linux/nvmem-consumer.h>
>  #include <linux/nvmem-provider.h>
> -
> -/* Hold pointers to callbacks owned by the nvmem provider module. */
> -struct nvmem_operations {
> -	nvmem_reg_read_t	reg_read;
> -	nvmem_reg_write_t	reg_write;
> -};
> +#include <linux/srcu.h>
>  
>  struct nvmem_device {
>  	struct module		*owner;
> @@ -20,6 +16,8 @@ struct nvmem_device {
>  	int			word_size;
>  	int			id;
>  	struct kref		refcnt;
> +	struct srcu_struct	srcu;
> +	bool			disconnected;
>  	size_t			size;
>  	bool			read_only;
>  	bool			root_only;
> @@ -34,12 +32,16 @@ struct nvmem_device {
>  	unsigned int		nkeepout;
>  	struct gpio_desc	*wp_gpio;
>  	struct nvmem_layout	*layout;
> -	struct nvmem_operations	*ops;
> +	nvmem_reg_read_t		reg_read;
> +	nvmem_reg_write_t	reg_write;
>  	void *priv;
> +	struct mutex		sysfs_mutex;
>  	bool			sysfs_cells_populated;
> +	struct attribute_group cells_group;
>  };
>  
>  int nvmem_add_cells_from_dt(struct nvmem_device *nvmem, struct device_node
> *np);
> +int nvmem_layout_add_cells_from_dt(struct nvmem_layout *layout, struct
> device_node *np);
>  
>  #if IS_ENABLED(CONFIG_OF)
>  int nvmem_layout_bus_register(void);
> diff --git a/drivers/nvmem/layouts.c b/drivers/nvmem/layouts.c
> index 07a34be9669c..32995c9be68d 100644
> --- a/drivers/nvmem/layouts.c
> +++ b/drivers/nvmem/layouts.c
> @@ -118,6 +118,7 @@ static int nvmem_layout_create_device(struct nvmem_device
> *nvmem,
>  
>  	ret = device_add(dev);
>  	if (ret) {
> +		nvmem->layout = NULL;
>  		put_device(dev);
>  		return ret;
>  	}
> @@ -192,6 +193,7 @@ void nvmem_destroy_layout(struct nvmem_device *nvmem)
>  	dev = &nvmem->layout->dev;
>  	of_node_clear_flag(dev->of_node, OF_POPULATED_BUS);
>  	device_unregister(dev);
> +	WRITE_ONCE(nvmem->layout, NULL);
>  }
>  
>  int nvmem_layout_bus_register(void)
> diff --git a/drivers/nvmem/layouts/fixed-layout.c
> b/drivers/nvmem/layouts/fixed-layout.c
> index 635d448b3dd2..b97f39897a75 100644
> --- a/drivers/nvmem/layouts/fixed-layout.c
> +++ b/drivers/nvmem/layouts/fixed-layout.c
> @@ -19,7 +19,7 @@ static int fixed_layout_add_cells(struct nvmem_layout
> *layout)
>  	if (!np)
>  		return -ENOENT;
>  
> -	ret = nvmem_add_cells_from_dt(layout->nvmem, np);
> +	ret = nvmem_layout_add_cells_from_dt(layout, np);
>  	of_node_put(np);
>  
>  	return ret;
> diff --git a/drivers/nvmem/layouts/onie-tlv.c b/drivers/nvmem/layouts/onie-
> tlv.c
> index 8b0f3c1b8a0e..99e7a5406b4c 100644
> --- a/drivers/nvmem/layouts/onie-tlv.c
> +++ b/drivers/nvmem/layouts/onie-tlv.c
> @@ -95,18 +95,19 @@ static nvmem_cell_post_process_t onie_tlv_read_cb(u8 type,
> u8 *buf)
>  	return NULL;
>  }
>  
> -static int onie_tlv_add_cells(struct device *dev, struct nvmem_device *nvmem,
> +static int onie_tlv_add_cells(struct nvmem_layout *layout,
>  			      size_t data_len, u8 *data)
>  {
> +	struct device *dev = &layout->dev;
>  	struct nvmem_cell_info cell = {};
> -	struct device_node *layout;
> +	struct device_node *layout_np;
>  	struct onie_tlv tlv;
>  	unsigned int hdr_len = sizeof(struct onie_tlv_hdr);
>  	unsigned int offset = 0;
>  	int ret;
>  
> -	layout = of_nvmem_layout_get_container(nvmem);
> -	if (!layout)
> +	layout_np = of_nvmem_layout_get_container(layout->nvmem);
> +	if (!layout_np)
>  		return -ENOENT;
>  
>  	while (offset < data_len) {
> @@ -123,12 +124,13 @@ static int onie_tlv_add_cells(struct device *dev, struct
> nvmem_device *nvmem,
>  
>  		cell.offset = hdr_len + offset + sizeof(tlv.type) +
> sizeof(tlv.len);
>  		cell.bytes = tlv.len;
> -		cell.np = of_get_child_by_name(layout, cell.name);
> +		cell.np = of_get_child_by_name(layout_np, cell.name);
>  		cell.read_post_process = onie_tlv_read_cb(tlv.type, data +
> offset + sizeof(tlv));
>  
> -		ret = nvmem_add_one_cell(nvmem, &cell);
> +		ret = nvmem_layout_add_cell(layout, &cell);
>  		if (ret) {
> -			of_node_put(layout);
> +			of_node_put(cell.np);
> +			of_node_put(layout_np);
>  			return ret;
>  		}
>  
> @@ -136,7 +138,7 @@ static int onie_tlv_add_cells(struct device *dev, struct
> nvmem_device *nvmem,
>  		offset += sizeof(tlv) + tlv.len;
>  	}
>  
> -	of_node_put(layout);
> +	of_node_put(layout_np);
>  
>  	return 0;
>  }
> @@ -221,7 +223,7 @@ static int onie_tlv_parse_table(struct nvmem_layout
> *layout)
>  		return -EINVAL;
>  
>  	data = table + hdr_len;
> -	ret = onie_tlv_add_cells(dev, nvmem, data_len, data);
> +	ret = onie_tlv_add_cells(layout, data_len, data);
>  	if (ret)
>  		return ret;
>  
> diff --git a/drivers/nvmem/layouts/sl28vpd.c b/drivers/nvmem/layouts/sl28vpd.c
> index e93b020b0836..1e65a0b6c61f 100644
> --- a/drivers/nvmem/layouts/sl28vpd.c
> +++ b/drivers/nvmem/layouts/sl28vpd.c
> @@ -124,8 +124,9 @@ static int sl28vpd_add_cells(struct nvmem_layout *layout)
>  		info.read_post_process = pinfo->read_post_process;
>  		info.np = of_get_child_by_name(layout_np, pinfo->name);
>  
> -		ret = nvmem_add_one_cell(nvmem, &info);
> +		ret = nvmem_layout_add_cell(layout, &info);
>  		if (ret) {
> +			of_node_put(info.np);
>  			of_node_put(layout_np);
>  			return ret;
>  		}
> diff --git a/drivers/nvmem/layouts/u-boot-env.c b/drivers/nvmem/layouts/u-
> boot-env.c
> index 33ec2350386f..83c687e43e5a 100644
> --- a/drivers/nvmem/layouts/u-boot-env.c
> +++ b/drivers/nvmem/layouts/u-boot-env.c
> @@ -49,11 +49,13 @@ static int u_boot_env_read_post_process_ethaddr(void
> *context, const char *id, i
>  	return 0;
>  }
>  
> -static int u_boot_env_parse_cells(struct device *dev, struct nvmem_device
> *nvmem, uint8_t *buf,
> +static int u_boot_env_parse_cells(struct device *dev, struct nvmem_device
> *nvmem,
> +				  struct nvmem_layout *layout, uint8_t *buf,
>  				  size_t data_offset, size_t data_len)
>  {
>  	char *data = buf + data_offset;
>  	char *var, *value, *eq;
> +	int ret;
>  
>  	for (var = data;
>  	     var < data + data_len && *var;
> @@ -78,14 +80,19 @@ static int u_boot_env_parse_cells(struct device *dev,
> struct nvmem_device *nvmem
>  			info.read_post_process =
> u_boot_env_read_post_process_ethaddr;
>  		}
>  
> -		nvmem_add_one_cell(nvmem, &info);
> +		ret = layout ? nvmem_layout_add_cell(layout, &info) :
> +			       nvmem_add_one_cell(nvmem, &info);
> +		if (ret) {
> +			of_node_put(info.np);
> +			return ret;
> +		}
>  	}
>  
>  	return 0;
>  }
>  
> -int u_boot_env_parse(struct device *dev, struct nvmem_device *nvmem,
> -		     enum u_boot_env_format format)
> +static int __u_boot_env_parse(struct device *dev, struct nvmem_device *nvmem,
> +			      struct nvmem_layout *layout, enum
> u_boot_env_format format)
>  {
>  	size_t crc32_data_offset;
>  	size_t crc32_data_len;
> @@ -156,13 +163,19 @@ int u_boot_env_parse(struct device *dev, struct
> nvmem_device *nvmem,
>  	}
>  
>  	buf[dev_size - 1] = '\0';
> -	err = u_boot_env_parse_cells(dev, nvmem, buf, data_offset, data_len);
> +	err = u_boot_env_parse_cells(dev, nvmem, layout, buf, data_offset,
> data_len);
>  
>  err_kfree:
>  	kfree(buf);
>  err_out:
>  	return err;
>  }
> +
> +int u_boot_env_parse(struct device *dev, struct nvmem_device *nvmem,
> +		     enum u_boot_env_format format)
> +{
> +	return __u_boot_env_parse(dev, nvmem, NULL, format);
> +}
>  EXPORT_SYMBOL_GPL(u_boot_env_parse);
>  
>  static int u_boot_env_add_cells(struct nvmem_layout *layout)
> @@ -172,7 +185,7 @@ static int u_boot_env_add_cells(struct nvmem_layout
> *layout)
>  
>  	format = (uintptr_t)device_get_match_data(dev);
>  
> -	return u_boot_env_parse(dev, layout->nvmem, format);
> +	return __u_boot_env_parse(dev, layout->nvmem, layout, format);
>  }
>  
>  static int u_boot_env_probe(struct nvmem_layout *layout)
> diff --git a/include/linux/nvmem-provider.h b/include/linux/nvmem-provider.h
> index 6063fe5b7784..87d871a6d5c6 100644
> --- a/include/linux/nvmem-provider.h
> +++ b/include/linux/nvmem-provider.h
> @@ -81,6 +81,8 @@ struct nvmem_cell_info {
>   * @name:	Optional name.
>   * @id:		Optional device ID used in full name. Ignored if name
> is NULL.
>   * @owner:	Pointer to exporter module. Used for refcounting.
> + * @owner_is_explicit: Use @owner even when NULL, without defaulting to the
> + *		parent driver's module.
>   * @cells:	Optional array of pre-defined NVMEM cells.
>   * @ncells:	Number of elements in cells.
>   * @add_legacy_fixed_of_cells:	Read fixed NVMEM cells from old OF syntax.
> @@ -107,12 +109,16 @@ struct nvmem_cell_info {
>   *
>   * Note: Specifying name and setting id to -1 implies a unique device
>   * whose name is provided as-is (kept unaltered).
> + *
> + * Provider callbacks and @priv must remain valid until nvmem_unregister()
> + * returns, or until a failed nvmem_register() returns.
>   */
>  struct nvmem_config {
>  	struct device		*dev;
>  	const char		*name;
>  	int			id;
>  	struct module		*owner;
> +	bool			owner_is_explicit;
>  	const struct nvmem_cell_info	*cells;
>  	int			ncells;
>  	bool			add_legacy_fixed_of_cells;
> @@ -144,7 +150,7 @@ struct nvmem_config {
>   * @nvmem:		The underlying NVMEM device
>   * @add_cells:		Will be called if a nvmem device is found which
>   *			has this layout. The function will add layout
> - *			specific cells with nvmem_add_one_cell().
> + *			specific cells with nvmem_layout_add_cell().
>   *
>   * A nvmem device can hold a well defined structure which can just be
>   * evaluated during runtime. For example a TLV list, or a list of "name=val"
> @@ -173,6 +179,8 @@ struct nvmem_device *devm_nvmem_register(struct device
> *dev,
>  
>  int nvmem_add_one_cell(struct nvmem_device *nvmem,
>  		       const struct nvmem_cell_info *info);
> +int nvmem_layout_add_cell(struct nvmem_layout *layout,
> +			  const struct nvmem_cell_info *info);
>  
>  int nvmem_layout_register(struct nvmem_layout *layout);
>  void nvmem_layout_unregister(struct nvmem_layout *layout);
> @@ -212,6 +220,12 @@ static inline int nvmem_layout_register(struct
> nvmem_layout *layout)
>  	return -EOPNOTSUPP;
>  }
>  
> +static inline int nvmem_layout_add_cell(struct nvmem_layout *layout,
> +				       const struct nvmem_cell_info *info)
> +{
> +	return -EOPNOTSUPP;
> +}
> +
>  static inline void nvmem_layout_unregister(struct nvmem_layout *layout) {}
>  
>  static inline int nvmem_add_cells_from_dt(struct nvmem_device *nvmem,

  reply	other threads:[~2026-11-17 11:26 UTC|newest]

Thread overview: 62+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-16  6:29 [PATCH v5 00/58] mtd: rawnand: retain chip and controller state across removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 01/58] nvmem: disconnect provider callbacks before unregister returns James Hilliard
2026-11-17 11:25   ` Paul Cercueil [this message]
2026-11-16  6:29 ` [PATCH v5 02/58] mtd: acquire an MTD handle from a referenced class device James Hilliard
2026-11-16  6:29 ` [PATCH v5 03/58] mtd: separate class devices from retained backing objects James Hilliard
2026-11-16  6:29 ` [PATCH v5 04/58] mtd: retain virtual concatenations across component removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 05/58] mtd: rawnand: separate hardware disconnection from cleanup James Hilliard
2026-11-16  6:29 ` [PATCH v5 06/58] mtd: rawnand: share retained chip and controller ownership James Hilliard
2026-11-16  6:29 ` [PATCH v5 07/58] mtd: rawnand: sunxi: retain chip state until the final MTD put James Hilliard
2026-11-16  6:29 ` [PATCH v5 08/58] mtd: rawnand: plat_nand: retain open-handle state on removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 09/58] mtd: rawnand: gpio: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 10/58] mtd: rawnand: stm32_fmc2: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 11/58] mtd: rawnand: denali: retain chips across controller removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 12/58] mtd: rawnand: arasan: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 13/58] mtd: rawnand: mxic: retain open-handle state on removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 14/58] mtd: rawnand: intel: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 15/58] mtd: rawnand: tegra: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 16/58] mtd: rawnand: mtk: retain chips across controller removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 17/58] mtd: rawnand: rockchip: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 18/58] mtd: rawnand: atmel: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 19/58] mtd: rawnand: orion: retain open-handle state on removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 20/58] mtd: rawnand: socrates: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 21/58] mtd: rawnand: fsl_upm: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 22/58] mtd: rawnand: pasemi: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 23/58] mtd: rawnand: ams-delta: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 24/58] mtd: rawnand: xway: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 25/58] mtd: rawnand: hisi504: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 26/58] mtd: rawnand: vf610: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 27/58] mtd: rawnand: technologic: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 28/58] mtd: rawnand: loongson: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 29/58] mtd: rawnand: ma35d1: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 30/58] mtd: rawnand: pl35x: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 31/58] mtd: rawnand: mxc: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 32/58] mtd: rawnand: fsmc: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 33/58] mtd: rawnand: gpmi: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 34/58] mtd: rawnand: omap2: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 35/58] mtd: rawnand: marvell: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 36/58] mtd: rawnand: renesas: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 37/58] mtd: rawnand: meson: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 38/58] mtd: rawnand: cadence: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 39/58] mtd: rawnand: qcom: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 40/58] mtd: rawnand: cafe: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 41/58] mtd: rawnand: brcmnand: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 42/58] mtd: rawnand: au1550nd: retain chip state across removal James Hilliard
2026-11-16  6:29 ` [PATCH v5 43/58] mtd: rawnand: sharpsl: " James Hilliard
2026-11-16  6:29 ` [PATCH v5 44/58] mtd: rawnand: davinci: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 45/58] mtd: rawnand: sh_flctl: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 46/58] mtd: rawnand: lpc32xx_slc: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 47/58] mtd: rawnand: lpc32xx_mlc: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 48/58] mtd: rawnand: ndfc: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 49/58] mtd: rawnand: txx9ndfmc: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 50/58] mtd: rawnand: ingenic: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 51/58] mtd: rawnand: mpc5121: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 52/58] mtd: rawnand: bcm47xxnflash: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 53/58] mtd: rawnand: fsl_elbc: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 54/58] mtd: rawnand: fsl_ifc: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 55/58] mtd: rawnand: r852: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 56/58] mtd: rawnand: nandsim: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 57/58] mtd: rawnand: cs553x: " James Hilliard
2026-11-16  6:30 ` [PATCH v5 58/58] mtd: rawnand: diskonchip: " James Hilliard
2026-11-16 15:29 ` [PATCH v5 00/58] mtd: rawnand: retain chip and controller " Miquel Raynal
2026-11-16 18:39   ` James Hilliard

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=9c247830067d2192acfe08080d1c5f2bb366cf1a.camel@crapouillou.net \
    --to=paul@crapouillou.net \
    --cc=gregkh@linuxfoundation.org \
    --cc=james.hilliard1@gmail.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-mtd@lists.infradead.org \
    --cc=miquel.raynal@bootlin.com \
    --cc=richard@nod.at \
    --cc=srini@kernel.org \
    --cc=tze.yee.ng@altera.com \
    --cc=vigneshr@ti.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®