public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-09-18 22:14:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

mfd: rsmu: support I2C SMBus access

Browse source 
8a3400x device implements its own reg_read and reg_write,
which only supports I2C bus access. This patch adds support
for SMBus access.

Signed-off-by: Min Li <min.li.xe@renesas.com>
Link: https://lore.kernel.org/r/LV3P220MB12021342F302AADEB6C1601CA0192@LV3P220MB1202.NAMP220.PROD.OUTLOOK.COM
Signed-off-by: Lee Jones <lee@kernel.org>
This commit is contained in:
Min Li 2024-05-01 12:32:55 -04:00 • committed by Lee Jones
parent ecbc0f273d
commit 53d3ff7be4
2 changed files with 97 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

107
drivers/mfd/rsmu_i2c.c
View file

@ -32,6 +32,8 @@
#define RSMU_SABRE_PAGE_ADDR 0x7F #define RSMU_SABRE_PAGE_ADDR 0x7F
#define RSMU_SABRE_PAGE_WINDOW 128 #define RSMU_SABRE_PAGE_WINDOW 128
typedef int (*rsmu_rw_device)(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes);
static const struct regmap_range_cfg rsmu_sabre_range_cfg[] = { static const struct regmap_range_cfg rsmu_sabre_range_cfg[] = {
{ {
.range_min = 0, .range_min = 0,
@ -54,7 +56,28 @@ static bool rsmu_sabre_volatile_reg(struct device *dev, unsigned int reg)
} }
} }
static int rsmu_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes) static int rsmu_smbus_i2c_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes)
{
struct i2c_client *client = to_i2c_client(rsmu->dev);
return i2c_smbus_write_i2c_block_data(client, reg, bytes, buf);
}
static int rsmu_smbus_i2c_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes)
{
struct i2c_client *client = to_i2c_client(rsmu->dev);
int ret;
ret = i2c_smbus_read_i2c_block_data(client, reg, bytes, buf);
if (ret == bytes)
return 0;
else if (ret < 0)
return ret;
else
return -EIO;
}
static int rsmu_i2c_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes)
{ {
struct i2c_client *client = to_i2c_client(rsmu->dev); struct i2c_client *client = to_i2c_client(rsmu->dev);
struct i2c_msg msg[2]; struct i2c_msg msg[2];
@ -84,10 +107,11 @@ static int rsmu_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes)
return 0; return 0;
} }
static int rsmu_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes) static int rsmu_i2c_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u8 bytes)
{ {
struct i2c_client *client = to_i2c_client(rsmu->dev); struct i2c_client *client = to_i2c_client(rsmu->dev);
u8 msg[RSMU_MAX_WRITE_COUNT + 1]; /* 1 Byte added for the device register */ /* we add 1 byte for device register */
u8 msg[RSMU_MAX_WRITE_COUNT + 1];
int cnt; int cnt;
if (bytes > RSMU_MAX_WRITE_COUNT) if (bytes > RSMU_MAX_WRITE_COUNT)
@ -107,7 +131,8 @@ static int rsmu_write_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes
return 0; return 0;
} }
static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg) static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg,
rsmu_rw_device rsmu_write_device)
{ {
u32 page = reg & RSMU_CM_PAGE_MASK; u32 page = reg & RSMU_CM_PAGE_MASK;
u8 buf[4]; u8 buf[4];
@ -136,35 +161,35 @@ static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg)
return err; return err;
} }
static int rsmu_reg_read(void *context, unsigned int reg, unsigned int *val) static int rsmu_i2c_reg_read(void *context, unsigned int reg, unsigned int *val)
{ {
struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context); struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context);
u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK); u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
int err; int err;
err = rsmu_write_page_register(rsmu, reg); err = rsmu_write_page_register(rsmu, reg, rsmu_i2c_write_device);
if (err) if (err)
return err; return err;
err = rsmu_read_device(rsmu, addr, (u8 *)val, 1); err = rsmu_i2c_read_device(rsmu, addr, (u8 *)val, 1);
if (err) if (err)
dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr); dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr);
return err; return err;
} }
static int rsmu_reg_write(void *context, unsigned int reg, unsigned int val) static int rsmu_i2c_reg_write(void *context, unsigned int reg, unsigned int val)
{ {
struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context); struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context);
u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK); u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
u8 data = (u8)val; u8 data = (u8)val;
int err; int err;
err = rsmu_write_page_register(rsmu, reg); err = rsmu_write_page_register(rsmu, reg, rsmu_i2c_write_device);
if (err) if (err)
return err; return err;
err = rsmu_write_device(rsmu, addr, &data, 1); err = rsmu_i2c_write_device(rsmu, addr, &data, 1);
if (err) if (err)
dev_err(rsmu->dev, dev_err(rsmu->dev,
"Failed to write offset address 0x%x\n", addr); "Failed to write offset address 0x%x\n", addr);
@ -172,12 +197,57 @@ static int rsmu_reg_write(void *context, unsigned int reg, unsigned int val)
return err; return err;
} }
static const struct regmap_config rsmu_cm_regmap_config = { static int rsmu_smbus_i2c_reg_read(void *context, unsigned int reg, unsigned int *val)
{
struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context);
u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
int err;
err = rsmu_write_page_register(rsmu, reg, rsmu_smbus_i2c_write_device);
if (err)
return err;
err = rsmu_smbus_i2c_read_device(rsmu, addr, (u8 *)val, 1);
if (err)
dev_err(rsmu->dev, "Failed to read offset address 0x%x\n", addr);
return err;
}
static int rsmu_smbus_i2c_reg_write(void *context, unsigned int reg, unsigned int val)
{
struct rsmu_ddata *rsmu = i2c_get_clientdata((struct i2c_client *)context);
u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
u8 data = (u8)val;
int err;
err = rsmu_write_page_register(rsmu, reg, rsmu_smbus_i2c_write_device);
if (err)
return err;
err = rsmu_smbus_i2c_write_device(rsmu, addr, &data, 1);
if (err)
dev_err(rsmu->dev,
"Failed to write offset address 0x%x\n", addr);
return err;
}
static const struct regmap_config rsmu_i2c_cm_regmap_config = {
.reg_bits = 32, .reg_bits = 32,
.val_bits = 8, .val_bits = 8,
.max_register = 0x20120000, .max_register = 0x20120000,
.reg_read = rsmu_reg_read, .reg_read = rsmu_i2c_reg_read,
.reg_write = rsmu_reg_write, .reg_write = rsmu_i2c_reg_write,
.cache_type = REGCACHE_NONE,
};
static const struct regmap_config rsmu_smbus_i2c_cm_regmap_config = {
.reg_bits = 32,
.val_bits = 8,
.max_register = 0x20120000,
.reg_read = rsmu_smbus_i2c_reg_read,
.reg_write = rsmu_smbus_i2c_reg_write,
.cache_type = REGCACHE_NONE, .cache_type = REGCACHE_NONE,
}; };
@ -219,7 +289,15 @@ static int rsmu_i2c_probe(struct i2c_client *client)
switch (rsmu->type) { switch (rsmu->type) {
case RSMU_CM: case RSMU_CM:
cfg = &rsmu_cm_regmap_config; if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
cfg = &rsmu_i2c_cm_regmap_config;
} else if (i2c_check_functionality(client->adapter,
I2C_FUNC_SMBUS_I2C_BLOCK)) {
cfg = &rsmu_smbus_i2c_cm_regmap_config;
} else {
dev_err(rsmu->dev, "Unsupported i2c adapter\n");
return -ENOTSUPP;
}
break; break;
case RSMU_SABRE: case RSMU_SABRE:
cfg = &rsmu_sabre_regmap_config; cfg = &rsmu_sabre_regmap_config;
@ -236,6 +314,7 @@ static int rsmu_i2c_probe(struct i2c_client *client)
rsmu->regmap = devm_regmap_init(&client->dev, NULL, client, cfg); rsmu->regmap = devm_regmap_init(&client->dev, NULL, client, cfg);
else else
rsmu->regmap = devm_regmap_init_i2c(client, cfg); rsmu->regmap = devm_regmap_init_i2c(client, cfg);
if (IS_ERR(rsmu->regmap)) { if (IS_ERR(rsmu->regmap)) {
ret = PTR_ERR(rsmu->regmap); ret = PTR_ERR(rsmu->regmap);
dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret); dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret);

8
drivers/mfd/rsmu_spi.c
View file

@ -106,10 +106,10 @@ static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg)
return 0; return 0;
page_reg = RSMU_CM_PAGE_ADDR; page_reg = RSMU_CM_PAGE_ADDR;
page = reg & RSMU_PAGE_MASK; page = reg & RSMU_PAGE_MASK;
buf[0] = (u8)(page & 0xff); buf[0] = (u8)(page & 0xFF);
buf[1] = (u8)((page >> 8) & 0xff); buf[1] = (u8)((page >> 8) & 0xFF);
buf[2] = (u8)((page >> 16) & 0xff); buf[2] = (u8)((page >> 16) & 0xFF);
buf[3] = (u8)((page >> 24) & 0xff); buf[3] = (u8)((page >> 24) & 0xFF);
bytes = 4; bytes = 4;
break; break;
case RSMU_SABRE: case RSMU_SABRE: