Difuse/u-boot
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

misc: i2c_eeprom: add size query

Browse source 
Add ability to query size of eeprom device and partitions

Signed-off-by: Robert Beckett <bob.beckett@collabora.com>
Reviewed-by: Heiko Schocher <hs@denx.de>
This commit is contained in:
Robert Beckett 2019-10-28 18:29:06 +00:00 committed by Heiko Schocher
parent 1a59cb426d
commit 033e18b47b
2 changed files with 138 additions and 19 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

145
drivers/misc/i2c_eeprom.c
View file

@ -12,6 +12,11 @@
#include <i2c.h> #include <i2c.h>
#include <i2c_eeprom.h> #include <i2c_eeprom.h>
struct i2c_eeprom_drv_data {
u32 size; /* size in bytes */
u32 pagewidth; /* pagesize = 2^pagewidth */
};
int i2c_eeprom_read(struct udevice *dev, int offset, uint8_t *buf, int size) int i2c_eeprom_read(struct udevice *dev, int offset, uint8_t *buf, int size)
{ {
const struct i2c_eeprom_ops *ops = device_get_ops(dev); const struct i2c_eeprom_ops *ops = device_get_ops(dev);
@ -32,6 +37,16 @@ int i2c_eeprom_write(struct udevice *dev, int offset, uint8_t *buf, int size)
return ops->write(dev, offset, buf, size); return ops->write(dev, offset, buf, size);
} }
int i2c_eeprom_size(struct udevice *dev)
{
const struct i2c_eeprom_ops *ops = device_get_ops(dev);
if (!ops->size)
return -ENOSYS;
return ops->size(dev);
}
static int i2c_eeprom_std_read(struct udevice *dev, int offset, uint8_t *buf, static int i2c_eeprom_std_read(struct udevice *dev, int offset, uint8_t *buf,
int size) int size)
{ {
@ -61,25 +76,39 @@ static int i2c_eeprom_std_write(struct udevice *dev, int offset,
return 0; return 0;
} }
static int i2c_eeprom_std_size(struct udevice *dev)
{
struct i2c_eeprom *priv = dev_get_priv(dev);
return priv->size;
}
static const struct i2c_eeprom_ops i2c_eeprom_std_ops = { static const struct i2c_eeprom_ops i2c_eeprom_std_ops = {
.read = i2c_eeprom_std_read, .read = i2c_eeprom_std_read,
.write = i2c_eeprom_std_write, .write = i2c_eeprom_std_write,
.size = i2c_eeprom_std_size,
}; };
static int i2c_eeprom_std_ofdata_to_platdata(struct udevice *dev) static int i2c_eeprom_std_ofdata_to_platdata(struct udevice *dev)
{ {
struct i2c_eeprom *priv = dev_get_priv(dev); struct i2c_eeprom *priv = dev_get_priv(dev);
u64 data = dev_get_driver_data(dev); struct i2c_eeprom_drv_data *data =
(struct i2c_eeprom_drv_data *)dev_get_driver_data(dev);
u32 pagesize; u32 pagesize;
u32 size;
if (dev_read_u32(dev, "pagesize", &pagesize) == 0) { if (dev_read_u32(dev, "pagesize", &pagesize) == 0) {
priv->pagesize = pagesize; priv->pagesize = pagesize;
return 0; } else {
/* 6 bit -> page size of up to 2^63 (should be sufficient) */
priv->pagewidth = data->pagewidth;
priv->pagesize = (1 << priv->pagewidth);
} }
/* 6 bit -> page size of up to 2^63 (should be sufficient) */ if (dev_read_u32(dev, "size", &size) == 0)
priv->pagewidth = data & 0x3F; priv->size = size;
priv->pagesize = (1 << priv->pagewidth); else
priv->size = data->size;
return 0; return 0;
} }
@ -120,21 +149,91 @@ static int i2c_eeprom_std_probe(struct udevice *dev)
return 0; return 0;
} }
static const struct i2c_eeprom_drv_data eeprom_data = {
.size = 0,
.pagewidth = 0,
};
static const struct i2c_eeprom_drv_data mc24aa02e48_data = {
.size = 256,
.pagewidth = 3,
};
static const struct i2c_eeprom_drv_data atmel24c01a_data = {
.size = 128,
.pagewidth = 3,
};
static const struct i2c_eeprom_drv_data atmel24c02_data = {
.size = 256,
.pagewidth = 3,
};
static const struct i2c_eeprom_drv_data atmel24c04_data = {
.size = 512,
.pagewidth = 4,
};
static const struct i2c_eeprom_drv_data atmel24c08_data = {
.size = 1024,
.pagewidth = 4,
};
static const struct i2c_eeprom_drv_data atmel24c08a_data = {
.size = 1024,
.pagewidth = 4,
};
static const struct i2c_eeprom_drv_data atmel24c16a_data = {
.size = 2048,
.pagewidth = 4,
};
static const struct i2c_eeprom_drv_data atmel24mac402_data = {
.size = 256,
.pagewidth = 4,
};
static const struct i2c_eeprom_drv_data atmel24c32_data = {
.size = 4096,
.pagewidth = 5,
};
static const struct i2c_eeprom_drv_data atmel24c64_data = {
.size = 8192,
.pagewidth = 5,
};
static const struct i2c_eeprom_drv_data atmel24c128_data = {
.size = 16384,
.pagewidth = 6,
};
static const struct i2c_eeprom_drv_data atmel24c256_data = {
.size = 32768,
.pagewidth = 6,
};
static const struct i2c_eeprom_drv_data atmel24c512_data = {
.size = 65536,
.pagewidth = 6,
};
static const struct udevice_id i2c_eeprom_std_ids[] = { static const struct udevice_id i2c_eeprom_std_ids[] = {
{ .compatible = "i2c-eeprom", .data = 0 }, { .compatible = "i2c-eeprom", (ulong)&eeprom_data },
{ .compatible = "microchip,24aa02e48", .data = 3 }, { .compatible = "microchip,24aa02e48", (ulong)&mc24aa02e48_data },
{ .compatible = "atmel,24c01a", .data = 3 }, { .compatible = "atmel,24c01a", (ulong)&atmel24c01a_data },
{ .compatible = "atmel,24c02", .data = 3 }, { .compatible = "atmel,24c02", (ulong)&atmel24c02_data },
{ .compatible = "atmel,24c04", .data = 4 }, { .compatible = "atmel,24c04", (ulong)&atmel24c04_data },
{ .compatible = "atmel,24c08", .data = 4 }, { .compatible = "atmel,24c08", (ulong)&atmel24c08_data },
{ .compatible = "atmel,24c08a", .data = 4 }, { .compatible = "atmel,24c08a", (ulong)&atmel24c08a_data },
{ .compatible = "atmel,24c16a", .data = 4 }, { .compatible = "atmel,24c16a", (ulong)&atmel24c16a_data },
{ .compatible = "atmel,24mac402", .data = 4 }, { .compatible = "atmel,24mac402", (ulong)&atmel24mac402_data },
{ .compatible = "atmel,24c32", .data = 5 }, { .compatible = "atmel,24c32", (ulong)&atmel24c32_data },
{ .compatible = "atmel,24c64", .data = 5 }, { .compatible = "atmel,24c64", (ulong)&atmel24c64_data },
{ .compatible = "atmel,24c128", .data = 6 }, { .compatible = "atmel,24c128", (ulong)&atmel24c128_data },
{ .compatible = "atmel,24c256", .data = 6 }, { .compatible = "atmel,24c256", (ulong)&atmel24c256_data },
{ .compatible = "atmel,24c512", .data = 6 }, { .compatible = "atmel,24c512", (ulong)&atmel24c512_data },
{ } { }
}; };
@ -208,9 +307,17 @@ static int i2c_eeprom_partition_write(struct udevice *dev, int offset,
size); size);
} }
static int i2c_eeprom_partition_size(struct udevice *dev)
{
struct i2c_eeprom_partition *priv = dev_get_priv(dev);
return priv->size;
}
static const struct i2c_eeprom_ops i2c_eeprom_partition_ops = { static const struct i2c_eeprom_ops i2c_eeprom_partition_ops = {
.read = i2c_eeprom_partition_read, .read = i2c_eeprom_partition_read,
.write = i2c_eeprom_partition_write, .write = i2c_eeprom_partition_write,
.size = i2c_eeprom_partition_size,
}; };
U_BOOT_DRIVER(i2c_eeprom_partition) = { U_BOOT_DRIVER(i2c_eeprom_partition) = {

12
include/i2c_eeprom.h
View file

@ -10,6 +10,7 @@ struct i2c_eeprom_ops {
int (*read)(struct udevice *dev, int offset, uint8_t *buf, int size); int (*read)(struct udevice *dev, int offset, uint8_t *buf, int size);
int (*write)(struct udevice *dev, int offset, const uint8_t *buf, int (*write)(struct udevice *dev, int offset, const uint8_t *buf,
int size); int size);
int (*size)(struct udevice *dev);
}; };
struct i2c_eeprom { struct i2c_eeprom {
@ -17,6 +18,8 @@ struct i2c_eeprom {
unsigned long pagesize; unsigned long pagesize;
/* The EEPROM's page width in bits (pagesize = 2^pagewidth) */ /* The EEPROM's page width in bits (pagesize = 2^pagewidth) */
unsigned pagewidth; unsigned pagewidth;
/* The EEPROM's capacity in bytes */
unsigned long size;
}; };
/* /*
@ -43,4 +46,13 @@ int i2c_eeprom_read(struct udevice *dev, int offset, uint8_t *buf, int size);
*/ */
int i2c_eeprom_write(struct udevice *dev, int offset, uint8_t *buf, int size); int i2c_eeprom_write(struct udevice *dev, int offset, uint8_t *buf, int size);
/*
* i2c_eeprom_size() - get size of I2C EEPROM chip
*
* @dev: Chip to query
*
* @return +ve size in bytes on success, -ve on failure
*/
int i2c_eeprom_size(struct udevice *dev);
#endif #endif