bq27xxx_battery partial series

From: Matt Ranostay <[email protected]>

Declare bus.write/read_bulk/write_bulk().
Add I2C write/read_bulk/write_bulk() to implement the above.
Add bq27xxx_write/read_block/write_block() helper functions to call the above.

Signed-off-by Matt Ranostay <[email protected]>

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 58 ++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 82 +++++++++++++++++++++++++++++-
 include/linux/power/bq27xxx_battery.h      |  3 ++
 3 files changed, 140 insertions(+), 3 deletions(-)

drivers/power/supply/bq27xxx_battery.c +7 -2

index 398801a..e3472c3 100644
@@ -794,11 +794,65 @@ MODULE_PARM_DESC(poll_interval,
 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
 			       bool single)
 {
-	/* Reports EINVAL for invalid/missing registers */
+	int ret;
+
 	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
 		return -EINVAL;
 
-	return di->bus.read(di, di->regs[reg_index], single);
+	ret = di->bus.read(di, di->regs[reg_index], single);
+	if (ret < 0)
+		dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n",
+		        di->regs[reg_index], reg_index);
+

drivers/power/supply/bq27xxx_battery.c +39 -0

+
+	ret = di->bus.write(di, di->regs[reg_index], value, single);
+	if (ret < 0)
+		dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n",
+		        di->regs[reg_index], reg_index);
+
+	return ret;
+}
+
+static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index,
+				     u8 *data, int len)
+{
+	int ret;
+
+	if (!di || di->regs[reg_index] == INVALID_REG_ADDR || !di->bus.read_bulk)
+		return -EINVAL;
+
+	ret = di->bus.read_bulk(di, di->regs[reg_index], data, len);
+	if (ret < 0)
+		dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n",
+		        di->regs[reg_index], reg_index);
+
+	return ret;
+}
+
+static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index,
+				      u8 *data, int len)
+{
+	int ret;
+
+	if (!di || di->regs[reg_index] == INVALID_REG_ADDR || !di->bus.write_bulk)
+		return -EINVAL;
+
+	ret = di->bus.write_bulk(di, di->regs[reg_index], data, len);
+	if (ret < 0)
+		dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n",
+		        di->regs[reg_index], reg_index);
+
+	return ret;
 }
 
 /*

drivers/power/supply/bq27xxx_battery_i2c.c +81 -1

index c68fbc3..a597221 100644
@@ -38,7 +38,7 @@ static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
 {
 	struct i2c_client *client = to_i2c_client(di->dev);
 	struct i2c_msg msg[2];
-	unsigned char data[2];
+	u8 data[2];
 	int ret;
 
 	if (!client->adapter)

@@ -68,6 +68,82 @@ static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
 	return ret;
 }
 
+static int bq27xxx_battery_i2c_write(struct bq27xxx_device_info *di, u8 reg,
+				     int value, bool single)
+{
+	struct i2c_client *client = to_i2c_client(di->dev);
+	struct i2c_msg msg;
+	u8 data[4];
+	int ret;
+
+	if (!client->adapter)
+		return -ENODEV;
+
+	data[0] = reg;
+	if (single) {
+		data[1] = (u8) value;
+		msg.len = 2;
+	} else {
+		put_unaligned_le16(value, &data[1]);
+		msg.len = 3;
+	}
+
+	msg.buf = data;
+	msg.addr = client->addr;
+	msg.flags = 0;
+
+	ret = i2c_transfer(client->adapter, &msg, 1);
+	if (ret < 0)
+		return ret;
+	if (ret != 1)
+		return -EINVAL;
+	return 0;
+}
+
+static int bq27xxx_battery_i2c_bulk_read(struct bq27xxx_device_info *di, u8 reg,
+					 u8 *data, int len)
+{
+	struct i2c_client *client = to_i2c_client(di->dev);
+	int ret;
+
+	if (!client->adapter)
+		return -ENODEV;
+
+	ret = i2c_smbus_read_i2c_block_data(client, reg, len, data);
+	if (ret < 0)
+		return ret;
+	if (ret != len)
+		return -EINVAL;
+	return 0;
+}
+
+static int bq27xxx_battery_i2c_bulk_write(struct bq27xxx_device_info *di,
+					  u8 reg, u8 *data, int len)
+{
+	struct i2c_client *client = to_i2c_client(di->dev);
+	struct i2c_msg msg;
+	u8 buf[33];
+	int ret;
+
+	if (!client->adapter)
+		return -ENODEV;
+
+	buf[0] = reg;
+	memcpy(&buf[1], data, len);
+
+	msg.buf = buf;
+	msg.addr = client->addr;
+	msg.flags = 0;
+	msg.len = len + 1;
+
+	ret = i2c_transfer(client->adapter, &msg, 1);
+	if (ret < 0)
+		return ret;
+	if (ret != 1)
+		return -EINVAL;
+	return 0;
+}
+
 static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
 				     const struct i2c_device_id *id)
 {

@@ -95,7 +171,11 @@ static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
 	di->dev = &client->dev;
 	di->chip = id->driver_data;
 	di->name = name;
+
 	di->bus.read = bq27xxx_battery_i2c_read;
+	di->bus.write = bq27xxx_battery_i2c_write;
+	di->bus.read_bulk = bq27xxx_battery_i2c_bulk_read;
+	di->bus.write_bulk = bq27xxx_battery_i2c_bulk_write;
 
 	ret = bq27xxx_battery_setup(di);
 	if (ret)

include/linux/power/bq27xxx_battery.h +3 -0

index b312bce..c3369fa 100644
@@ -40,6 +40,9 @@ struct bq27xxx_platform_data {
 struct bq27xxx_device_info;
 struct bq27xxx_access_methods {
 	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
+	int (*write)(struct bq27xxx_device_info *di, u8 reg, int value, bool single);
+	int (*read_bulk)(struct bq27xxx_device_info *di, u8 reg, u8 *data, int len);
+	int (*write_bulk)(struct bq27xxx_device_info *di, u8 reg, u8 *data, int len);
 };
 
 struct bq27xxx_reg_cache {

Quoted 39 lines · Liam Breck

From: Matt Ranostay <[email protected]>

Declare bus.write/read_bulk/write_bulk().
Add I2C write/read_bulk/write_bulk() to implement the above.
Add bq27xxx_write/read_block/write_block() helper functions to call the above.

Signed-off-by Matt Ranostay <[email protected]>

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 58 ++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 82 +++++++++++++++++++++++++++++-
 include/linux/power/bq27xxx_battery.h      |  3 ++
 3 files changed, 140 insertions(+), 3 deletions(-)

drivers/power/supply/bq27xxx_battery.c +12 -2

index 398801a..e3472c3 100644
@@ -794,11 +794,65 @@ MODULE_PARM_DESC(poll_interval,
 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
                             bool single)
 {
-     /* Reports EINVAL for invalid/missing registers */
+     int ret;
+
      if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
              return -EINVAL;
 
-     return di->bus.read(di, di->regs[reg_index], single);
+     ret = di->bus.read(di, di->regs[reg_index], single);
+     if (ret < 0)
+             dev_dbg(di->dev, "failed to read register 0x%02x (index %d)\n",
+                     di->regs[reg_index], reg_index);
+
+     return ret;
+}
+
+static inline int bq27xxx_write(struct bq27xxx_device_info *di, int reg_index,
+                             u16 value, bool single)

drivers/power/supply/bq27xxx_battery.c MODULE_PARM_DESC(poll_interval, · line 816

Quoted 5 lines

drivers/power/supply/bq27xxx_battery.c +5 -0

+{
+     int ret;
+
+     if (!di || di->regs[reg_index] == INVALID_REG_ADDR || !di->bus.write)
+             return -EINVAL;

Perhaps (!di || !di->bus.write) should return "not implemented" or some similar separate error code.

Otherwise,

Acked-by Andrew F. Davis <[email protected]>

Quoted 165 lines

drivers/power/supply/bq27xxx_battery.c +39 -0

+
+     ret = di->bus.write(di, di->regs[reg_index], value, single);
+     if (ret < 0)
+             dev_dbg(di->dev, "failed to write register 0x%02x (index %d)\n",
+                     di->regs[reg_index], reg_index);
+
+     return ret;
+}
+
+static inline int bq27xxx_read_block(struct bq27xxx_device_info *di, int reg_index,
+                                  u8 *data, int len)
+{
+     int ret;
+
+     if (!di || di->regs[reg_index] == INVALID_REG_ADDR || !di->bus.read_bulk)
+             return -EINVAL;
+
+     ret = di->bus.read_bulk(di, di->regs[reg_index], data, len);
+     if (ret < 0)
+             dev_dbg(di->dev, "failed to read_bulk register 0x%02x (index %d)\n",
+                     di->regs[reg_index], reg_index);
+
+     return ret;
+}
+
+static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_index,
+                                   u8 *data, int len)
+{
+     int ret;
+
+     if (!di || di->regs[reg_index] == INVALID_REG_ADDR || !di->bus.write_bulk)
+             return -EINVAL;
+
+     ret = di->bus.write_bulk(di, di->regs[reg_index], data, len);
+     if (ret < 0)
+             dev_dbg(di->dev, "failed to write_bulk register 0x%02x (index %d)\n",
+                     di->regs[reg_index], reg_index);
+
+     return ret;
 }
 
 /*

drivers/power/supply/bq27xxx_battery_i2c.c +81 -1

index c68fbc3..a597221 100644
@@ -38,7 +38,7 @@ static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
 {
      struct i2c_client *client = to_i2c_client(di->dev);
      struct i2c_msg msg[2];
-     unsigned char data[2];
+     u8 data[2];
      int ret;
 
      if (!client->adapter)

@@ -68,6 +68,82 @@ static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
      return ret;
 }
 
+static int bq27xxx_battery_i2c_write(struct bq27xxx_device_info *di, u8 reg,
+                                  int value, bool single)
+{
+     struct i2c_client *client = to_i2c_client(di->dev);
+     struct i2c_msg msg;
+     u8 data[4];
+     int ret;
+
+     if (!client->adapter)
+             return -ENODEV;
+
+     data[0] = reg;
+     if (single) {
+             data[1] = (u8) value;
+             msg.len = 2;
+     } else {
+             put_unaligned_le16(value, &data[1]);
+             msg.len = 3;
+     }
+
+     msg.buf = data;
+     msg.addr = client->addr;
+     msg.flags = 0;
+
+     ret = i2c_transfer(client->adapter, &msg, 1);
+     if (ret < 0)
+             return ret;
+     if (ret != 1)
+             return -EINVAL;
+     return 0;
+}
+
+static int bq27xxx_battery_i2c_bulk_read(struct bq27xxx_device_info *di, u8 reg,
+                                      u8 *data, int len)
+{
+     struct i2c_client *client = to_i2c_client(di->dev);
+     int ret;
+
+     if (!client->adapter)
+             return -ENODEV;
+
+     ret = i2c_smbus_read_i2c_block_data(client, reg, len, data);
+     if (ret < 0)
+             return ret;
+     if (ret != len)
+             return -EINVAL;
+     return 0;
+}
+
+static int bq27xxx_battery_i2c_bulk_write(struct bq27xxx_device_info *di,
+                                       u8 reg, u8 *data, int len)
+{
+     struct i2c_client *client = to_i2c_client(di->dev);
+     struct i2c_msg msg;
+     u8 buf[33];
+     int ret;
+
+     if (!client->adapter)
+             return -ENODEV;
+
+     buf[0] = reg;
+     memcpy(&buf[1], data, len);
+
+     msg.buf = buf;
+     msg.addr = client->addr;
+     msg.flags = 0;
+     msg.len = len + 1;
+
+     ret = i2c_transfer(client->adapter, &msg, 1);
+     if (ret < 0)
+             return ret;
+     if (ret != 1)
+             return -EINVAL;
+     return 0;
+}
+
 static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
                                   const struct i2c_device_id *id)
 {

@@ -95,7 +171,11 @@ static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
      di->dev = &client->dev;
      di->chip = id->driver_data;
      di->name = name;
+
      di->bus.read = bq27xxx_battery_i2c_read;
+     di->bus.write = bq27xxx_battery_i2c_write;
+     di->bus.read_bulk = bq27xxx_battery_i2c_bulk_read;
+     di->bus.write_bulk = bq27xxx_battery_i2c_bulk_write;
 
      ret = bq27xxx_battery_setup(di);
      if (ret)

include/linux/power/bq27xxx_battery.h +3 -0

index b312bce..c3369fa 100644
@@ -40,6 +40,9 @@ struct bq27xxx_platform_data {
 struct bq27xxx_device_info;
 struct bq27xxx_access_methods {
      int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
+     int (*write)(struct bq27xxx_device_info *di, u8 reg, int value, bool single);
+     int (*read_bulk)(struct bq27xxx_device_info *di, u8 reg, u8 *data, int len);
+     int (*write_bulk)(struct bq27xxx_device_info *di, u8 reg, u8 *data, int len);
 };
 
 struct bq27xxx_reg_cache {

From: Liam Breck <[email protected]>

Add the following to enable read/write of chip data memory (DM) RAM/NVM/flash:
bq27xxx_battery_seal()
bq27xxx_battery_unseal()
bq27xxx_battery_set_cfgupdate()
bq27xxx_battery_read_dm_block() bq27xxx_battery_write_dm_block() bq27xxx_battery_checksum_dm_block()

Signed-off-by Matt Ranostay <[email protected]>

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c | 285 +++++++++++++++++++++++++++++++++
 include/linux/power/bq27xxx_battery.h  |   1 +
 2 files changed, 286 insertions(+)

drivers/power/supply/bq27xxx_battery.c +93 -0

index e3472c3..dbcf14a 100644
@@ -65,6 +65,7 @@
 #define BQ27XXX_FLAG_DSC	BIT(0)
 #define BQ27XXX_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
 #define BQ27XXX_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
+#define BQ27XXX_FLAG_CFGUP	BIT(4)
 #define BQ27XXX_FLAG_FC		BIT(9)
 #define BQ27XXX_FLAG_OTD	BIT(14)
 #define BQ27XXX_FLAG_OTC	BIT(15)

@@ -78,6 +79,12 @@
 #define BQ27000_FLAG_FC		BIT(5)
 #define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
 
+/* control register params */
+#define BQ27XXX_SEALED			0x20
+#define BQ27XXX_SET_CFGUPDATE		0x13
+#define BQ27XXX_SOFT_RESET		0x42
+#define BQ27XXX_RESET			0x41
+
 #define BQ27XXX_RS			(20) /* Resistor sense mOhm */
 #define BQ27XXX_POWER_CONSTANT		(29200) /* 29.2 µV^2 * 1000 */
 #define BQ27XXX_CURRENT_CONSTANT	(3570) /* 3.57 µV * 1000 */

@@ -108,6 +115,11 @@ enum bq27xxx_reg_index {
 	BQ27XXX_REG_SOC,	/* State-of-Charge */
 	BQ27XXX_REG_DCAP,	/* Design Capacity */
 	BQ27XXX_REG_AP,		/* Average Power */
+	BQ27XXX_DM_CTRL,	/* Block Data Control */
+	BQ27XXX_DM_CLASS,	/* Data Class */
+	BQ27XXX_DM_BLOCK,	/* Data Block */
+	BQ27XXX_DM_DATA,	/* Block Data */
+	BQ27XXX_DM_CKSUM,	/* Block Data Checksum */
 	BQ27XXX_REG_MAX,	/* sentinel */
 };
 

@@ -131,6 +143,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x0b,
 		[BQ27XXX_REG_DCAP] = 0x76,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
 	},
 	[BQ27010] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -150,6 +167,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x0b,
 		[BQ27XXX_REG_DCAP] = 0x76,
 		[BQ27XXX_REG_AP] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CTRL] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CLASS] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_BLOCK] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_DATA] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CKSUM] = INVALID_REG_ADDR,
 	},
 	[BQ2750X] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -169,6 +191,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ2751X] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -188,6 +215,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x20,
 		[BQ27XXX_REG_DCAP] = 0x2e,
 		[BQ27XXX_REG_AP] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27500] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -207,6 +239,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27510G1] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -226,6 +263,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27510G2] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -245,6 +287,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27510G3] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -264,6 +311,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x20,
 		[BQ27XXX_REG_DCAP] = 0x2e,
 		[BQ27XXX_REG_AP] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27520G1] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -283,6 +335,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27520G2] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -302,6 +359,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27520G3] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -321,6 +383,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27520G4] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -340,6 +407,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x20,
 		[BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
 		[BQ27XXX_REG_AP] = INVALID_REG_ADDR,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27530] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -359,6 +431,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27541] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -378,6 +455,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27545] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -397,6 +479,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x2c,
 		[BQ27XXX_REG_DCAP] = INVALID_REG_ADDR,
 		[BQ27XXX_REG_AP] = 0x24,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 	[BQ27421] = {
 		[BQ27XXX_REG_CTRL] = 0x00,

@@ -416,6 +503,11 @@ static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = {
 		[BQ27XXX_REG_SOC] = 0x1c,
 		[BQ27XXX_REG_DCAP] = 0x3c,
 		[BQ27XXX_REG_AP] = 0x18,
+		[BQ27XXX_DM_CTRL] = 0x61,
+		[BQ27XXX_DM_CLASS] = 0x3e,
+		[BQ27XXX_DM_BLOCK] = 0x3f,
+		[BQ27XXX_DM_DATA] = 0x40,
+		[BQ27XXX_DM_CKSUM] = 0x60,
 	},
 };
 

