mfd: rsmu: support I2C SMBus access

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>

diff --git a/drivers/mfd/rsmu_i2c.c b/drivers/mfd/rsmu_i2c.c
index 5711e512b6a2f3bb10d3aa1fa107938f1426958a..cba64f107a2fd1e863e92581cdfde44176607ece 100644 (file)
--- a/drivers/mfd/rsmu_i2c.c
+++ b/drivers/mfd/rsmu_i2c.c
@@ -32,6 +32,8 @@
 #define        RSMU_SABRE_PAGE_ADDR            0x7F
 #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[] = {
        {
                .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_msg msg[2];
@@ -84,10 +107,11 @@ static int rsmu_read_device(struct rsmu_ddata *rsmu, u8 reg, u8 *buf, u16 bytes)
        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);
-       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;
 
        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;
 }
 
-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;
        u8 buf[4];
@@ -136,35 +161,35 @@ static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg)
        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);
        u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
        int err;
 
-       err = rsmu_write_page_register(rsmu, reg);
+       err = rsmu_write_page_register(rsmu, reg, rsmu_i2c_write_device);
        if (err)
                return err;
 
-       err = rsmu_read_device(rsmu, addr, (u8 *)val, 1);
+       err = rsmu_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_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);
        u8 addr = (u8)(reg & RSMU_CM_ADDRESS_MASK);
        u8 data = (u8)val;
        int err;
 
-       err = rsmu_write_page_register(rsmu, reg);
+       err = rsmu_write_page_register(rsmu, reg, rsmu_i2c_write_device);
        if (err)
                return err;
 
-       err = rsmu_write_device(rsmu, addr, &data, 1);
+       err = rsmu_i2c_write_device(rsmu, addr, &data, 1);
        if (err)
                dev_err(rsmu->dev,
                        "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;
 }
 
-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,
        .val_bits = 8,
        .max_register = 0x20120000,
-       .reg_read = rsmu_reg_read,
-       .reg_write = rsmu_reg_write,
+       .reg_read = rsmu_i2c_reg_read,
+       .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,
 };
 
@@ -219,7 +289,15 @@ static int rsmu_i2c_probe(struct i2c_client *client)
 
        switch (rsmu->type) {
        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;
        case RSMU_SABRE:
                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);
        else
                rsmu->regmap = devm_regmap_init_i2c(client, cfg);
+
        if (IS_ERR(rsmu->regmap)) {
                ret = PTR_ERR(rsmu->regmap);
                dev_err(rsmu->dev, "Failed to allocate register map: %d\n", ret);

diff --git a/drivers/mfd/rsmu_spi.c b/drivers/mfd/rsmu_spi.c
index ca0a1202c3ce1fb13ec31ce478f3c76e7073d36d..39d9be1e141fb67f3529a7332d905e6efe3986c3 100644 (file)
--- a/drivers/mfd/rsmu_spi.c
+++ b/drivers/mfd/rsmu_spi.c
@@ -106,10 +106,10 @@ static int rsmu_write_page_register(struct rsmu_ddata *rsmu, u32 reg)
                        return 0;
                page_reg = RSMU_CM_PAGE_ADDR;
                page = reg & RSMU_PAGE_MASK;
-               buf[0] = (u8)(page & 0xff);
-               buf[1] = (u8)((page >> 8) & 0xff);
-               buf[2] = (u8)((page >> 16) & 0xff);
-               buf[3] = (u8)((page >> 24) & 0xff);
+               buf[0] = (u8)(page & 0xFF);
+               buf[1] = (u8)((page >> 8) & 0xFF);
+               buf[2] = (u8)((page >> 16) & 0xFF);
+               buf[3] = (u8)((page >> 24) & 0xFF);
                bytes = 4;
                break;
        case RSMU_SABRE: