Merge tag 'char-misc-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc
Pull char / misc driver updates from Greg KH: "Here's the big char and misc driver update for 4.7-rc1. Lots of different tiny driver subsystems have updates here with new drivers and functionality. Details in the shortlog. All have been in linux-next with no reported issues for a while" * tag 'char-misc-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (125 commits) mcb: Delete num_cells variable which is not required mcb: Fixed bar number assignment for the gdd mcb: Replace ioremap and request_region with the devm version mcb: Implement bus->dev.release callback mcb: export bus information via sysfs mcb: Correctly initialize the bus's device mei: bus: call mei_cl_read_start under device lock coresight: etb10: adjust read pointer only when needed coresight: configuring ETF in FIFO mode when acting as link coresight: tmc: implementing TMC-ETF AUX space API coresight: moving struct cs_buffers to header file coresight: tmc: keep track of memory width coresight: tmc: make sysFS and Perf mode mutually exclusive coresight: tmc: dump system memory content only when needed coresight: tmc: adding mode of operation for link/sinks coresight: tmc: getting rid of multiple read access coresight: tmc: allocating memory when needed coresight: tmc: making prepare/unprepare functions generic coresight: tmc: splitting driver in ETB/ETF and ETR components coresight: tmc: cleaning up header file ...
This commit is contained in:
Linus Torvalds
@@ -3,7 +3,6 @@ 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
|
||||
@@ -32,7 +31,6 @@ 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,
|
||||
|
||||
@@ -23,7 +23,6 @@
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/nvmem-provider.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/platform_data/at24.h>
|
||||
|
||||
/*
|
||||
@@ -69,7 +68,6 @@ struct at24_data {
|
||||
unsigned write_max;
|
||||
unsigned num_addresses;
|
||||
|
||||
struct regmap_config regmap_config;
|
||||
struct nvmem_config nvmem_config;
|
||||
struct nvmem_device *nvmem;
|
||||
|
||||
@@ -251,10 +249,10 @@ static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
static ssize_t at24_read(struct at24_data *at24,
|
||||
char *buf, loff_t off, size_t count)
|
||||
static int at24_read(void *priv, unsigned int off, void *val, size_t count)
|
||||
{
|
||||
ssize_t retval = 0;
|
||||
struct at24_data *at24 = priv;
|
||||
char *buf = val;
|
||||
|
||||
if (unlikely(!count))
|
||||
return count;
|
||||
@@ -266,23 +264,21 @@ static ssize_t at24_read(struct at24_data *at24,
|
||||
mutex_lock(&at24->lock);
|
||||
|
||||
while (count) {
|
||||
ssize_t status;
|
||||
int status;
|
||||
|
||||
status = at24_eeprom_read(at24, buf, off, count);
|
||||
if (status <= 0) {
|
||||
if (retval == 0)
|
||||
retval = status;
|
||||
break;
|
||||
if (status < 0) {
|
||||
mutex_unlock(&at24->lock);
|
||||
return status;
|
||||
}
|
||||
buf += status;
|
||||
off += status;
|
||||
count -= status;
|
||||
retval += status;
|
||||
}
|
||||
|
||||
mutex_unlock(&at24->lock);
|
||||
|
||||
return retval;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -370,13 +366,13 @@ static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf,
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
|
||||
size_t count)
|
||||
static int at24_write(void *priv, unsigned int off, void *val, size_t count)
|
||||
{
|
||||
ssize_t retval = 0;
|
||||
struct at24_data *at24 = priv;
|
||||
char *buf = val;
|
||||
|
||||
if (unlikely(!count))
|
||||
return count;
|
||||
return -EINVAL;
|
||||
|
||||
/*
|
||||
* Write data to chip, protecting against concurrent updates
|
||||
@@ -385,70 +381,23 @@ static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
|
||||
mutex_lock(&at24->lock);
|
||||
|
||||
while (count) {
|
||||
ssize_t status;
|
||||
int status;
|
||||
|
||||
status = at24_eeprom_write(at24, buf, off, count);
|
||||
if (status <= 0) {
|
||||
if (retval == 0)
|
||||
retval = status;
|
||||
break;
|
||||
if (status < 0) {
|
||||
mutex_unlock(&at24->lock);
|
||||
return status;
|
||||
}
|
||||
buf += status;
|
||||
off += status;
|
||||
count -= status;
|
||||
retval += status;
|
||||
}
|
||||
|
||||
mutex_unlock(&at24->lock);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* 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)
|
||||
@@ -480,7 +429,6 @@ 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;
|
||||
@@ -607,19 +555,6 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
@@ -627,6 +562,12 @@ static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
|
||||
at24->nvmem_config.owner = THIS_MODULE;
|
||||
at24->nvmem_config.compat = true;
|
||||
at24->nvmem_config.base_dev = &client->dev;
|
||||
at24->nvmem_config.reg_read = at24_read;
|
||||
at24->nvmem_config.reg_write = at24_write;
|
||||
at24->nvmem_config.priv = at24;
|
||||
at24->nvmem_config.stride = 4;
|
||||
at24->nvmem_config.word_size = 1;
|
||||
at24->nvmem_config.size = chip.byte_len;
|
||||
|
||||
at24->nvmem = nvmem_register(&at24->nvmem_config);
|
||||
|
||||
|
||||
@@ -17,7 +17,6 @@
|
||||
#include <linux/sched.h>
|
||||
|
||||
#include <linux/nvmem-provider.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/spi/spi.h>
|
||||
#include <linux/spi/eeprom.h>
|
||||
#include <linux/property.h>
|
||||
@@ -34,7 +33,6 @@ struct at25_data {
|
||||
struct mutex lock;
|
||||
struct spi_eeprom chip;
|
||||
unsigned addrlen;
|
||||
struct regmap_config regmap_config;
|
||||
struct nvmem_config nvmem_config;
|
||||
struct nvmem_device *nvmem;
|
||||
};
|
||||
@@ -65,14 +63,11 @@ struct at25_data {
|
||||
|
||||
#define io_limit PAGE_SIZE /* bytes */
|
||||
|
||||
static ssize_t
|
||||
at25_ee_read(
|
||||
struct at25_data *at25,
|
||||
char *buf,
|
||||
unsigned offset,
|
||||
size_t count
|
||||
)
|
||||
static int at25_ee_read(void *priv, unsigned int offset,
|
||||
void *val, size_t count)
|
||||
{
|
||||
struct at25_data *at25 = priv;
|
||||
char *buf = val;
|
||||
u8 command[EE_MAXADDRLEN + 1];
|
||||
u8 *cp;
|
||||
ssize_t status;
|
||||
@@ -81,11 +76,11 @@ at25_ee_read(
|
||||
u8 instr;
|
||||
|
||||
if (unlikely(offset >= at25->chip.byte_len))
|
||||
return 0;
|
||||
return -EINVAL;
|
||||
if ((offset + count) > at25->chip.byte_len)
|
||||
count = at25->chip.byte_len - offset;
|
||||
if (unlikely(!count))
|
||||
return count;
|
||||
return -EINVAL;
|
||||
|
||||
cp = command;
|
||||
|
||||
@@ -131,28 +126,14 @@ at25_ee_read(
|
||||
count, offset, (int) status);
|
||||
|
||||
mutex_unlock(&at25->lock);
|
||||
return status ? status : count;
|
||||
return status;
|
||||
}
|
||||
|
||||
static int at25_regmap_read(void *context, const void *reg, size_t reg_size,
|
||||
void *val, size_t val_size)
|
||||
static int at25_ee_write(void *priv, unsigned int off, void *val, size_t count)
|
||||
{
|
||||
struct at25_data *at25 = context;
|
||||
off_t offset = *(u32 *)reg;
|
||||
int err;
|
||||
|
||||
err = at25_ee_read(at25, val, offset, val_size);
|
||||
if (err)
|
||||
return err;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
at25_ee_write(struct at25_data *at25, const char *buf, loff_t off,
|
||||
size_t count)
|
||||
{
|
||||
ssize_t status = 0;
|
||||
unsigned written = 0;
|
||||
struct at25_data *at25 = priv;
|
||||
const char *buf = val;
|
||||
int status = 0;
|
||||
unsigned buf_size;
|
||||
u8 *bounce;
|
||||
|
||||
@@ -161,7 +142,7 @@ at25_ee_write(struct at25_data *at25, const char *buf, loff_t off,
|
||||
if ((off + count) > at25->chip.byte_len)
|
||||
count = at25->chip.byte_len - off;
|
||||
if (unlikely(!count))
|
||||
return count;
|
||||
return -EINVAL;
|
||||
|
||||
/* Temp buffer starts with command and address */
|
||||
buf_size = at25->chip.page_size;
|
||||
@@ -256,40 +237,15 @@ at25_ee_write(struct at25_data *at25, const char *buf, loff_t off,
|
||||
off += segment;
|
||||
buf += segment;
|
||||
count -= segment;
|
||||
written += segment;
|
||||
|
||||
} while (count > 0);
|
||||
|
||||
mutex_unlock(&at25->lock);
|
||||
|
||||
kfree(bounce);
|
||||
return written ? written : status;
|
||||
return status;
|
||||
}
|
||||
|
||||
static int at25_regmap_write(void *context, const void *data, size_t count)
|
||||
{
|
||||
struct at25_data *at25 = 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 = at25_ee_write(at25, buf, offset, len);
|
||||
if (err)
|
||||
return err;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct regmap_bus at25_regmap_bus = {
|
||||
.read = at25_regmap_read,
|
||||
.write = at25_regmap_write,
|
||||
.reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
|
||||
};
|
||||
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
static int at25_fw_to_chip(struct device *dev, struct spi_eeprom *chip)
|
||||
@@ -349,7 +305,6 @@ static int at25_probe(struct spi_device *spi)
|
||||
{
|
||||
struct at25_data *at25 = NULL;
|
||||
struct spi_eeprom chip;
|
||||
struct regmap *regmap;
|
||||
int err;
|
||||
int sr;
|
||||
int addrlen;
|
||||
@@ -390,22 +345,10 @@ static int at25_probe(struct spi_device *spi)
|
||||
|
||||
mutex_init(&at25->lock);
|
||||
at25->chip = chip;
|
||||
at25->spi = spi_dev_get(spi);
|
||||
at25->spi = spi;
|
||||
spi_set_drvdata(spi, at25);
|
||||
at25->addrlen = addrlen;
|
||||
|
||||
at25->regmap_config.reg_bits = 32;
|
||||
at25->regmap_config.val_bits = 8;
|
||||
at25->regmap_config.reg_stride = 1;
|
||||
at25->regmap_config.max_register = chip.byte_len - 1;
|
||||
|
||||
regmap = devm_regmap_init(&spi->dev, &at25_regmap_bus, at25,
|
||||
&at25->regmap_config);
|
||||
if (IS_ERR(regmap)) {
|
||||
dev_err(&spi->dev, "regmap init failed\n");
|
||||
return PTR_ERR(regmap);
|
||||
}
|
||||
|
||||
at25->nvmem_config.name = dev_name(&spi->dev);
|
||||
at25->nvmem_config.dev = &spi->dev;
|
||||
at25->nvmem_config.read_only = chip.flags & EE_READONLY;
|
||||
@@ -413,6 +356,12 @@ static int at25_probe(struct spi_device *spi)
|
||||
at25->nvmem_config.owner = THIS_MODULE;
|
||||
at25->nvmem_config.compat = true;
|
||||
at25->nvmem_config.base_dev = &spi->dev;
|
||||
at25->nvmem_config.reg_read = at25_ee_read;
|
||||
at25->nvmem_config.reg_write = at25_ee_write;
|
||||
at25->nvmem_config.priv = at25;
|
||||
at25->nvmem_config.stride = 4;
|
||||
at25->nvmem_config.word_size = 1;
|
||||
at25->nvmem_config.size = chip.byte_len;
|
||||
|
||||
at25->nvmem = nvmem_register(&at25->nvmem_config);
|
||||
if (IS_ERR(at25->nvmem))
|
||||
|
||||
@@ -20,7 +20,6 @@
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spi/spi.h>
|
||||
#include <linux/nvmem-provider.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/eeprom_93xx46.h>
|
||||
|
||||
#define OP_START 0x4
|
||||
@@ -43,7 +42,6 @@ struct eeprom_93xx46_dev {
|
||||
struct spi_device *spi;
|
||||
struct eeprom_93xx46_platform_data *pdata;
|
||||
struct mutex lock;
|
||||
struct regmap_config regmap_config;
|
||||
struct nvmem_config nvmem_config;
|
||||
struct nvmem_device *nvmem;
|
||||
int addrlen;
|
||||
@@ -60,11 +58,12 @@ static inline bool has_quirk_instruction_length(struct eeprom_93xx46_dev *edev)
|
||||
return edev->pdata->quirks & EEPROM_93XX46_QUIRK_INSTRUCTION_LENGTH;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
eeprom_93xx46_read(struct eeprom_93xx46_dev *edev, char *buf,
|
||||
unsigned off, size_t count)
|
||||
static int eeprom_93xx46_read(void *priv, unsigned int off,
|
||||
void *val, size_t count)
|
||||
{
|
||||
ssize_t ret = 0;
|
||||
struct eeprom_93xx46_dev *edev = priv;
|
||||
char *buf = val;
|
||||
int err = 0;
|
||||
|
||||
if (unlikely(off >= edev->size))
|
||||
return 0;
|
||||
@@ -84,7 +83,6 @@ eeprom_93xx46_read(struct eeprom_93xx46_dev *edev, char *buf,
|
||||
u16 cmd_addr = OP_READ << edev->addrlen;
|
||||
size_t nbytes = count;
|
||||
int bits;
|
||||
int err;
|
||||
|
||||
if (edev->addrlen == 7) {
|
||||
cmd_addr |= off & 0x7f;
|
||||
@@ -120,21 +118,20 @@ eeprom_93xx46_read(struct eeprom_93xx46_dev *edev, char *buf,
|
||||
if (err) {
|
||||
dev_err(&edev->spi->dev, "read %zu bytes at %d: err. %d\n",
|
||||
nbytes, (int)off, err);
|
||||
ret = err;
|
||||
break;
|
||||
}
|
||||
|
||||
buf += nbytes;
|
||||
off += nbytes;
|
||||
count -= nbytes;
|
||||
ret += nbytes;
|
||||
}
|
||||
|
||||
if (edev->pdata->finish)
|
||||
edev->pdata->finish(edev);
|
||||
|
||||
mutex_unlock(&edev->lock);
|
||||
return ret;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static int eeprom_93xx46_ew(struct eeprom_93xx46_dev *edev, int is_on)
|
||||
@@ -230,10 +227,11 @@ eeprom_93xx46_write_word(struct eeprom_93xx46_dev *edev,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
eeprom_93xx46_write(struct eeprom_93xx46_dev *edev, const char *buf,
|
||||
loff_t off, size_t count)
|
||||
static int eeprom_93xx46_write(void *priv, unsigned int off,
|
||||
void *val, size_t count)
|
||||
{
|
||||
struct eeprom_93xx46_dev *edev = priv;
|
||||
char *buf = val;
|
||||
int i, ret, step = 1;
|
||||
|
||||
if (unlikely(off >= edev->size))
|
||||
@@ -275,52 +273,9 @@ eeprom_93xx46_write(struct eeprom_93xx46_dev *edev, const char *buf,
|
||||
|
||||
/* erase/write disable */
|
||||
eeprom_93xx46_ew(edev, 0);
|
||||
return ret ? : count;
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* 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,
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
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;
|
||||
}
|
||||
|
||||
static const struct regmap_bus eeprom_93xx46_regmap_bus = {
|
||||
.read = eeprom_93xx46_regmap_read,
|
||||
.write = eeprom_93xx46_regmap_write,
|
||||
.reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
|
||||
};
|
||||
|
||||
static int eeprom_93xx46_eral(struct eeprom_93xx46_dev *edev)
|
||||
{
|
||||
struct eeprom_93xx46_platform_data *pd = edev->pdata;
|
||||
@@ -480,7 +435,6 @@ static int eeprom_93xx46_probe(struct spi_device *spi)
|
||||
{
|
||||
struct eeprom_93xx46_platform_data *pd;
|
||||
struct eeprom_93xx46_dev *edev;
|
||||
struct regmap *regmap;
|
||||
int err;
|
||||
|
||||
if (spi->dev.of_node) {
|
||||
@@ -511,24 +465,10 @@ static int eeprom_93xx46_probe(struct spi_device *spi)
|
||||
|
||||
mutex_init(&edev->lock);
|
||||
|
||||
edev->spi = spi_dev_get(spi);
|
||||
edev->spi = spi;
|
||||
edev->pdata = pd;
|
||||
|
||||
edev->size = 128;
|
||||
|
||||
edev->regmap_config.reg_bits = 32;
|
||||
edev->regmap_config.val_bits = 8;
|
||||
edev->regmap_config.reg_stride = 1;
|
||||
edev->regmap_config.max_register = edev->size - 1;
|
||||
|
||||
regmap = devm_regmap_init(&spi->dev, &eeprom_93xx46_regmap_bus, edev,
|
||||
&edev->regmap_config);
|
||||
if (IS_ERR(regmap)) {
|
||||
dev_err(&spi->dev, "regmap init failed\n");
|
||||
err = PTR_ERR(regmap);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
edev->nvmem_config.name = dev_name(&spi->dev);
|
||||
edev->nvmem_config.dev = &spi->dev;
|
||||
edev->nvmem_config.read_only = pd->flags & EE_READONLY;
|
||||
@@ -536,6 +476,12 @@ static int eeprom_93xx46_probe(struct spi_device *spi)
|
||||
edev->nvmem_config.owner = THIS_MODULE;
|
||||
edev->nvmem_config.compat = true;
|
||||
edev->nvmem_config.base_dev = &spi->dev;
|
||||
edev->nvmem_config.reg_read = eeprom_93xx46_read;
|
||||
edev->nvmem_config.reg_write = eeprom_93xx46_write;
|
||||
edev->nvmem_config.priv = edev;
|
||||
edev->nvmem_config.stride = 4;
|
||||
edev->nvmem_config.word_size = 1;
|
||||
edev->nvmem_config.size = edev->size;
|
||||
|
||||
edev->nvmem = nvmem_register(&edev->nvmem_config);
|
||||
if (IS_ERR(edev->nvmem)) {
|
||||
|
||||
مرجع در شماره جدید
Block a user