@@ -757,6 +849,18 @@ static struct {
 static DEFINE_MUTEX(bq27xxx_list_lock);
 static LIST_HEAD(bq27xxx_battery_devices);
 
+#define BQ27XXX_MSLEEP(i) usleep_range((i)*1000, (i)*1000+500)

drivers/power/supply/bq27xxx_battery.c +1 -0

+
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {
 	struct bq27xxx_device_info *di;

@@ -855,6 +959,187 @@ static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_in
 	return ret;

drivers/power/supply/bq27xxx_battery.c +16 -0

+	dev_err(di->dev, "bus error on seal: %d\n", ret);
+	return ret;
+}
+
+static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di)
+{
+	int ret;
+
+	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false);
+	if (ret < 0)
+		goto out;
+
+	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false);
+	if (ret < 0)
+		goto out;
+

drivers/power/supply/bq27xxx_battery.c +113 -0

+	int i;
+
+	for (i = 0; i < BQ27XXX_DM_SZ; i++)
+		sum += buf->data[i];
+	sum &= 0xff;
+
+	return 0xff - sum;
+}
+
+static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di,
+					 struct bq27xxx_dm_buf *buf)
+{
+	int ret;
+
+	buf->has_data = false;
+
+	ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
+	if (ret < 0)
+		goto out;
+
+	ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
+	if (ret < 0)
+		goto out;
+
+	BQ27XXX_MSLEEP(1);
+
+	ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
+	if (ret < 0)
+		goto out;
+
+	ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true);
+	if (ret < 0)
+		goto out;
+
+	if ((u8)ret != bq27xxx_battery_checksum_dm_block(buf)) {
+		ret = -EINVAL;
+		goto out;
+	}
+
+	buf->has_data = true;
+	buf->dirty = false;
+
+	return 0;
+
+out:
+	dev_err(di->dev, "bus error reading chip memory: %d\n", ret);
+	return ret;
+}
+
+static int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di, u16 state)
+{
+	const int limit = 100;
+	int ret, try = limit;
+
+	ret = bq27xxx_write(di, BQ27XXX_REG_CTRL,
+			    state ? BQ27XXX_SET_CFGUPDATE : BQ27XXX_SOFT_RESET,
+			    false);
+	if (ret < 0)
+		goto out;
+
+	do {
+		BQ27XXX_MSLEEP(25);
+		ret = di->bus.read(di, di->regs[BQ27XXX_REG_FLAGS], false);
+		if (ret < 0)
+			goto out;
+	} while ((ret & BQ27XXX_FLAG_CFGUP) != state && --try);
+
+	if (!try) {
+		dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", !!state);
+		return -EINVAL;
+	}
+
+	if (limit-try > 3)
+		dev_warn(di->dev, "cfgupdate %d, retries %d\n", !!state, limit-try);
+
+	return 0;
+
+out:
+	dev_err(di->dev, "bus error on %s: %d\n", state ? "set_cfgupdate" : "soft_reset", ret);
+	return ret;
+}
+
+static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di,
+					  struct bq27xxx_dm_buf *buf)
+{
+	bool cfgup = di->chip == BQ27421; /* assume group supports cfgupdate */
+	int ret;
+
+	if (!buf->dirty)
+		return 0;
+
+	if (cfgup) {
+		ret = bq27xxx_battery_set_cfgupdate(di, BQ27XXX_FLAG_CFGUP);
+		if (ret < 0)
+			return ret;
+	}
+
+	ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
+	if (ret < 0)
+		goto out;
+
+	ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
+	if (ret < 0)
+		goto out;
+
+	ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
+	if (ret < 0)
+		goto out;
+
+	BQ27XXX_MSLEEP(1);
+
+	ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
+	if (ret < 0)

drivers/power/supply/bq27xxx_battery.c +24 -0

+	 * http://git.ti.com/bms-linux/bqtool/blobs/master/gauge.c#line328
+	 */
+
+	if (cfgup) {
+		BQ27XXX_MSLEEP(1);
+		ret = bq27xxx_battery_set_cfgupdate(di, 0);
+		if (ret < 0)
+			return ret;
+	} else {
+		BQ27XXX_MSLEEP(100); /* flash DM updates in <100ms */
+	}
+
+	buf->dirty = false;
+
+	return 0;
+
+out:
+	if (cfgup)
+		bq27xxx_battery_set_cfgupdate(di, 0);
+
+	dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
+	return ret;
+}
+
 /*
  * Return the battery State-of-Charge
  * Or < 0 if something fails.

include/linux/power/bq27xxx_battery.h +1 -0

index c3369fa..b1defb8 100644
@@ -64,6 +64,7 @@ struct bq27xxx_device_info {
 	int id;
 	enum bq27xxx_chip chip;
 	const char *name;
+	u32 unseal_key;
 	struct bq27xxx_access_methods bus;
 	struct bq27xxx_reg_cache cache;
 	int charge_design_full;

Quoted 27 lines · Liam Breck

From: Liam Breck <[email protected]>

Add the following to enable read/write of chip data memory (DM) RAM/NVM/flash:
bq27xxx_battery_seal()
bq27xxx_battery_unseal()
bq27xxx_battery_set_cfgupdate()
bq27xxx_battery_read_dm_block() bq27xxx_battery_write_dm_block() bq27xxx_battery_checksum_dm_block()

Signed-off-by Matt Ranostay <[email protected]>

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c | 285 +++++++++++++++++++++++++++++++++
 include/linux/power/bq27xxx_battery.h  |   1 +
 2 files changed, 286 insertions(+)

drivers/power/supply/bq27xxx_battery.c +1 -0

index e3472c3..dbcf14a 100644
@@ -757,6 +849,18 @@ static struct {
 static DEFINE_MUTEX(bq27xxx_list_lock);
 static LIST_HEAD(bq27xxx_battery_devices);
 
+#define BQ27XXX_MSLEEP(i) usleep_range((i)*1000, (i)*1000+500)

drivers/power/supply/bq27xxx_battery.c static struct { · line 862

Quoted 10 lines

drivers/power/supply/bq27xxx_battery.c +10 -0

+
+#define BQ27XXX_DM_SZ        32
+
+struct bq27xxx_dm_buf {
+     u8 class;
+     u8 block;
+     u8 data[BQ27XXX_DM_SZ];
+     bool has_data, dirty;
+};
+

kernel-doc this struct

Quoted 8 lines

drivers/power/supply/bq27xxx_battery.c +1 -0

+
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {
      struct bq27xxx_device_info *di;

@@ -855,6 +959,187 @@ static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_in
      return ret;
 }
 

drivers/power/supply/bq27xxx_battery.c static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_in · line 969

Quoted 8 lines

drivers/power/supply/bq27xxx_battery.c +8 -0

+static int bq27xxx_battery_seal(struct bq27xxx_device_info *di)
+{
+     int ret;
+
+     ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, BQ27XXX_SEALED, false);
+     if (ret >= 0)
+             return 0;
+

This logic is reversed, return on error first.

Quoted 16 lines

drivers/power/supply/bq27xxx_battery.c +16 -0

+     dev_err(di->dev, "bus error on seal: %d\n", ret);
+     return ret;
+}
+
+static int bq27xxx_battery_unseal(struct bq27xxx_device_info *di)
+{
+     int ret;
+
+     ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)(di->unseal_key >> 16), false);
+     if (ret < 0)
+             goto out;
+
+     ret = bq27xxx_write(di, BQ27XXX_REG_CTRL, (u16)di->unseal_key, false);
+     if (ret < 0)
+             goto out;
+

drivers/power/supply/bq27xxx_battery.c static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_in · line 995

Quoted 10 lines

drivers/power/supply/bq27xxx_battery.c +10 -0

+     return 0;
+
+out:
+     dev_err(di->dev, "bus error on unseal: %d\n", ret);
+     return ret;
+}
+
+static u8 bq27xxx_battery_checksum_dm_block(struct bq27xxx_dm_buf *buf)
+{
+     u16 sum = 0;

I haven't tested this, but maybe you could:

u8 sum = 0xff;

for (i = 0; i < BQ27XXX_DM_SZ; i++)

        sum -= buf->data[i];

return sum;

Quoted 117 lines

drivers/power/supply/bq27xxx_battery.c +117 -0

+     int i;
+
+     for (i = 0; i < BQ27XXX_DM_SZ; i++)
+             sum += buf->data[i];
+     sum &= 0xff;
+
+     return 0xff - sum;
+}
+
+static int bq27xxx_battery_read_dm_block(struct bq27xxx_device_info *di,
+                                      struct bq27xxx_dm_buf *buf)
+{
+     int ret;
+
+     buf->has_data = false;
+
+     ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
+     if (ret < 0)
+             goto out;
+
+     ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
+     if (ret < 0)
+             goto out;
+
+     BQ27XXX_MSLEEP(1);
+
+     ret = bq27xxx_read_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
+     if (ret < 0)
+             goto out;
+
+     ret = bq27xxx_read(di, BQ27XXX_DM_CKSUM, true);
+     if (ret < 0)
+             goto out;
+
+     if ((u8)ret != bq27xxx_battery_checksum_dm_block(buf)) {
+             ret = -EINVAL;
+             goto out;
+     }
+
+     buf->has_data = true;
+     buf->dirty = false;
+
+     return 0;
+
+out:
+     dev_err(di->dev, "bus error reading chip memory: %d\n", ret);
+     return ret;
+}
+
+static int bq27xxx_battery_set_cfgupdate(struct bq27xxx_device_info *di, u16 state)
+{
+     const int limit = 100;
+     int ret, try = limit;
+
+     ret = bq27xxx_write(di, BQ27XXX_REG_CTRL,
+                         state ? BQ27XXX_SET_CFGUPDATE : BQ27XXX_SOFT_RESET,
+                         false);
+     if (ret < 0)
+             goto out;
+
+     do {
+             BQ27XXX_MSLEEP(25);
+             ret = di->bus.read(di, di->regs[BQ27XXX_REG_FLAGS], false);
+             if (ret < 0)
+                     goto out;
+     } while ((ret & BQ27XXX_FLAG_CFGUP) != state && --try);
+
+     if (!try) {
+             dev_err(di->dev, "timed out waiting for cfgupdate flag %d\n", !!state);
+             return -EINVAL;
+     }
+
+     if (limit-try > 3)
+             dev_warn(di->dev, "cfgupdate %d, retries %d\n", !!state, limit-try);
+
+     return 0;
+
+out:
+     dev_err(di->dev, "bus error on %s: %d\n", state ? "set_cfgupdate" : "soft_reset", ret);
+     return ret;
+}
+
+static int bq27xxx_battery_write_dm_block(struct bq27xxx_device_info *di,
+                                       struct bq27xxx_dm_buf *buf)
+{
+     bool cfgup = di->chip == BQ27421; /* assume group supports cfgupdate */
+     int ret;
+
+     if (!buf->dirty)
+             return 0;
+
+     if (cfgup) {
+             ret = bq27xxx_battery_set_cfgupdate(di, BQ27XXX_FLAG_CFGUP);
+             if (ret < 0)
+                     return ret;
+     }
+
+     ret = bq27xxx_write(di, BQ27XXX_DM_CTRL, 0, true);
+     if (ret < 0)
+             goto out;
+
+     ret = bq27xxx_write(di, BQ27XXX_DM_CLASS, buf->class, true);
+     if (ret < 0)
+             goto out;
+
+     ret = bq27xxx_write(di, BQ27XXX_DM_BLOCK, buf->block, true);
+     if (ret < 0)
+             goto out;
+
+     BQ27XXX_MSLEEP(1);
+
+     ret = bq27xxx_write_block(di, BQ27XXX_DM_DATA, buf->data, BQ27XXX_DM_SZ);
+     if (ret < 0)
+             goto out;
+
+     ret = bq27xxx_write(di, BQ27XXX_DM_CKSUM,
+                         bq27xxx_battery_checksum_dm_block(buf), true);

