Merge "nvmem: core: add NVMEM_SYSFS Kconfig" (2187e28b) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/nvmem/Kconfig

+10 −0

Original line number	Diff line number	Diff line
		@@ -13,6 +13,16 @@ menuconfig NVMEM

		if NVMEM

		config NVMEM_SYSFS
		bool "/sys/bus/nvmem/devices/*/nvmem (sysfs interface)"
		depends on SYSFS
		default y
		help
		Say Y here to add a sysfs interface for NVMEM.

		This interface is mostly used by userspace applications to
		read/write directly into nvmem.

		config NVMEM_IMX_OCOTP
		tristate "i.MX6 On-Chip OTP Controller support"
		depends on SOC_IMX6 \|\| COMPILE_TEST

drivers/nvmem/Makefile

+3 −0

Original line number	Diff line number	Diff line
		@@ -5,6 +5,9 @@
		obj-$(CONFIG_NVMEM) += nvmem_core.o
		nvmem_core-y := core.o

		obj-$(CONFIG_NVMEM_SYSFS) += nvmem_sysfs.o
		nvmem_sysfs-y := nvmem-sysfs.o

		# Devices
		obj-$(CONFIG_NVMEM_IMX_OCOTP) += nvmem-imx-ocotp.o
		nvmem-imx-ocotp-y := imx-ocotp.o

drivers/nvmem/core.c

+3 −234

