Convert exiting EEPROM drivers to NVMEM
Subsystems (7)
v5 cover Convert exiting EEPROM drivers to NVMEM
This patch set converts the old EEPROM drivers in driver/misc/eeprom to use the NVMEM framework. These drivers export there content in /sys as read only to root, since the EEPROM may contain sensitive information. So the first patch adds a flag so the NVMEM framework will create its file in /sys as root read only.
To keep backwards compatibility with these older drivers, the contents of the EEPROM must be exports in sysfs in a file called eeprom in the devices node in sys, where as the NVMEM places them under class/nvmem. So add this optional backwards compatible to the framework, again using a flag.
Then convert the at24, at25 and 93xx46 by adding regmap support, removing each drivers own /sys code and registering with the NVMEM framework.
AT24 and 93xx46 has been boot tested, at25 compile tested only.
v2:
nvmem_register() now supports a backwards compatible flag, and the Kconfig option has been removed.
v3:
Rebase on v4.5-rc1.
Add a patch to replace memory_accessor in the setup() callbacks with nvmem API calls
v4:
Rebase on v4.5-rc3
Fix lockdep key in patch #2
v5:
Remove useless test
Added Acked-bys.
Andrew Lunn (7):
nvmem: Add flag to export NVMEM to root only
nvmem: Add backwards compatibility support for older EEPROM drivers.
eeprom: at24: extend driver to plug into the NVMEM framework
eeprom: at25: Remove in kernel API for accessing the EEPROM
eeprom: at25: extend driver to plug into the NVMEM framework
eeprom: 93xx46: extend driver to plug into the NVMEM framework
misc: at24: replace memory_accessor with nvmem_device_read
arch/arm/mach-davinci/board-mityomapl138.c | 5 +- arch/arm/mach-davinci/common.c | 4 +- drivers/misc/eeprom/Kconfig | 6 ++ drivers/misc/eeprom/at24.c | 130 +++++++++++++------------ drivers/misc/eeprom/at25.c | 148 +++++++++++++---------------- drivers/misc/eeprom/eeprom_93xx46.c | 121 +++++++++++++++++------ drivers/nvmem/core.c | 141 +++++++++++++++++++++++++-- include/linux/davinci_emac.h | 4 +- include/linux/memory.h | 11 --- include/linux/nvmem-provider.h | 5 +- include/linux/platform_data/at24.h | 10 +- include/linux/spi/eeprom.h | 2 - 12 files changed, 385 insertions(+), 202 deletions(-)
Signature · 1 line
2.7.0
PATCH v5 1/7 nvmem: Add flag to export NVMEM to root only
Legacy AT24, AT25 EEPROMs are exported in sys so that only root can read the contents. The EEPROMs may contain sensitive information. Add a flag so the provide can indicate that NVMEM should also restrict access to root only.
--- drivers/nvmem/core.c | 57 ++++++++++++++++++++++++++++++++++++++++-- include/linux/nvmem-provider.h | 1 + 2 files changed, 56 insertions(+), 2 deletions(-)
drivers/nvmem/core.c +55 -2
@@ -155,6 +155,53 @@ static const struct attribute_group *nvmem_ro_dev_groups[] = { 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);
@@ -347,8 +394,14 @@ struct nvmem_device *nvmem_register(const struct nvmem_config *config) nvmem->read_only =of_property_read_bool (np,"read-only" ) | config->read_only; - nvmem->dev.groups = nvmem->read_only ? nvmem_ro_dev_groups : - nvmem_rw_dev_groups; +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;device_initialize (&nvmem->dev);
include/linux/nvmem-provider.h +1 -0
@@ -23,6 +23,7 @@ struct nvmem_config {const struct nvmem_cell_info *cells;int ncells;bool read_only; +bool root_only; };#if IS_ENABLED (CONFIG_NVMEM )
Signature · 1 line
2.7.0
PATCH v5 2/7 nvmem: Add backwards compatibility support for older EEPROM drivers.
In reply to Andrew LunnOlder drivers made an 'eeprom' file available in the /sys device directory. Have the NVMEM core provide this to retain backwards compatibility.
---
v4: Add lockdep support
--- drivers/nvmem/core.c | 84 ++++++++++++++++++++++++++++++++++++++---- include/linux/nvmem-provider.h | 4 +- 2 files changed, 79 insertions(+), 9 deletions(-)
drivers/nvmem/core.c +76 -8
@@ -38,8 +38,13 @@ struct nvmem_device {int users;size_t size;bool read_only; +int flags; +struct bin_attribute eeprom; +struct device *base_dev; }; +#define FLAG_COMPAT BIT(0) +struct nvmem_cell {const char *name;int offset;
@@ -56,16 +61,26 @@ 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 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 = container_of(kobj, struct device, kobj); -struct nvmem_device *nvmem =to_nvmem_device (dev); +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 ;
@@ -87,10 +102,16 @@ 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 = container_of(kobj, struct device, kobj); -struct nvmem_device *nvmem =to_nvmem_device (dev); + 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 ;
@@ -341,6 +362,43 @@ err: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
@@ -408,16 +466,23 @@ struct nvmem_device *nvmem_register(const struct nvmem_config *config)dev_dbg (&nvmem->dev,"Registering nvmem device %s\n" , config->name); rval =device_add (&nvmem->dev); -if (rval) { -ida_simple_remove (&nvmem_ida, nvmem->id); -kfree (nvmem); -return ERR_PTR (rval); +if (rval) + goto out; + +if (config->compat) { + rval =nvmem_setup_compat (nvmem, config); +if (rval) + goto out; }if (config->cells)nvmem_add_cells (nvmem, config);return nvmem; +out: +ida_simple_remove (&nvmem_ida, nvmem->id); +kfree (nvmem); +return ERR_PTR (rval); }EXPORT_SYMBOL_GPL (nvmem_register);
@@ -437,6 +502,9 @@ int nvmem_unregister(struct nvmem_device *nvmem) }mutex_unlock (&nvmem_mutex); +if (nvmem->flags &FLAG_COMPAT ) +device_remove_bin_file (nvmem->base_dev, &nvmem->eeprom); +nvmem_device_remove_all_cells (nvmem);device_del (&nvmem->dev);
include/linux/nvmem-provider.h +3 -1
@@ -24,6 +24,9 @@ struct nvmem_config {int ncells;bool read_only;bool root_only; +/* To be only used by old driver/misc/eeprom drivers */ +bool compat; +struct device *base_dev; };#if IS_ENABLED (CONFIG_NVMEM )
@@ -44,5 +47,4 @@ static inline int nvmem_unregister(struct nvmem_device *nvmem) }#endif /* CONFIG_NVMEM */ -#endif /* ifndef _LINUX_NVMEM_PROVIDER_H */
Signature · 1 line
2.7.0
PATCH v5 3/7 eeprom: at24: extend driver to plug into the NVMEM framework
In reply to Andrew LunnAdd a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Set the NVMEM config structure to enable backward, so that the 'eeprom' file in sys is provided by the framework.
--- drivers/misc/eeprom/Kconfig | 2 + drivers/misc/eeprom/at24.c | 121 +++++++++++++++++++++++++++++--------------- 2 files changed, 82 insertions(+), 41 deletions(-)
drivers/misc/eeprom/Kconfig +2 -0
@@ -3,6 +3,8 @@ menu "EEPROM support" config EEPROM_AT24 tristate "I2C EEPROMs / RAMs / ROMs from most vendors" depends on I2C && SYSFS + select REGMAP + select NVMEM help Enable this driver to get read/write support to most I2C EEPROMs and compatible devices like FRAMs, SRAMs, ROMs etc. After you
drivers/misc/eeprom/at24.c +80 -41
196 lines not on this page · raw message
Signature · 1 line
2.7.0
Re: [PATCHv5 3/7] eeprom: at24: extend driver to plug into the NVMEM framework
2016-02-17 21:07 GMT+01:00 Andrew Lunn <[email protected]>:
Quoted 236 lines
Add a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Set the NVMEM config structure to enable backward, so that the 'eeprom' file in sys is provided by the framework.
Signed-off-by Andrew Lunn <[email protected]>--- drivers/misc/eeprom/Kconfig | 2 + drivers/misc/eeprom/at24.c | 121 +++++++++++++++++++++++++++++--------------- 2 files changed, 82 insertions(+), 41 deletions(-)drivers/misc/eeprom/Kconfig +2
-0@@ -3,6 +3,8 @@ menu "EEPROM support" config EEPROM_AT24 tristate "I2C EEPROMs / RAMs / ROMs from most vendors" depends on I2C && SYSFS + select REGMAP + select NVMEM help Enable this driver to get read/write support to most I2C EEPROMs and compatible devices like FRAMs, SRAMs, ROMs etc. After youdrivers/misc/eeprom/at24.c +80
-42@@ -15,7 +15,6 @@#include <linux/slab.h> #include <linux/delay.h> #include <linux/mutex.h> -#include <linux/sysfs.h> #include <linux/mod_devicetable.h> #include <linux/log2.h> #include <linux/bitops.h> @@ -23,6 +22,8 @@#include <linux/of.h> #include <linux/acpi.h> #include <linux/i2c.h> +#include <linux/nvmem-provider.h> +#include <linux/regmap.h> #include <linux/platform_data/at24.h> /* @@ -64,12 +65,15 @@ struct at24_data {* but not from changes by other I2C masters. */ struct mutex lock; -struct bin_attribute bin;u8 *writebuf;unsigned write_max;unsigned num_addresses; +struct regmap_config regmap_config; +struct nvmem_config nvmem_config; +struct nvmem_device *nvmem; +/* * Some chips tie up multiple I2C addresses; dummy devices reserve * them for us, and we'll use them with SMBus calls. @@ -283,17 +287,6 @@ static ssize_t at24_read(struct at24_data *at24,return retval; } -static ssize_t at24_bin_read (struct file *filp,struct kobject *kobj, -struct bin_attribute *attr, -char *buf,loff_t off,size_t count) -{ -struct at24_data *at24; - - at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); -return at24_read (at24, buf, off, count); -} - -/* * Note that if the hardware write-protect pin is pulled high, the whole * chip is normally write protected. But there are plenty of product @@ -414,16 +407,6 @@ static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,return retval; } -static ssize_t at24_bin_write (struct file *filp,struct kobject *kobj, -struct bin_attribute *attr, -char *buf,loff_t off,size_t count) -{ -struct at24_data *at24; - - at24 = dev_get_drvdata(container_of(kobj, struct device, kobj)); -return at24_write (at24, buf, off, count); -} -/*-------------------------------------------------------------------------*/ /* @@ -450,6 +433,49 @@ static ssize_t at24_macc_write(struct memory_accessor *macc, const char *buf,/*-------------------------------------------------------------------------*/ +/* +* Provide a regmap interface, which is registered with the NVMEM +* framework +*/ +static int at24_regmap_read (void *context,const void *reg,size_t reg_size, +void *val,size_t val_size) +{ +struct at24_data *at24 = context; +off_t offset = *(u32 *)reg; +int err; + + err =at24_read (at24, val, offset, val_size); +if (err) +return err; +return 0 ; +} + +static int at24_regmap_write (void *context,const void *data,size_t count) +{ +struct at24_data *at24 = context; +const char *buf; +u32 offset; +size_t len; +int err; + +memcpy (&offset, data,sizeof (offset)); + buf = (const char *)data +sizeof (offset); + len = count -sizeof (offset); + + err =at24_write (at24, buf, offset, len); +if (err) +return err; +return 0 ; +} + +static const struct regmap_bus at24_regmap_bus = { + .read = at24_regmap_read, + .write = at24_regmap_write, + .reg_format_endian_default =REGMAP_ENDIAN_NATIVE , +}; + +/*-------------------------------------------------------------------------*/ +#ifdef CONFIG_OF static void at24_get_ofdata (struct i2c_client *client,struct at24_platform_data *chip)@@ -481,6 +507,7 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)struct at24_data *at24;int err;unsigned i, num_addresses; +struct regmap *regmap;if (client->dev.platform_data) { chip = *(struct at24_platform_data *)client->dev.platform_data;@@ -573,16 +600,6 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) at24->chip = chip; at24->num_addresses = num_addresses; -/* -* Export the EEPROM bytes through sysfs, since that's convenient. -* By default, only root should see the data (maybe passwords etc) -*/ -sysfs_bin_attr_init (&at24->bin); - at24->bin.attr.name ="eeprom" ; - at24->bin.attr.mode = chip.flags &AT24_FLAG_IRUGO ?S_IRUGO :S_IRUSR ; - at24->bin.read = at24_bin_read; - at24->bin.size = chip.byte_len; - at24->macc.read = at24_macc_read; writable = !(chip.flags &AT24_FLAG_READONLY );@@ -593,9 +610,6 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) at24->macc.write = at24_macc_write; - at24->bin.write = at24_bin_write; - at24->bin.attr.mode |=S_IWUSR ; -if (write_max > io_limit) write_max = io_limit;if (use_smbus && write_max >I2C_SMBUS_BLOCK_MAX )@@ -627,14 +641,38 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) } } - err =sysfs_create_bin_file (&client->dev.kobj, &at24->bin); -if (err) + at24->regmap_config.reg_bits =32 ; + at24->regmap_config.val_bits =8 ; + at24->regmap_config.reg_stride =1 ; + at24->regmap_config.max_register = chip.byte_len -1 ; + + regmap =devm_regmap_init (&client->dev, &at24_regmap_bus, at24, + &at24->regmap_config); +if (IS_ERR (regmap)) { +dev_err (&client->dev,"regmap init failed\n" ); + err =PTR_ERR (regmap); goto err_clients; + } + + at24->nvmem_config.name =dev_name (&client->dev); + at24->nvmem_config.dev = &client->dev; + at24->nvmem_config.read_only = !writable; + at24->nvmem_config.root_only = true; + at24->nvmem_config.owner =THIS_MODULE ; + at24->nvmem_config.compat = true; + at24->nvmem_config.base_dev = &client->dev; + + at24->nvmem =nvmem_register (&at24->nvmem_config); + +if (IS_ERR (at24->nvmem)) { + err =PTR_ERR (at24->nvmem); + goto err_clients; + }i2c_set_clientdata (client, at24); -dev_info (&client->dev,"%zu byte %s EEPROM, %s, %u bytes/write\n" , - at24->bin.size, client->name, +dev_info (&client->dev,"%u byte %s EEPROM, %s, %u bytes/write\n" , + chip.byte_len, client->name, writable ?"writable" :"read-only" , at24->write_max);if (use_smbus ==I2C_SMBUS_WORD_DATA || use_smbus ==I2C_SMBUS_BYTE_DATA ) {@@ -663,7 +701,8 @@ static int at24_remove(struct i2c_client *client)int i; at24 =i2c_get_clientdata (client); -sysfs_remove_bin_file (&client->dev.kobj, &at24->bin); + +nvmem_unregister (at24->nvmem);for (i =1 ; i < at24->num_addresses; i++)i2c_unregister_device (at24->client[i]); --
Quoted 2 lines
2.7.0
Best regards,
Bartosz Golaszewski
PATCH v5 4/7 eeprom: at25: Remove in kernel API for accessing the EEPROM
In reply to Andrew LunnThe setup() callback is not used by any in kernel code. Remove it. Any new code which requires access to the eeprom can use the NVMEM API.
--- drivers/misc/eeprom/at25.c | 26 -------------------------- include/linux/spi/eeprom.h | 2 -- 2 files changed, 28 deletions(-)
drivers/misc/eeprom/at25.c +0 -26
@@ -29,7 +29,6 @@struct at25_data {struct spi_device *spi; -struct memory_accessor mem;struct mutex lock;struct spi_eeprom chip;struct bin_attribute bin;
@@ -281,26 +280,6 @@ at25_bin_write(struct file *filp, struct kobject *kobj,/*-------------------------------------------------------------------------*/ -/* Let in-kernel code access the eeprom data. */ - -static ssize_t at25_mem_read (struct memory_accessor *mem,char *buf, -off_t offset,size_t count) -{ - struct at25_data *at25 = container_of(mem, struct at25_data, mem); - -return at25_ee_read (at25, buf, offset, count); -} - -static ssize_t at25_mem_write (struct memory_accessor *mem,const char *buf, -off_t offset,size_t count) -{ - struct at25_data *at25 = container_of(mem, struct at25_data, mem); - -return at25_ee_write (at25, buf, offset, count); -} - -/*-------------------------------------------------------------------------*/ -static int at25_fw_to_chip (struct device *dev,struct spi_eeprom *chip) {u32 val;
@@ -415,22 +394,17 @@ static int at25_probe(struct spi_device *spi) at25->bin.attr.name ="eeprom" ; at25->bin.attr.mode =S_IRUSR ; at25->bin.read = at25_bin_read; - at25->mem.read = at25_mem_read; at25->bin.size = at25->chip.byte_len;if (!(chip.flags &EE_READONLY )) { at25->bin.write = at25_bin_write; at25->bin.attr.mode |=S_IWUSR ; - at25->mem.write = at25_mem_write; } err =sysfs_create_bin_file (&spi->dev.kobj, &at25->bin);if (err)return err; -if (chip.setup) - chip.setup (&at25->mem, chip.context); - dev_info(&spi->dev, "%Zd %s %s eeprom%s, pagesize %u\n", (at25->bin.size < 1024) ? at25->bin.size
include/linux/spi/eeprom.h +0 -2
@@ -30,8 +30,6 @@ struct spi_eeprom {*/ #define EE_INSTR_BIT3_IS_ADDR 0x0010 -/* for exporting this chip's data to other kernel code */ -void (*setup)(struct memory_accessor *mem,void *context);void *context; };
Signature · 1 line
2.7.0
PATCH v5 5/7 eeprom: at25: extend driver to plug into the NVMEM framework
In reply to Andrew LunnAdd a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Enable backwards compatibility in the NVMEM config, so that the 'eeprom' file in sys is provided by the framework.
--- drivers/misc/eeprom/Kconfig | 2 + drivers/misc/eeprom/at25.c | 124 ++++++++++++++++++++++++-------------------- 2 files changed, 71 insertions(+), 55 deletions(-)
drivers/misc/eeprom/Kconfig +2 -0
@@ -32,6 +32,8 @@ config EEPROM_AT24 config EEPROM_AT25 tristate "SPI EEPROMs from most vendors" depends on SPI && SYSFS + select REGMAP + select NVMEM help Enable this driver to get read/write support to most SPI EEPROMs, after you configure the board init code to know about each eeprom
drivers/misc/eeprom/at25.c +69 -55
192 lines not on this page · raw message
Signature · 1 line
2.7.0
PATCH v5 6/7 eeprom: 93xx46: extend driver to plug into the NVMEM framework
In reply to Andrew LunnAdd a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Enable backward compatibility in the MVMEM config structure, so that the 'eeprom' file in sys is provided by the framework.
---
v5: Remove useless test.
--- drivers/misc/eeprom/Kconfig | 2 + drivers/misc/eeprom/eeprom_93xx46.c | 121 ++++++++++++++++++++++++++++-------- 2 files changed, 96 insertions(+), 27 deletions(-)
drivers/misc/eeprom/Kconfig +2 -0
@@ -78,6 +78,8 @@ config EEPROM_93CX6 config EEPROM_93XX46 tristate "Microwire EEPROM 93XX46 support" depends on SPI && SYSFS + select REGMAP + select NVMEM help Driver for the microwire EEPROM chipsets 93xx46x. The driver supports both read and write commands and also the command to
drivers/misc/eeprom/eeprom_93xx46.c +94 -27
189 lines not on this page · raw message
Signature · 1 line
2.7.0
Re: [PATCHv5 6/7] eeprom: 93xx46: extend driver to plug into the NVMEM framework
Hi Andrew,
Quoted 2 lines · Andrew Lunn
Add a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Enable backward compatibility in the MVMEM config
typo: MVMEM
Quoted 78 lines
structure, so that the 'eeprom' file in sys is provided by the framework.
Signed-off-by Andrew Lunn <[email protected]>---
v5: Remove useless test.--- drivers/misc/eeprom/Kconfig | 2 + drivers/misc/eeprom/eeprom_93xx46.c | 121 ++++++++++++++++++++++++++++-------- 2 files changed, 96 insertions(+), 27 deletions(-)drivers/misc/eeprom/Kconfig +2
-0@@ -78,6 +78,8 @@ config EEPROM_93CX6 config EEPROM_93XX46 tristate "Microwire EEPROM 93XX46 support" depends on SPI && SYSFS + select REGMAP + select NVMEM help Driver for the microwire EEPROM chipsets 93xx46x. The driver supports both read and write commands and also the command todrivers/misc/eeprom/eeprom_93xx46.c +14
-9@@ -15,7 +15,8 @@#include <linux/mutex.h> #include <linux/slab.h> #include <linux/spi/spi.h> -#include <linux/sysfs.h> +#include <linux/nvmem-provider.h> +#include <linux/regmap.h> #include <linux/eeprom_93xx46.h> #define OP_START 0x4@@ -28,25 +29,29 @@struct eeprom_93xx46_dev {struct spi_device *spi;struct eeprom_93xx46_platform_data *pdata; -struct bin_attribute bin;struct mutex lock; +struct regmap_config regmap_config; +struct nvmem_config nvmem_config; +struct nvmem_device *nvmem;int addrlen; +int size; };static ssize_t -eeprom_93xx46_bin_read (struct file *filp,struct kobject *kobj, -struct bin_attribute *bin_attr, -char *buf,loff_t off,size_t count) +eeprom_93xx46_read (struct eeprom_93xx46_dev *edev,char *buf, +unsigned off,size_t count) { -struct eeprom_93xx46_dev *edev; -struct device *dev;struct spi_message m;struct spi_transfer t[2 ];int bits, ret;u16 cmd_addr; - dev = container_of(kobj, struct device, kobj); - edev =dev_get_drvdata (dev); +if (unlikely (off >= edev->size)) +return 0 ; +if ((off + count) > edev->size) + count = edev->size - off; +if (unlikely (!count)) +return count; cmd_addr =OP_READ << edev->addrlen;
drivers/misc/eeprom/eeprom_93xx46.c eeprom_93xx46_bin_read(struct file *filp, struct kobject *kobj, · line 102
Quoted 4 lines
drivers/misc/eeprom/eeprom_93xx46.c +1
-0@@ -94,6 +99,7 @@ eeprom_93xx46_bin_read(struct file *filp, struct kobject *kobj,return ret ? : count; } +
Stray newline?
Quoted 38 lines
drivers/misc/eeprom/eeprom_93xx46.c +14
-7static int eeprom_93xx46_ew (struct eeprom_93xx46_dev *edev,int is_on) {struct spi_message m;@@ -182,16 +188,17 @@ eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev, }static ssize_t -eeprom_93xx46_bin_write (struct file *filp,struct kobject *kobj, -struct bin_attribute *bin_attr, -char *buf,loff_t off,size_t count) +eeprom_93xx46_write (struct eeprom_93xx46_dev *edev,const char *buf, +loff_t off,size_t count) { -struct eeprom_93xx46_dev *edev; -struct device *dev;int i, ret, step =1 ; - dev = container_of(kobj, struct device, kobj); - edev =dev_get_drvdata (dev); +if (unlikely (off >= edev->size)) +return -EFBIG ; +if ((off + count) > edev->size) + count = edev->size - off; +if (unlikely (!count)) +return count;/* only write even number of bytes on 16-bit devices */ if (edev->addrlen ==6 ) {@@ -228,6 +235,49 @@ eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj,return ret ? : count; } +/* +* Provide a regmap interface, which is registered with the NVMEM +* framework +*/ +static int eeprom_93xx46_regmap_read(void *context, const void *reg, + size_t reg_size, void *val,
drivers/misc/eeprom/eeprom_93xx46.c eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj, · line 253
Quoted 10 lines
drivers/misc/eeprom/eeprom_93xx46.c +10
-0+ size_t val_size) +{ +struct eeprom_93xx46_dev *eeprom_93xx46 = context; +off_t offset = *(u32 *)reg; +int err; + + err =eeprom_93xx46_read (eeprom_93xx46, val, offset, val_size); +if (err) +return err; +return 0 ;
Can be:
return eeprom_93xx46_read(eeprom_93xx46, val, offset, val_size);
Allows you to remove the 'err' variable also.
Quoted 9 lines
drivers/misc/eeprom/eeprom_93xx46.c +9
-0+} + +static int eeprom_93xx46_regmap_write (void *context,const void *data, +size_t count) +{ +struct eeprom_93xx46_dev *eeprom_93xx46 = context; +const char *buf; +u32 offset; +size_t len;
drivers/misc/eeprom/eeprom_93xx46.c eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj, · line 272
Quoted 10 lines
drivers/misc/eeprom/eeprom_93xx46.c +10
-0+int err; + +memcpy (&offset, data,sizeof (offset)); + buf = (const char *)data +sizeof (offset); + len = count -sizeof (offset); + + err =eeprom_93xx46_write (eeprom_93xx46, buf, offset, len); +if (err) +return err; +return 0 ;
Same here.
regards,
Joachim Eastwood
Re: [PATCHv5 6/7] eeprom: 93xx46: extend driver to plug into the NVMEM framework
Quoted 23 lines · Joachim Eastwood
Hi Andrew,
Quoted 6 lines · Andrew Lunn
drivers/misc/eeprom/eeprom_93xx46.c +6
-0+/* +* Provide a regmap interface, which is registered with the NVMEM +* framework +*/ +static int eeprom_93xx46_regmap_read(void *context, const void *reg, + size_t reg_size, void *val,drivers/misc/eeprom/eeprom_93xx46.c eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj, · line 253
Quoted 10 lines
drivers/misc/eeprom/eeprom_93xx46.c +10
-0+ size_t val_size) +{ +struct eeprom_93xx46_dev *eeprom_93xx46 = context; +off_t offset = *(u32 *)reg; +int err; + + err =eeprom_93xx46_read (eeprom_93xx46, val, offset, val_size); +if (err) +return err; +return 0 ;Can be:
returneeprom_93xx46_read(eeprom_93xx46, val, offset, val_size);
Quoted 1 line
Allows you to remove the 'err' variable also.
You seem to do this consistently in the other patches as well. Any particular reason?
regards,
Joachim Eastwood
Re: [PATCHv5 6/7] eeprom: 93xx46: extend driver to plug into the NVMEM framework
In reply to Joachim EastwoodQuoted 7 lines · Joachim Eastwood
Hi Andrew,
Quoted 2 lines · Andrew Lunn
Add a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Enable backward compatibility in the MVMEM config
typo: MVMEM
Thanks
Quoted 20 lines
Quoted 6 lines
drivers/misc/eeprom/eeprom_93xx46.c +6
-0+/* +* Provide a regmap interface, which is registered with the NVMEM +* framework +*/ +static int eeprom_93xx46_regmap_read(void *context, const void *reg, + size_t reg_size, void *val,drivers/misc/eeprom/eeprom_93xx46.c eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj, · line 253
Quoted 10 lines
drivers/misc/eeprom/eeprom_93xx46.c +10
-0+ size_t val_size) +{ +struct eeprom_93xx46_dev *eeprom_93xx46 = context; +off_t offset = *(u32 *)reg; +int err; + + err =eeprom_93xx46_read (eeprom_93xx46, val, offset, val_size); +if (err) +return err; +return 0 ;Can be:
returneeprom_93xx46_read(eeprom_93xx46, val, offset, val_size);
Quoted 1 line
Allows you to remove the 'err' variable also.
Nope. regmap wants a return value of 0 or error. eeprom_93xx46_read() returns how many bytes where actually read. So we either need this code here, or we change the return from eeprom_93xx46_read().
Andrew
Re: [PATCHv5 6/7] eeprom: 93xx46: extend driver to plug into the NVMEM framework
Quoted 31 lines · Andrew Lunn
Quoted 7 lines · Joachim Eastwood
Hi Andrew,
Quoted 2 lines · Andrew Lunn
Add a regmap for accessing the EEPROM, and then use that with the NVMEM framework. Enable backward compatibility in the MVMEM config
typo: MVMEM
Thanks
Quoted 20 lines
Quoted 6 lines
drivers/misc/eeprom/eeprom_93xx46.c +6
-0+/* +* Provide a regmap interface, which is registered with the NVMEM +* framework +*/ +static int eeprom_93xx46_regmap_read(void *context, const void *reg, + size_t reg_size, void *val,drivers/misc/eeprom/eeprom_93xx46.c eeprom_93xx46_bin_write(struct file *filp, struct kobject *kobj, · line 253
Quoted 10 lines
drivers/misc/eeprom/eeprom_93xx46.c +10
-0+ size_t val_size) +{ +struct eeprom_93xx46_dev *eeprom_93xx46 = context; +off_t offset = *(u32 *)reg; +int err; + + err =eeprom_93xx46_read (eeprom_93xx46, val, offset, val_size); +if (err) +return err; +return 0 ;Can be:
returneeprom_93xx46_read(eeprom_93xx46, val, offset, val_size);
Quoted 5 lines
Quoted 1 line
Allows you to remove the 'err' variable also.
Nope. regmap wants a return value of 0 or error.
eeprom_93xx46_read()returns how many bytes where actually read. So we either need this code here, or we change the return fromeeprom_93xx46_read().
ah, my bad. Sorry about that.
regards,
Joachim Eastwood
PATCH v5 7/7 misc: at24: replace memory_accessor with nvmem_device_read
In reply to Andrew LunnNow that the AT24 uses the NVMEM framework, replace the memory_accessor in the setup() callback with nvmem API calls.
--- arch/arm/mach-davinci/board-mityomapl138.c | 5 +++-- arch/arm/mach-davinci/common.c | 4 ++-- drivers/misc/eeprom/at24.c | 31 +----------------------------- include/linux/davinci_emac.h | 4 ++-- include/linux/memory.h | 11 ----------- include/linux/platform_data/at24.h | 10 +++++----- 6 files changed, 13 insertions(+), 52 deletions(-)
arch/arm/mach-davinci/board-mityomapl138.c +3 -2
@@ -115,13 +115,14 @@ static void mityomapl138_cpufreq_init(const char *partnum)static void mityomapl138_cpufreq_init (const char *partnum) { }#endif -static void read_factory_config (struct memory_accessor *a,void *context) +static void read_factory_config (struct nvmem_device *nvmem,void *context) {int ret;const char *partnum =NULL ;struct davinci_soc_info *soc_info = &davinci_soc_info; - ret = a->read (a, (char *)&factory_config,0 ,sizeof (factory_config)); + ret =nvmem_device_read (nvmem,0 ,sizeof (factory_config), + &factory_config);if (ret !=sizeof (struct factory_config )) {pr_warn ("Read Factory Config Failed: %d\n" , ret); goto bad_config;
arch/arm/mach-davinci/common.c +2 -2
@@ -28,13 +28,13 @@ EXPORT_SYMBOL(davinci_soc_info);void __iomem *davinci_intc_base;int davinci_intc_type; -void davinci_get_mac_addr (struct memory_accessor *mem_acc,void *context) +void davinci_get_mac_addr (struct nvmem_device *nvmem,void *context) {char *mac_addr = davinci_soc_info.emac_pdata->mac_addr;off_t offset = (off_t )context;/* Read MAC addr from EEPROM */ -if (mem_acc->read (mem_acc, mac_addr, offset,ETH_ALEN ) ==ETH_ALEN ) +if (nvmem_device_read (nvmem, offset,ETH_ALEN , mac_addr) ==ETH_ALEN )pr_info ("Read MAC addr from EEPROM: %pM\n" , mac_addr); }
drivers/misc/eeprom/at24.c +1 -30
@@ -56,7 +56,6 @@struct at24_data {struct at24_platform_data chip; -struct memory_accessor macc;int use_smbus;int use_smbus_write;
@@ -410,30 +409,6 @@ static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,/*-------------------------------------------------------------------------*/ /* -* This lets other kernel code access the eeprom data. For example, it -* might hold a board's Ethernet address, or board-specific calibration -* data generated on the manufacturing floor. -*/ - -static ssize_t at24_macc_read (struct memory_accessor *macc,char *buf, -off_t offset,size_t count) -{ - struct at24_data *at24 = container_of(macc, struct at24_data, macc); - -return at24_read (at24, buf, offset, count); -} - -static ssize_t at24_macc_write (struct memory_accessor *macc,const char *buf, -off_t offset,size_t count) -{ - struct at24_data *at24 = container_of(macc, struct at24_data, macc); - -return at24_write (at24, buf, offset, count); -} - -/*-------------------------------------------------------------------------*/ - -/* * Provide a regmap interface, which is registered with the NVMEM * framework */
@@ -600,16 +575,12 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id) at24->chip = chip; at24->num_addresses = num_addresses; - at24->macc.read = at24_macc_read; - writable = !(chip.flags &AT24_FLAG_READONLY );if (writable) {if (!use_smbus || use_smbus_write) {unsigned write_max = chip.page_size; - at24->macc.write = at24_macc_write; -if (write_max > io_limit) write_max = io_limit;if (use_smbus && write_max >I2C_SMBUS_BLOCK_MAX )
@@ -683,7 +654,7 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)/* export data to kernel code */ if (chip.setup) - chip.setup (&at24->macc, chip.context); + chip.setup (at24->nvmem, chip.context);return 0 ;
include/linux/davinci_emac.h +2 -2
@@ -12,7 +12,7 @@#define _LINUX_DAVINCI_EMAC_H#include <linux/if_ether.h> -#include <linux/memory.h> +#include <linux/nvmem-consumer.h> struct mdio_platform_data {unsigned long bus_freq;
@@ -46,5 +46,5 @@ enum { EMAC_VERSION_2, /* DM646x */ }; -void davinci_get_mac_addr (struct memory_accessor *mem_acc,void *context); +void davinci_get_mac_addr (struct nvmem_device *nvmem,void *context);#endif
include/linux/memory.h +0 -11
@@ -137,17 +137,6 @@ extern struct memory_block *find_memory_block(struct mem_section *);#endif /* -* 'struct memory_accessor' is a generic interface to provide -* in-kernel access to persistent memory such as i2c or SPI EEPROMs -*/ -struct memory_accessor { -ssize_t (*read)(struct memory_accessor *,char *buf,off_t offset, -size_t count); -ssize_t (*write)(struct memory_accessor *,const char *buf, -off_t offset,size_t count); -}; - -/* * Kernel text modification mutex, used for code patching. Users of this lock * can sleep. */
include/linux/platform_data/at24.h +5 -5
@@ -9,7 +9,7 @@#define _LINUX_AT24_H#include <linux/types.h> -#include <linux/memory.h> +#include <linux/nvmem-consumer.h> /** * struct at24_platform_data - data to set up at24 (generic eeprom) driver
@@ -17,7 +17,7 @@* @page_size: number of byte which can be written in one go * @flags: tunable options, check AT24_FLAG_* defines * @setup: an optional callback invoked after eeprom is probed; enables kernel -code to access eeprom via memory_accessor, see example +code to access eeprom via nvmem, see example * @context: optional parameter passed to setup() * * If you set up a custom eeprom type, please double-check the parameters.
@@ -26,13 +26,13 @@* * An example in pseudo code for a setup() callback: * -* void get_mac_addr(struct memory_accessor *mem_acc, void *context) +* void get_mac_addr(struct mvmem_device *nvmem, void *context) * { * u8 *mac_addr = ethernet_pdata->mac_addr; * off_t offset = context; * * // Read MAC addr from EEPROM -* if (mem_acc->read(mem_acc, mac_addr, offset, ETH_ALEN) == ETH_ALEN) +* if (nvmem_device_read(nvmem, offset, ETH_ALEN, mac_addr) == ETH_ALEN) * pr_info("Read MAC addr from EEPROM: %pM\n", mac_addr); * } *
@@ -48,7 +48,7 @@ struct at24_platform_data {#define AT24_FLAG_IRUGO 0x20/* sysfs-entry will be world-readable */ #define AT24_FLAG_TAKE8ADDR 0x10/* take always 8 addresses (24c00) */ -void (*setup)(struct memory_accessor *,void *context); +void (*setup)(struct nvmem_device *nvmem,void *context);void *context; };
Signature · 1 line
2.7.0