drivers/power/supply/bq27xxx_battery.c static inline int bq27xxx_write_block(struct bq27xxx_device_info *di, int reg_in · line 1118

Quoted 6 lines

drivers/power/supply/bq27xxx_battery.c +6 -0

+     if (ret < 0)
+             goto out;
+
+     /* DO NOT read BQ27XXX_DM_CKSUM here to verify it! That may cause NVM
+      * corruption on the '425 chip (and perhaps others), which can damage
+      * the chip. See TI bqtool for what not to do:

The bqtool does work, it even says delay needs to be long enough.

Quoted 40 lines

drivers/power/supply/bq27xxx_battery.c +24 -0

+      * http://git.ti.com/bms-linux/bqtool/blobs/master/gauge.c#line328
+      */
+
+     if (cfgup) {
+             BQ27XXX_MSLEEP(1);
+             ret = bq27xxx_battery_set_cfgupdate(di, 0);
+             if (ret < 0)
+                     return ret;
+     } else {
+             BQ27XXX_MSLEEP(100); /* flash DM updates in <100ms */
+     }
+
+     buf->dirty = false;
+
+     return 0;
+
+out:
+     if (cfgup)
+             bq27xxx_battery_set_cfgupdate(di, 0);
+
+     dev_err(di->dev, "bus error writing chip memory: %d\n", ret);
+     return ret;
+}
+
 /*
  * Return the battery State-of-Charge
  * Or < 0 if something fails.

include/linux/power/bq27xxx_battery.h +1 -0

index c3369fa..b1defb8 100644
@@ -64,6 +64,7 @@ struct bq27xxx_device_info {
      int id;
      enum bq27xxx_chip chip;
      const char *name;
+     u32 unseal_key;
      struct bq27xxx_access_methods bus;
      struct bq27xxx_reg_cache cache;
      int charge_design_full;

From: Liam Breck <[email protected]>

Support data memory update of BQ27500, 545, 421, 425, 441, 621.

Create IDs for for previously unID'd chips, to index arrays for unseal keys and data memory register tables.

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 73 +++++++++++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 16 +++----
 include/linux/power/bq27xxx_battery.h      | 11 +++++
 3 files changed, 90 insertions(+), 10 deletions(-)

drivers/power/supply/bq27xxx_battery.c +71 -2

index 4c7a13e..70b8d1c 100644
@@ -57,7 +57,7 @@
 
 #include <linux/power/bq27xxx_battery.h>
 
-#define DRIVER_VERSION		"1.2.0"
+#define DRIVER_VERSION		"1.3.0"
 
 #define BQ27XXX_MANUFACTURER	"Texas Instruments"
 

@@ -894,6 +894,54 @@ static const char* bq27xxx_dm_reg_name[] = {
 	[BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
 };
 
+static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
+	[BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 10, 2,    0, 65535 },
+	[BQ27XXX_DM_DESIGN_ENERGY]     = { }, /* missing on chip */
+	[BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
+};
+
+static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
+	[BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 23, 2,    0, 32767 },
+	[BQ27XXX_DM_DESIGN_ENERGY]     = { 48, 25, 2,    0, 32767 },
+	[BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
+	[BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 10, 2,    0,  8000 },
+	[BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 12, 2,    0, 32767 },
+	[BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
+	[BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 12, 2,    0, 32767 },
+	[BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 14, 2,    0, 32767 },
+	[BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
+	[BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 3, 2,    0,  8000 },
+	[BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 5, 2,    0, 32767 },
+	[BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg *bq27xxx_dm_regs[] = {
+	[BQ27500] = bq27500_dm_regs,
+	[BQ27545] = bq27545_dm_regs,
+	[BQ27421] = bq27421_dm_regs,
+	[BQ27425] = bq27425_dm_regs,
+	[BQ27441] = bq27421_dm_regs,
+	[BQ27621] = bq27621_dm_regs,
+};
+
+static u32 bq27xxx_unseal_keys[] = {
+	[BQ27500] = 0x04143672,
+	[BQ27545] = 0x04143672,
+	[BQ27421] = 0x80008000,
+	[BQ27425] = 0x04143672,
+	[BQ27441] = 0x80008000,
+	[BQ27621] = 0x80008000,
+};
+
 
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {

@@ -1861,9 +1909,30 @@ int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
 		.drv_data = di,
 	};
 
+	di->unseal_key = bq27xxx_unseal_keys[di->chip];
+	di->dm_regs = bq27xxx_dm_regs[di->chip];
+
+	switch(di->chip) {  /* translate members of categories */
+	case BQ2752X:
+		di->chip = BQ27510G3; break;
+	case BQ27531:
+		di->chip = BQ27530;   break;
+	case BQ27542:
+	case BQ27546:
+	case BQ27742:
+		di->chip = BQ27541;   break;
+	case BQ27425:
+	case BQ27441:
+	case BQ27621:
+		di->chip = BQ27421;   break;
+	default:
+		break;
+	}
+
+	di->regs = bq27xxx_regs[di->chip];
+
 	INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
 	mutex_init(&di->lock);
-	di->regs = bq27xxx_regs[di->chip];
 
 	psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
 	if (!psy_desc)

drivers/power/supply/bq27xxx_battery_i2c.c +8 -8

index a597221..0b11ed4 100644
@@ -230,7 +230,7 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
 	{ "bq27210", BQ27010 },
 	{ "bq27500", BQ2750X },
 	{ "bq27510", BQ2751X },
-	{ "bq27520", BQ2751X },
+	{ "bq27520", BQ2752X },
 	{ "bq27500-1", BQ27500 },
 	{ "bq27510g1", BQ27510G1 },
 	{ "bq27510g2", BQ27510G2 },

@@ -240,16 +240,16 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
 	{ "bq27520g3", BQ27520G3 },
 	{ "bq27520g4", BQ27520G4 },
 	{ "bq27530", BQ27530 },
-	{ "bq27531", BQ27530 },
+	{ "bq27531", BQ27531 },
 	{ "bq27541", BQ27541 },
-	{ "bq27542", BQ27541 },
-	{ "bq27546", BQ27541 },
-	{ "bq27742", BQ27541 },
+	{ "bq27542", BQ27542 },
+	{ "bq27546", BQ27546 },
+	{ "bq27742", BQ27742 },
 	{ "bq27545", BQ27545 },
 	{ "bq27421", BQ27421 },
-	{ "bq27425", BQ27421 },
-	{ "bq27441", BQ27421 },
-	{ "bq27621", BQ27421 },
+	{ "bq27425", BQ27425 },
+	{ "bq27441", BQ27441 },
+	{ "bq27621", BQ27621 },
 	{},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

include/linux/power/bq27xxx_battery.h +1 -0

index 227eb08..014e59f 100644
@@ -2,6 +2,7 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 
 enum bq27xxx_chip {
+	/* categories; index for bq27xxx_regs[] */
 	BQ27000 = 1, /* bq27000, bq27200 */
 	BQ27010, /* bq27010, bq27210 */
 	BQ2750X, /* bq27500 deprecated alias */

include/linux/power/bq27xxx_battery.h +8 -0

+	BQ2752X, /* deprecated alias */
+	BQ27531,
+	BQ27542,
+	BQ27546,
+	BQ27742,
+	BQ27425,
+	BQ27441,
+	BQ27621,
 };
 
 /**

Quoted 158 lines · Liam Breck

From: Liam Breck <[email protected]>

Support data memory update of BQ27500, 545, 421, 425, 441, 621.

Create IDs for for previously unID'd chips, to index arrays for unseal keys and data memory register tables.

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 73 +++++++++++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 16 +++----
 include/linux/power/bq27xxx_battery.h      | 11 +++++
 3 files changed, 90 insertions(+), 10 deletions(-)

drivers/power/supply/bq27xxx_battery.c +71 -2

index 4c7a13e..70b8d1c 100644
@@ -57,7 +57,7 @@
 
 #include <linux/power/bq27xxx_battery.h>
 
-#define DRIVER_VERSION               "1.2.0"
+#define DRIVER_VERSION               "1.3.0"
 
 #define BQ27XXX_MANUFACTURER "Texas Instruments"
 

@@ -894,6 +894,54 @@ static const char* bq27xxx_dm_reg_name[] = {
      [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
 };
 
+static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 10, 2,    0, 65535 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { }, /* missing on chip */
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
+};
+
+static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 23, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 48, 25, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 10, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 14, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 3, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 5, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg *bq27xxx_dm_regs[] = {
+     [BQ27500] = bq27500_dm_regs,
+     [BQ27545] = bq27545_dm_regs,
+     [BQ27421] = bq27421_dm_regs,
+     [BQ27425] = bq27425_dm_regs,
+     [BQ27441] = bq27421_dm_regs,
+     [BQ27621] = bq27621_dm_regs,
+};
+
+static u32 bq27xxx_unseal_keys[] = {
+     [BQ27500] = 0x04143672,
+     [BQ27545] = 0x04143672,
+     [BQ27421] = 0x80008000,
+     [BQ27425] = 0x04143672,
+     [BQ27441] = 0x80008000,
+     [BQ27621] = 0x80008000,
+};
+
 
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {

@@ -1861,9 +1909,30 @@ int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
              .drv_data = di,
      };
 
+     di->unseal_key = bq27xxx_unseal_keys[di->chip];
+     di->dm_regs = bq27xxx_dm_regs[di->chip];
+
+     switch(di->chip) {  /* translate members of categories */
+     case BQ2752X:
+             di->chip = BQ27510G3; break;
+     case BQ27531:
+             di->chip = BQ27530;   break;
+     case BQ27542:
+     case BQ27546:
+     case BQ27742:
+             di->chip = BQ27541;   break;
+     case BQ27425:
+     case BQ27441:
+     case BQ27621:
+             di->chip = BQ27421;   break;
+     default:
+             break;
+     }
+
+     di->regs = bq27xxx_regs[di->chip];
+
      INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
      mutex_init(&di->lock);
-     di->regs = bq27xxx_regs[di->chip];
 
      psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
      if (!psy_desc)

drivers/power/supply/bq27xxx_battery_i2c.c +8 -8

index a597221..0b11ed4 100644
@@ -230,7 +230,7 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27210", BQ27010 },
      { "bq27500", BQ2750X },
      { "bq27510", BQ2751X },
-     { "bq27520", BQ2751X },
+     { "bq27520", BQ2752X },
      { "bq27500-1", BQ27500 },
      { "bq27510g1", BQ27510G1 },
      { "bq27510g2", BQ27510G2 },

@@ -240,16 +240,16 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27520g3", BQ27520G3 },
      { "bq27520g4", BQ27520G4 },
      { "bq27530", BQ27530 },
-     { "bq27531", BQ27530 },
+     { "bq27531", BQ27531 },
      { "bq27541", BQ27541 },
-     { "bq27542", BQ27541 },
-     { "bq27546", BQ27541 },
-     { "bq27742", BQ27541 },
+     { "bq27542", BQ27542 },
+     { "bq27546", BQ27546 },
+     { "bq27742", BQ27742 },
      { "bq27545", BQ27545 },
      { "bq27421", BQ27421 },
-     { "bq27425", BQ27421 },
-     { "bq27441", BQ27421 },
-     { "bq27621", BQ27421 },
+     { "bq27425", BQ27425 },
+     { "bq27441", BQ27441 },
+     { "bq27621", BQ27621 },
      {},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

include/linux/power/bq27xxx_battery.h +0 -0

index 227eb08..014e59f 100644
@@ -2,6 +2,7 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 

include/linux/power/bq27xxx_battery.h enum bq27xxx_chip { · line 23

Quoted 11 lines

include/linux/power/bq27xxx_battery.h +3 -0

 enum bq27xxx_chip {
+     /* categories; index for bq27xxx_regs[] */
      BQ27000 = 1, /* bq27000, bq27200 */
      BQ27010, /* bq27010, bq27210 */
      BQ2750X, /* bq27500 deprecated alias */

@@ -18,6 +19,16 @@ enum bq27xxx_chip {
      BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
      BQ27545, /* bq27545 */
      BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+
+     /* members of categories; translate these to category in _setup() */

These don't need to be separate from the others, these are valid chip IDs, we may use another compatible ID for register array index right now but these are not "categories".

Quoted 12 lines

include/linux/power/bq27xxx_battery.h +8 -0

+     BQ2752X, /* deprecated alias */
+     BQ27531,
+     BQ27542,
+     BQ27546,
+     BQ27742,
+     BQ27425,
+     BQ27441,
+     BQ27621,
 };
 
 /**

Quoted 159 lines · Andrew F. Davis

Quoted 158 lines · Liam Breck

From: Liam Breck <[email protected]>

Support data memory update of BQ27500, 545, 421, 425, 441, 621.

Create IDs for for previously unID'd chips, to index arrays for unseal keys and data memory register tables.

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 73 +++++++++++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 16 +++----
 include/linux/power/bq27xxx_battery.h      | 11 +++++
 3 files changed, 90 insertions(+), 10 deletions(-)

drivers/power/supply/bq27xxx_battery.c +71 -2

index 4c7a13e..70b8d1c 100644
@@ -57,7 +57,7 @@
 
 #include <linux/power/bq27xxx_battery.h>
 
-#define DRIVER_VERSION               "1.2.0"
+#define DRIVER_VERSION               "1.3.0"
 
 #define BQ27XXX_MANUFACTURER "Texas Instruments"
 

@@ -894,6 +894,54 @@ static const char* bq27xxx_dm_reg_name[] = {
      [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
 };
 
+static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 10, 2,    0, 65535 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { }, /* missing on chip */
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
+};
+
+static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 23, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 48, 25, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 10, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 14, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 3, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 5, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg *bq27xxx_dm_regs[] = {
+     [BQ27500] = bq27500_dm_regs,
+     [BQ27545] = bq27545_dm_regs,
+     [BQ27421] = bq27421_dm_regs,
+     [BQ27425] = bq27425_dm_regs,
+     [BQ27441] = bq27421_dm_regs,
+     [BQ27621] = bq27621_dm_regs,
+};
+
+static u32 bq27xxx_unseal_keys[] = {
+     [BQ27500] = 0x04143672,
+     [BQ27545] = 0x04143672,
+     [BQ27421] = 0x80008000,
+     [BQ27425] = 0x04143672,
+     [BQ27441] = 0x80008000,
+     [BQ27621] = 0x80008000,
+};
+
 
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {

@@ -1861,9 +1909,30 @@ int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
              .drv_data = di,
      };
 
+     di->unseal_key = bq27xxx_unseal_keys[di->chip];
+     di->dm_regs = bq27xxx_dm_regs[di->chip];
+
+     switch(di->chip) {  /* translate members of categories */
+     case BQ2752X:
+             di->chip = BQ27510G3; break;
+     case BQ27531:
+             di->chip = BQ27530;   break;
+     case BQ27542:
+     case BQ27546:
+     case BQ27742:
+             di->chip = BQ27541;   break;
+     case BQ27425:
+     case BQ27441:
+     case BQ27621:
+             di->chip = BQ27421;   break;
+     default:
+             break;
+     }
+
+     di->regs = bq27xxx_regs[di->chip];
+
      INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
      mutex_init(&di->lock);
-     di->regs = bq27xxx_regs[di->chip];
 
      psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
      if (!psy_desc)

drivers/power/supply/bq27xxx_battery_i2c.c +8 -8

index a597221..0b11ed4 100644
@@ -230,7 +230,7 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27210", BQ27010 },
      { "bq27500", BQ2750X },
      { "bq27510", BQ2751X },
-     { "bq27520", BQ2751X },
+     { "bq27520", BQ2752X },
      { "bq27500-1", BQ27500 },
      { "bq27510g1", BQ27510G1 },
      { "bq27510g2", BQ27510G2 },

@@ -240,16 +240,16 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27520g3", BQ27520G3 },
      { "bq27520g4", BQ27520G4 },
      { "bq27530", BQ27530 },
-     { "bq27531", BQ27530 },
+     { "bq27531", BQ27531 },
      { "bq27541", BQ27541 },
-     { "bq27542", BQ27541 },
-     { "bq27546", BQ27541 },
-     { "bq27742", BQ27541 },
+     { "bq27542", BQ27542 },
+     { "bq27546", BQ27546 },
+     { "bq27742", BQ27742 },
      { "bq27545", BQ27545 },
      { "bq27421", BQ27421 },
-     { "bq27425", BQ27421 },
-     { "bq27441", BQ27421 },
-     { "bq27621", BQ27421 },
+     { "bq27425", BQ27425 },
+     { "bq27441", BQ27441 },
+     { "bq27621", BQ27621 },
      {},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

include/linux/power/bq27xxx_battery.h +0 -0

index 227eb08..014e59f 100644
@@ -2,6 +2,7 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 

Quoted 15 lines

include/linux/power/bq27xxx_battery.h enum bq27xxx_chip { · line 23

Quoted 11 lines

include/linux/power/bq27xxx_battery.h +3 -0

 enum bq27xxx_chip {
+     /* categories; index for bq27xxx_regs[] */
      BQ27000 = 1, /* bq27000, bq27200 */
      BQ27010, /* bq27010, bq27210 */
      BQ2750X, /* bq27500 deprecated alias */

@@ -18,6 +19,16 @@ enum bq27xxx_chip {
      BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
      BQ27545, /* bq27545 */
      BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+
+     /* members of categories; translate these to category in _setup() */

These don't need to be separate from the others, these are valid chip IDs, we may use another compatible ID for register array index right now but these are not "categories".

The above were indeed treated like categories, as the I2C ID table mapped other chips to them. We could call them category|class "leaders" (prototypes? models? patterns?) instead.

The below are not valid in di->chip, they must be converted. So it makes sense to group them.

Quoted 12 lines

Quoted 12 lines

include/linux/power/bq27xxx_battery.h +8 -0

+     BQ2752X, /* deprecated alias */
+     BQ27531,
+     BQ27542,
+     BQ27546,
+     BQ27742,
+     BQ27425,
+     BQ27441,
+     BQ27621,
 };
 
 /**

Quoted 180 lines · Liam Breck

Quoted 159 lines · Andrew F. Davis

Quoted 158 lines · Liam Breck

From: Liam Breck <[email protected]>

Support data memory update of BQ27500, 545, 421, 425, 441, 621.

Create IDs for for previously unID'd chips, to index arrays for unseal keys and data memory register tables.

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 73 +++++++++++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 16 +++----
 include/linux/power/bq27xxx_battery.h      | 11 +++++
 3 files changed, 90 insertions(+), 10 deletions(-)

drivers/power/supply/bq27xxx_battery.c +71 -2

index 4c7a13e..70b8d1c 100644
@@ -57,7 +57,7 @@
 
 #include <linux/power/bq27xxx_battery.h>
 
-#define DRIVER_VERSION               "1.2.0"
+#define DRIVER_VERSION               "1.3.0"
 
 #define BQ27XXX_MANUFACTURER "Texas Instruments"
 

@@ -894,6 +894,54 @@ static const char* bq27xxx_dm_reg_name[] = {
      [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
 };
 
+static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 10, 2,    0, 65535 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { }, /* missing on chip */
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
+};
+
+static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 23, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 48, 25, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 10, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 14, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 3, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 5, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg *bq27xxx_dm_regs[] = {
+     [BQ27500] = bq27500_dm_regs,
+     [BQ27545] = bq27545_dm_regs,
+     [BQ27421] = bq27421_dm_regs,
+     [BQ27425] = bq27425_dm_regs,
+     [BQ27441] = bq27421_dm_regs,
+     [BQ27621] = bq27621_dm_regs,
+};
+
+static u32 bq27xxx_unseal_keys[] = {
+     [BQ27500] = 0x04143672,
+     [BQ27545] = 0x04143672,
+     [BQ27421] = 0x80008000,
+     [BQ27425] = 0x04143672,
+     [BQ27441] = 0x80008000,
+     [BQ27621] = 0x80008000,
+};
+
 
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {

@@ -1861,9 +1909,30 @@ int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
              .drv_data = di,
      };
 
+     di->unseal_key = bq27xxx_unseal_keys[di->chip];
+     di->dm_regs = bq27xxx_dm_regs[di->chip];
+
+     switch(di->chip) {  /* translate members of categories */
+     case BQ2752X:
+             di->chip = BQ27510G3; break;
+     case BQ27531:
+             di->chip = BQ27530;   break;
+     case BQ27542:
+     case BQ27546:
+     case BQ27742:
+             di->chip = BQ27541;   break;
+     case BQ27425:
+     case BQ27441:
+     case BQ27621:
+             di->chip = BQ27421;   break;
+     default:
+             break;
+     }
+
+     di->regs = bq27xxx_regs[di->chip];
+
      INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
      mutex_init(&di->lock);
-     di->regs = bq27xxx_regs[di->chip];
 
      psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
      if (!psy_desc)

drivers/power/supply/bq27xxx_battery_i2c.c +8 -8

index a597221..0b11ed4 100644
@@ -230,7 +230,7 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27210", BQ27010 },
      { "bq27500", BQ2750X },
      { "bq27510", BQ2751X },
-     { "bq27520", BQ2751X },
+     { "bq27520", BQ2752X },
      { "bq27500-1", BQ27500 },
      { "bq27510g1", BQ27510G1 },
      { "bq27510g2", BQ27510G2 },

@@ -240,16 +240,16 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27520g3", BQ27520G3 },
      { "bq27520g4", BQ27520G4 },
      { "bq27530", BQ27530 },
-     { "bq27531", BQ27530 },
+     { "bq27531", BQ27531 },
      { "bq27541", BQ27541 },
-     { "bq27542", BQ27541 },
-     { "bq27546", BQ27541 },
-     { "bq27742", BQ27541 },
+     { "bq27542", BQ27542 },
+     { "bq27546", BQ27546 },
+     { "bq27742", BQ27742 },
      { "bq27545", BQ27545 },
      { "bq27421", BQ27421 },
-     { "bq27425", BQ27421 },
-     { "bq27441", BQ27421 },
-     { "bq27621", BQ27421 },
+     { "bq27425", BQ27425 },
+     { "bq27441", BQ27441 },
+     { "bq27621", BQ27621 },
      {},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

include/linux/power/bq27xxx_battery.h +0 -0

index 227eb08..014e59f 100644
@@ -2,6 +2,7 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 

Quoted 15 lines

include/linux/power/bq27xxx_battery.h enum bq27xxx_chip { · line 23

Quoted 11 lines

include/linux/power/bq27xxx_battery.h +3 -0

 enum bq27xxx_chip {
+     /* categories; index for bq27xxx_regs[] */
      BQ27000 = 1, /* bq27000, bq27200 */
      BQ27010, /* bq27010, bq27210 */
      BQ2750X, /* bq27500 deprecated alias */

@@ -18,6 +19,16 @@ enum bq27xxx_chip {
      BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
      BQ27545, /* bq27545 */
      BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+
+     /* members of categories; translate these to category in _setup() */

These don't need to be separate from the others, these are valid chip IDs, we may use another compatible ID for register array index right now but these are not "categories".

The above were indeed treated like categories, as the I2C ID table mapped other chips to them. We could call them category|class "leaders" (prototypes? models? patterns?) instead.

Quoted 3 lines

The below are not valid in di->chip, they must be converted. So it makes sense to group them.

They are only "not valid" because you did not add tables for them. If you don't want to add register tables then think of a better way to map chip to register table. This is overly complex and will cause problems for people adding more chips.

Quoted 12 lines

Quoted 12 lines

Quoted 12 lines

include/linux/power/bq27xxx_battery.h +8 -0

+     BQ2752X, /* deprecated alias */
+     BQ27531,
+     BQ27542,
+     BQ27546,
+     BQ27742,
+     BQ27425,
+     BQ27441,
+     BQ27621,
 };
 
 /**

Quoted 181 lines · Andrew F. Davis

Quoted 180 lines · Liam Breck

Quoted 159 lines · Andrew F. Davis

Quoted 158 lines · Liam Breck

From: Liam Breck <[email protected]>

Support data memory update of BQ27500, 545, 421, 425, 441, 621.

Create IDs for for previously unID'd chips, to index arrays for unseal keys and data memory register tables.

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 73 +++++++++++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 16 +++----
 include/linux/power/bq27xxx_battery.h      | 11 +++++
 3 files changed, 90 insertions(+), 10 deletions(-)

drivers/power/supply/bq27xxx_battery.c +71 -2

index 4c7a13e..70b8d1c 100644
@@ -57,7 +57,7 @@
 
 #include <linux/power/bq27xxx_battery.h>
 
-#define DRIVER_VERSION               "1.2.0"
+#define DRIVER_VERSION               "1.3.0"
 
 #define BQ27XXX_MANUFACTURER "Texas Instruments"
 

@@ -894,6 +894,54 @@ static const char* bq27xxx_dm_reg_name[] = {
      [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
 };
 
+static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 10, 2,    0, 65535 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { }, /* missing on chip */
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
+};
+
+static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 23, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 48, 25, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 10, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 14, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 3, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 5, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg *bq27xxx_dm_regs[] = {
+     [BQ27500] = bq27500_dm_regs,
+     [BQ27545] = bq27545_dm_regs,
+     [BQ27421] = bq27421_dm_regs,
+     [BQ27425] = bq27425_dm_regs,
+     [BQ27441] = bq27421_dm_regs,
+     [BQ27621] = bq27621_dm_regs,
+};
+
+static u32 bq27xxx_unseal_keys[] = {
+     [BQ27500] = 0x04143672,
+     [BQ27545] = 0x04143672,
+     [BQ27421] = 0x80008000,
+     [BQ27425] = 0x04143672,
+     [BQ27441] = 0x80008000,
+     [BQ27621] = 0x80008000,
+};
+
 
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {

@@ -1861,9 +1909,30 @@ int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
              .drv_data = di,
      };
 
+     di->unseal_key = bq27xxx_unseal_keys[di->chip];
+     di->dm_regs = bq27xxx_dm_regs[di->chip];
+
+     switch(di->chip) {  /* translate members of categories */
+     case BQ2752X:
+             di->chip = BQ27510G3; break;
+     case BQ27531:
+             di->chip = BQ27530;   break;
+     case BQ27542:
+     case BQ27546:
+     case BQ27742:
+             di->chip = BQ27541;   break;
+     case BQ27425:
+     case BQ27441:
+     case BQ27621:
+             di->chip = BQ27421;   break;
+     default:
+             break;
+     }
+
+     di->regs = bq27xxx_regs[di->chip];
+
      INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
      mutex_init(&di->lock);
-     di->regs = bq27xxx_regs[di->chip];
 
      psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
      if (!psy_desc)

drivers/power/supply/bq27xxx_battery_i2c.c +8 -8

index a597221..0b11ed4 100644
@@ -230,7 +230,7 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27210", BQ27010 },
      { "bq27500", BQ2750X },
      { "bq27510", BQ2751X },
-     { "bq27520", BQ2751X },
+     { "bq27520", BQ2752X },
      { "bq27500-1", BQ27500 },
      { "bq27510g1", BQ27510G1 },
      { "bq27510g2", BQ27510G2 },

@@ -240,16 +240,16 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27520g3", BQ27520G3 },
      { "bq27520g4", BQ27520G4 },
      { "bq27530", BQ27530 },
-     { "bq27531", BQ27530 },
+     { "bq27531", BQ27531 },
      { "bq27541", BQ27541 },
-     { "bq27542", BQ27541 },
-     { "bq27546", BQ27541 },
-     { "bq27742", BQ27541 },
+     { "bq27542", BQ27542 },
+     { "bq27546", BQ27546 },
+     { "bq27742", BQ27742 },
      { "bq27545", BQ27545 },
      { "bq27421", BQ27421 },
-     { "bq27425", BQ27421 },
-     { "bq27441", BQ27421 },
-     { "bq27621", BQ27421 },
+     { "bq27425", BQ27425 },
+     { "bq27441", BQ27441 },
+     { "bq27621", BQ27621 },
      {},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

include/linux/power/bq27xxx_battery.h +0 -0

index 227eb08..014e59f 100644
@@ -2,6 +2,7 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 

Quoted 15 lines

include/linux/power/bq27xxx_battery.h enum bq27xxx_chip { · line 23

Quoted 11 lines

include/linux/power/bq27xxx_battery.h +3 -0

 enum bq27xxx_chip {
+     /* categories; index for bq27xxx_regs[] */
      BQ27000 = 1, /* bq27000, bq27200 */
      BQ27010, /* bq27010, bq27210 */
      BQ2750X, /* bq27500 deprecated alias */

@@ -18,6 +19,16 @@ enum bq27xxx_chip {
      BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
      BQ27545, /* bq27545 */
      BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+
+     /* members of categories; translate these to category in _setup() */

These don't need to be separate from the others, these are valid chip IDs, we may use another compatible ID for register array index right now but these are not "categories".

The above were indeed treated like categories, as the I2C ID table mapped other chips to them. We could call them category|class "leaders" (prototypes? models? patterns?) instead.

Quoted 8 lines

Quoted 3 lines

The below are not valid in di->chip, they must be converted. So it makes sense to group them.

They are only "not valid" because you did not add tables for them. If you don't want to add register tables then think of a better way to map chip to register table. This is overly complex and will cause problems for people adding more chips.

This very mapping from category member -> prototype ID was done by the I2C table previously. How is doing it in a setup() switch any more complex?

The alternative mapping from chip to regs is this, which you said was there but replaced by a 2D array a while ago. Shall we revert to this?

  bq27xxx_regs[] = {
    [BQ27991] = bq27991_regs, // prototype
    [BQ27992] = bq27991_regs, // member
    ...

};

Quoted 13 lines

Quoted 13 lines

Quoted 13 lines

Quoted 13 lines

include/linux/power/bq27xxx_battery.h +8 -0

+     BQ2752X, /* deprecated alias */
+     BQ27531,
+     BQ27542,
+     BQ27546,
+     BQ27742,
+     BQ27425,
+     BQ27441,
+     BQ27621,
 };
 
 /**

Quoted 195 lines · Liam Breck

Quoted 181 lines · Andrew F. Davis

Quoted 180 lines · Liam Breck

Quoted 159 lines · Andrew F. Davis

Quoted 158 lines · Liam Breck

From: Liam Breck <[email protected]>

Support data memory update of BQ27500, 545, 421, 425, 441, 621.

Create IDs for for previously unID'd chips, to index arrays for unseal keys and data memory register tables.

Signed-off-by Liam Breck <[email protected]>

---
 drivers/power/supply/bq27xxx_battery.c     | 73 +++++++++++++++++++++++++++++-
 drivers/power/supply/bq27xxx_battery_i2c.c | 16 +++----
 include/linux/power/bq27xxx_battery.h      | 11 +++++
 3 files changed, 90 insertions(+), 10 deletions(-)

drivers/power/supply/bq27xxx_battery.c +71 -2

index 4c7a13e..70b8d1c 100644
@@ -57,7 +57,7 @@
 
 #include <linux/power/bq27xxx_battery.h>
 
-#define DRIVER_VERSION               "1.2.0"
+#define DRIVER_VERSION               "1.3.0"
 
 #define BQ27XXX_MANUFACTURER "Texas Instruments"
 

@@ -894,6 +894,54 @@ static const char* bq27xxx_dm_reg_name[] = {
      [BQ27XXX_DM_TERMINATE_VOLTAGE] = "terminate-voltage",
 };
 
+static struct bq27xxx_dm_reg bq27500_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 10, 2,    0, 65535 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { }, /* missing on chip */
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 48, 2, 1000, 32767 },
+};
+
+static struct bq27xxx_dm_reg bq27545_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 48, 23, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 48, 25, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 80, 67, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27421_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 10, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 16, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27425_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 12, 2,    0, 32767 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 14, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 18, 2, 2800,  3700 },
+};
+
+static struct bq27xxx_dm_reg bq27621_dm_regs[] = {
+     [BQ27XXX_DM_DESIGN_CAPACITY]   = { 82, 3, 2,    0,  8000 },
+     [BQ27XXX_DM_DESIGN_ENERGY]     = { 82, 5, 2,    0, 32767 },
+     [BQ27XXX_DM_TERMINATE_VOLTAGE] = { 82, 9, 2, 2500,  3700 },
+};
+
+static struct bq27xxx_dm_reg *bq27xxx_dm_regs[] = {
+     [BQ27500] = bq27500_dm_regs,
+     [BQ27545] = bq27545_dm_regs,
+     [BQ27421] = bq27421_dm_regs,
+     [BQ27425] = bq27425_dm_regs,
+     [BQ27441] = bq27421_dm_regs,
+     [BQ27621] = bq27621_dm_regs,
+};
+
+static u32 bq27xxx_unseal_keys[] = {
+     [BQ27500] = 0x04143672,
+     [BQ27545] = 0x04143672,
+     [BQ27421] = 0x80008000,
+     [BQ27425] = 0x04143672,
+     [BQ27441] = 0x80008000,
+     [BQ27621] = 0x80008000,
+};
+
 
 static int poll_interval_param_set(const char *val, const struct kernel_param *kp)
 {

@@ -1861,9 +1909,30 @@ int bq27xxx_battery_setup(struct bq27xxx_device_info *di)
              .drv_data = di,
      };
 
+     di->unseal_key = bq27xxx_unseal_keys[di->chip];
+     di->dm_regs = bq27xxx_dm_regs[di->chip];
+
+     switch(di->chip) {  /* translate members of categories */
+     case BQ2752X:
+             di->chip = BQ27510G3; break;
+     case BQ27531:
+             di->chip = BQ27530;   break;
+     case BQ27542:
+     case BQ27546:
+     case BQ27742:
+             di->chip = BQ27541;   break;
+     case BQ27425:
+     case BQ27441:
+     case BQ27621:
+             di->chip = BQ27421;   break;
+     default:
+             break;
+     }
+
+     di->regs = bq27xxx_regs[di->chip];
+
      INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
      mutex_init(&di->lock);
-     di->regs = bq27xxx_regs[di->chip];
 
      psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL);
      if (!psy_desc)

drivers/power/supply/bq27xxx_battery_i2c.c +8 -8

index a597221..0b11ed4 100644
@@ -230,7 +230,7 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27210", BQ27010 },
      { "bq27500", BQ2750X },
      { "bq27510", BQ2751X },
-     { "bq27520", BQ2751X },
+     { "bq27520", BQ2752X },
      { "bq27500-1", BQ27500 },
      { "bq27510g1", BQ27510G1 },
      { "bq27510g2", BQ27510G2 },

@@ -240,16 +240,16 @@ static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
      { "bq27520g3", BQ27520G3 },
      { "bq27520g4", BQ27520G4 },
      { "bq27530", BQ27530 },
-     { "bq27531", BQ27530 },
+     { "bq27531", BQ27531 },
      { "bq27541", BQ27541 },
-     { "bq27542", BQ27541 },
-     { "bq27546", BQ27541 },
-     { "bq27742", BQ27541 },
+     { "bq27542", BQ27542 },
+     { "bq27546", BQ27546 },
+     { "bq27742", BQ27742 },
      { "bq27545", BQ27545 },
      { "bq27421", BQ27421 },
-     { "bq27425", BQ27421 },
-     { "bq27441", BQ27421 },
-     { "bq27621", BQ27421 },
+     { "bq27425", BQ27425 },
+     { "bq27441", BQ27441 },
+     { "bq27621", BQ27621 },
      {},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);

include/linux/power/bq27xxx_battery.h +0 -0

index 227eb08..014e59f 100644
@@ -2,6 +2,7 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 

Quoted 15 lines

include/linux/power/bq27xxx_battery.h enum bq27xxx_chip { · line 23

Quoted 11 lines

include/linux/power/bq27xxx_battery.h +3 -0

 enum bq27xxx_chip {
+     /* categories; index for bq27xxx_regs[] */
      BQ27000 = 1, /* bq27000, bq27200 */
      BQ27010, /* bq27010, bq27210 */
      BQ2750X, /* bq27500 deprecated alias */

@@ -18,6 +19,16 @@ enum bq27xxx_chip {
      BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
      BQ27545, /* bq27545 */
      BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+
+     /* members of categories; translate these to category in _setup() */

These don't need to be separate from the others, these are valid chip IDs, we may use another compatible ID for register array index right now but these are not "categories".

The above were indeed treated like categories, as the I2C ID table mapped other chips to them. We could call them category|class "leaders" (prototypes? models? patterns?) instead.

Quoted 8 lines

Quoted 3 lines

The below are not valid in di->chip, they must be converted. So it makes sense to group them.

They are only "not valid" because you did not add tables for them. If you don't want to add register tables then think of a better way to map chip to register table. This is overly complex and will cause problems for people adding more chips.

This very mapping from category member -> prototype ID was done by the I2C table previously. How is doing it in a setup() switch any more complex?

Quoted 8 lines

The alternative mapping from chip to regs is this, which you said was there but replaced by a 2D array a while ago. Shall we revert to this?

  bq27xxx_regs[] = {
    [BQ27991] = bq27991_regs, // prototype
    [BQ27992] = bq27991_regs, // member
    ...

};

It's either that or add a second index into di, up to you. The easiest way is still, and always has been, to just add the extra tables. It would get this series reviewed faster, and we can remove redundant ones later when we pick a clean way of doing that.

Quoted 12 lines

Quoted 12 lines

Quoted 12 lines

Quoted 12 lines

Quoted 12 lines

include/linux/power/bq27xxx_battery.h +8 -0

+     BQ2752X, /* deprecated alias */
+     BQ27531,
+     BQ27542,
+     BQ27546,
+     BQ27742,
+     BQ27425,
+     BQ27441,
+     BQ27621,
 };
 
 /**