Original line number	Diff line number	Diff line
		@@ -25,26 +25,7 @@
		#include <linux/of.h>
		#include <linux/slab.h>

		struct nvmem_device {
		const char *name;
		struct module *owner;
		struct device dev;
		int stride;
		int word_size;
		int ncells;
		int id;
		int users;
		size_t size;
		bool read_only;
		int flags;
		struct bin_attribute eeprom;
		struct device *base_dev;
		nvmem_reg_read_t reg_read;
		nvmem_reg_write_t reg_write;
		void *priv;
		};

		#define FLAG_COMPAT BIT(0)
		#include "nvmem.h"

		struct nvmem_cell {
		const char *name;
		@@ -62,11 +43,6 @@ static DEFINE_IDA(nvmem_ida);
		static LIST_HEAD(nvmem_cells);
		static DEFINE_MUTEX(nvmem_cells_mutex);

		#ifdef CONFIG_DEBUG_LOCK_ALLOC
		static struct lock_class_key eeprom_lock_key;
		#endif

		#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
		static int nvmem_reg_read(struct nvmem_device *nvmem, unsigned int offset,
		void *val, size_t bytes)
		{
		@@ -85,168 +61,6 @@ static int nvmem_reg_write(struct nvmem_device *nvmem, unsigned int offset,
		return -EINVAL;
		}

		static ssize_t bin_attr_nvmem_read(struct file filp, struct kobject kobj,
		struct bin_attribute *attr,
		char *buf, loff_t pos, size_t count)
		{
		struct device *dev;
		struct nvmem_device *nvmem;
		int rc;

		if (attr->private)
		dev = attr->private;
		else
		dev = container_of(kobj, struct device, kobj);
		nvmem = to_nvmem_device(dev);

		/* Stop the user from reading */
		if (pos >= nvmem->size)
		return 0;

		if (count < nvmem->word_size)
		return -EINVAL;

		if (pos + count > nvmem->size)
		count = nvmem->size - pos;

		count = round_down(count, nvmem->word_size);

		rc = nvmem_reg_read(nvmem, pos, buf, count);

		if (rc)
		return rc;

		return count;
		}

		static ssize_t bin_attr_nvmem_write(struct file filp, struct kobject kobj,
		struct bin_attribute *attr,
		char *buf, loff_t pos, size_t count)
		{
		struct device *dev;
		struct nvmem_device *nvmem;
		int rc;

		if (attr->private)
		dev = attr->private;
		else
		dev = container_of(kobj, struct device, kobj);
		nvmem = to_nvmem_device(dev);

		/* Stop the user from writing */
		if (pos >= nvmem->size)
		return 0;

		if (count < nvmem->word_size)
		return -EINVAL;

		if (pos + count > nvmem->size)
		count = nvmem->size - pos;

		count = round_down(count, nvmem->word_size);

		rc = nvmem_reg_write(nvmem, pos, buf, count);

		if (rc)
		return rc;

		return count;
		}

		/* default read/write permissions */
		static struct bin_attribute bin_attr_rw_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IWUSR \| S_IRUGO,
		},
		.read = bin_attr_nvmem_read,
		.write = bin_attr_nvmem_write,
		};

		static struct bin_attribute *nvmem_bin_rw_attributes[] = {
		&bin_attr_rw_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_rw_group = {
		.bin_attrs = nvmem_bin_rw_attributes,
		};

		static const struct attribute_group *nvmem_rw_dev_groups[] = {
		&nvmem_bin_rw_group,
		NULL,
		};

		/* read only permission */
		static struct bin_attribute bin_attr_ro_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IRUGO,
		},
		.read = bin_attr_nvmem_read,
		};

		static struct bin_attribute *nvmem_bin_ro_attributes[] = {
		&bin_attr_ro_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_ro_group = {
		.bin_attrs = nvmem_bin_ro_attributes,
		};

		static const struct attribute_group *nvmem_ro_dev_groups[] = {
		&nvmem_bin_ro_group,
		NULL,
		};

		/* default read/write permissions, root only */
		static struct bin_attribute bin_attr_rw_root_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IWUSR \| S_IRUSR,
		},
		.read = bin_attr_nvmem_read,
		.write = bin_attr_nvmem_write,
		};

		static struct bin_attribute *nvmem_bin_rw_root_attributes[] = {
		&bin_attr_rw_root_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_rw_root_group = {
		.bin_attrs = nvmem_bin_rw_root_attributes,
		};

		static const struct attribute_group *nvmem_rw_root_dev_groups[] = {
		&nvmem_bin_rw_root_group,
		NULL,
		};

		/* read only permission, root only */
		static struct bin_attribute bin_attr_ro_root_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IRUSR,
		},
		.read = bin_attr_nvmem_read,
		};

		static struct bin_attribute *nvmem_bin_ro_root_attributes[] = {
		&bin_attr_ro_root_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_ro_root_group = {
		.bin_attrs = nvmem_bin_ro_root_attributes,
		};

		static const struct attribute_group *nvmem_ro_root_dev_groups[] = {
		&nvmem_bin_ro_root_group,
		NULL,
		};

		static void nvmem_release(struct device *dev)
		{
		struct nvmem_device *nvmem = to_nvmem_device(dev);
		@@ -388,43 +202,6 @@ static int nvmem_add_cells(struct nvmem_device *nvmem,
		return rval;
		}

		/*
		* nvmem_setup_compat() - Create an additional binary entry in
		* drivers sys directory, to be backwards compatible with the older
		* drivers/misc/eeprom drivers.
		*/
		static int nvmem_setup_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		int rval;

		if (!config->base_dev)
		return -EINVAL;

		if (nvmem->read_only)
		nvmem->eeprom = bin_attr_ro_root_nvmem;
		else
		nvmem->eeprom = bin_attr_rw_root_nvmem;
		nvmem->eeprom.attr.name = "eeprom";
		nvmem->eeprom.size = nvmem->size;
		#ifdef CONFIG_DEBUG_LOCK_ALLOC
		nvmem->eeprom.attr.key = &eeprom_lock_key;
		#endif
		nvmem->eeprom.private = &nvmem->dev;
		nvmem->base_dev = config->base_dev;

		rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
		if (rval) {
		dev_err(&nvmem->dev,
		"Failed to create eeprom binary file %d\n", rval);
		return rval;
		}

		nvmem->flags \|= FLAG_COMPAT;

		return 0;
		}

		/**
		* nvmem_register() - Register a nvmem device for given nvmem_config.
		* Also creates an binary entry in /sys/bus/nvmem/devices/dev-name/nvmem
		@@ -473,15 +250,7 @@ struct nvmem_device nvmem_register(const struct nvmem_config config)
		nvmem->read_only = of_property_read_bool(np, "read-only") \|
		config->read_only;

		if (config->root_only)
		nvmem->dev.groups = nvmem->read_only ?
		nvmem_ro_root_dev_groups :
		nvmem_rw_root_dev_groups;
		else
		nvmem->dev.groups = nvmem->read_only ?
		nvmem_ro_dev_groups :
		nvmem_rw_dev_groups;

		nvmem->dev.groups = nvmem_sysfs_get_groups(nvmem, config);
		device_initialize(&nvmem->dev);

		dev_dbg(&nvmem->dev, "Registering nvmem device %s\n", config->name);
		@@ -491,7 +260,7 @@ struct nvmem_device nvmem_register(const struct nvmem_config config)
		goto err_put_device;

		if (config->compat) {
		rval = nvmem_setup_compat(nvmem, config);
		rval = nvmem_sysfs_setup_compat(nvmem, config);
		if (rval)
		goto err_device_del;
		}

drivers/nvmem/nvmem-sysfs.c

0 → 100644

+230 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Copyright (c) 2019, Linaro Limited
		*/
		#include "nvmem.h"

		#ifdef CONFIG_DEBUG_LOCK_ALLOC
		static struct lock_class_key eeprom_lock_key;
		#endif

		static ssize_t bin_attr_nvmem_read(struct file filp, struct kobject kobj,
		struct bin_attribute *attr,
		char *buf, loff_t pos, size_t count)
		{
		struct device *dev;
		struct nvmem_device *nvmem;
		int rc;

		if (attr->private)
		dev = attr->private;
		else
		dev = container_of(kobj, struct device, kobj);
		nvmem = to_nvmem_device(dev);

		/* Stop the user from reading */
		if (pos >= nvmem->size)
		return 0;

		if (count < nvmem->word_size)
		return -EINVAL;

		if (pos + count > nvmem->size)
		count = nvmem->size - pos;

		count = round_down(count, nvmem->word_size);

		rc = nvmem->reg_read(nvmem->priv, pos, buf, count);

		if (rc)
		return rc;

		return count;
		}

		static ssize_t bin_attr_nvmem_write(struct file filp, struct kobject kobj,
		struct bin_attribute *attr,
		char *buf, loff_t pos, size_t count)
		{
		struct device *dev;
		struct nvmem_device *nvmem;
		int rc;

		if (attr->private)
		dev = attr->private;
		else
		dev = container_of(kobj, struct device, kobj);
		nvmem = to_nvmem_device(dev);

		/* Stop the user from writing */
		if (pos >= nvmem->size)
		return -EFBIG;

		if (count < nvmem->word_size)
		return -EINVAL;

		if (pos + count > nvmem->size)
		count = nvmem->size - pos;

		count = round_down(count, nvmem->word_size);

		rc = nvmem->reg_write(nvmem->priv, pos, buf, count);

		if (rc)
		return rc;

		return count;
		}

		/* default read/write permissions */
		static struct bin_attribute bin_attr_rw_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IWUSR \| S_IRUGO,
		},
		.read = bin_attr_nvmem_read,
		.write = bin_attr_nvmem_write,
		};

		static struct bin_attribute *nvmem_bin_rw_attributes[] = {
		&bin_attr_rw_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_rw_group = {
		.bin_attrs = nvmem_bin_rw_attributes,
		};

		static const struct attribute_group *nvmem_rw_dev_groups[] = {
		&nvmem_bin_rw_group,
		NULL,
		};

		/* read only permission */
		static struct bin_attribute bin_attr_ro_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IRUGO,
		},
		.read = bin_attr_nvmem_read,
		};

		static struct bin_attribute *nvmem_bin_ro_attributes[] = {
		&bin_attr_ro_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_ro_group = {
		.bin_attrs = nvmem_bin_ro_attributes,
		};

		static const struct attribute_group *nvmem_ro_dev_groups[] = {
		&nvmem_bin_ro_group,
		NULL,
		};

		/* default read/write permissions, root only */
		static struct bin_attribute bin_attr_rw_root_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IWUSR \| S_IRUSR,
		},
		.read = bin_attr_nvmem_read,
		.write = bin_attr_nvmem_write,
		};

		static struct bin_attribute *nvmem_bin_rw_root_attributes[] = {
		&bin_attr_rw_root_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_rw_root_group = {
		.bin_attrs = nvmem_bin_rw_root_attributes,
		};

		static const struct attribute_group *nvmem_rw_root_dev_groups[] = {
		&nvmem_bin_rw_root_group,
		NULL,
		};

		/* read only permission, root only */
		static struct bin_attribute bin_attr_ro_root_nvmem = {
		.attr = {
		.name = "nvmem",
		.mode = S_IRUSR,
		},
		.read = bin_attr_nvmem_read,
		};

		static struct bin_attribute *nvmem_bin_ro_root_attributes[] = {
		&bin_attr_ro_root_nvmem,
		NULL,
		};

		static const struct attribute_group nvmem_bin_ro_root_group = {
		.bin_attrs = nvmem_bin_ro_root_attributes,
		};

		static const struct attribute_group *nvmem_ro_root_dev_groups[] = {
		&nvmem_bin_ro_root_group,
		NULL,
		};

		const struct attribute_group **nvmem_sysfs_get_groups(
		struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		if (config->root_only)
		return nvmem->read_only ?
		nvmem_ro_root_dev_groups :
		nvmem_rw_root_dev_groups;

		return nvmem->read_only ? nvmem_ro_dev_groups : nvmem_rw_dev_groups;
		}

		/*
		* nvmem_setup_compat() - Create an additional binary entry in
		* drivers sys directory, to be backwards compatible with the older
		* drivers/misc/eeprom drivers.
		*/
		int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		int rval;

		if (!config->compat)
		return 0;

		if (!config->base_dev)
		return -EINVAL;

		if (nvmem->read_only)
		nvmem->eeprom = bin_attr_ro_root_nvmem;
		else
		nvmem->eeprom = bin_attr_rw_root_nvmem;
		nvmem->eeprom.attr.name = "eeprom";
		nvmem->eeprom.size = nvmem->size;
		#ifdef CONFIG_DEBUG_LOCK_ALLOC
		nvmem->eeprom.attr.key = &eeprom_lock_key;
		#endif
		nvmem->eeprom.private = &nvmem->dev;
		nvmem->base_dev = config->base_dev;

		rval = device_create_bin_file(nvmem->base_dev, &nvmem->eeprom);
		if (rval) {
		dev_err(&nvmem->dev,
		"Failed to create eeprom binary file %d\n", rval);
		return rval;
		}

		nvmem->flags \|= FLAG_COMPAT;

		return 0;
		}

		void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		if (config->compat)
		device_remove_bin_file(nvmem->base_dev, &nvmem->eeprom);
		}

drivers/nvmem/nvmem.h

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */

		#ifndef _DRIVERS_NVMEM_H
		#define _DRIVERS_NVMEM_H

		#include <linux/device.h>
		#include <linux/fs.h>
		#include <linux/kref.h>
		#include <linux/list.h>
		#include <linux/nvmem-consumer.h>
		#include <linux/nvmem-provider.h>

		struct nvmem_device {
		const char *name;
		struct module *owner;
		struct device dev;
		int stride;
		int word_size;
		int ncells;
		int id;
		int users;
		size_t size;
		bool read_only;
		int flags;
		struct bin_attribute eeprom;
		struct device *base_dev;
		nvmem_reg_read_t reg_read;
		nvmem_reg_write_t reg_write;
		void *priv;
		};

		#define to_nvmem_device(d) container_of(d, struct nvmem_device, dev)
		#define FLAG_COMPAT BIT(0)

		#ifdef CONFIG_NVMEM_SYSFS
		const struct attribute_group **nvmem_sysfs_get_groups(
		struct nvmem_device *nvmem,
		const struct nvmem_config *config);
		int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config);
		void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config);
		#else
		static inline const struct attribute_group **nvmem_sysfs_get_groups(
		struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		return NULL;
		}

		static inline int nvmem_sysfs_setup_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		return -ENOSYS;
		}
		static inline void nvmem_sysfs_remove_compat(struct nvmem_device *nvmem,
		const struct nvmem_config *config)
		{
		}
		#endif /* CONFIG_NVMEM_SYSFS */

		#endif /* _DRIVERS_NVMEM_H */