[PATCH 0/8] Add support for additional bq27xxx devices

[PATCH 0/8] Add support for additional bq27xxx devices

[Andrew F. Davis]

This series adds support for several additional bq27xxx devices and 
makes a few related fixes.

Andrew F. Davis (8):
  power: bq27x00_battery: Add manufacturer property
  power: bq27x00_battery: Fix lines over 80 characters long
  power: bq27x00_battery: Fix function parameter alignment
  power: bq27x00_battery: Checkpatch fixes
  power: bq27x00_battery: Renaming for consistency
  power: bq27xxx_battery: Fix typos and change naming for state of
    charge functions
  power: bq27xxx_battery: Add support for additional bq27xxx family
    devices
  power: bq27xxx_battery: Cleanup health checking

 MAINTAINERS                                        |    4 +-
 arch/arm/configs/omap2plus_defconfig               |    2 +-
 arch/unicore32/Kconfig                             |    2 +-
 drivers/power/Kconfig                              |   22 +-
 drivers/power/Makefile                             |    2 +-
 drivers/power/bq27x00_battery.c                    | 1122 ----------------
 drivers/power/bq27xxx_battery.c                    | 1350 ++++++++++++++++++++
 drivers/w1/slaves/w1_bq27000.c                     |    2 +-
 .../power/{bq27x00_battery.h => bq27xxx_battery.h} |    6 +-
 9 files changed, 1370 insertions(+), 1142 deletions(-)
 delete mode 100644 drivers/power/bq27x00_battery.c
 create mode 100644 drivers/power/bq27xxx_battery.c
 rename include/linux/power/{bq27x00_battery.h => bq27xxx_battery.h} (82%)

-- 
1.9.1

[PATCH 1/8] power: bq27x00_battery: Add manufacturer property

[Andrew F. Davis]

Add the manufacturer property to the bq27x00 driver.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27x00_battery.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
index b6b9837..2257bd4 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27x00_battery.c
@@ -41,6 +41,8 @@
 
 #define DRIVER_VERSION			"1.2.0"
 
+#define BQ27XXX_MANUFACTURER	"Texas Instruments"
+
 #define BQ27x00_REG_TEMP		0x06
 #define BQ27x00_REG_VOLT		0x08
 #define BQ27x00_REG_AI			0x14
@@ -142,6 +144,7 @@ static enum power_supply_property bq27x00_battery_props[] = {
 	POWER_SUPPLY_PROP_ENERGY_NOW,
 	POWER_SUPPLY_PROP_POWER_AVG,
 	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
 static enum power_supply_property bq27425_battery_props[] = {
@@ -156,6 +159,7 @@ static enum power_supply_property bq27425_battery_props[] = {
 	POWER_SUPPLY_PROP_CHARGE_FULL,
 	POWER_SUPPLY_PROP_CHARGE_NOW,
 	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
+	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
 static enum power_supply_property bq27742_battery_props[] = {
@@ -174,6 +178,7 @@ static enum power_supply_property bq27742_battery_props[] = {
 	POWER_SUPPLY_PROP_CYCLE_COUNT,
 	POWER_SUPPLY_PROP_POWER_AVG,
 	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
 static enum power_supply_property bq27510_battery_props[] = {
@@ -192,6 +197,7 @@ static enum power_supply_property bq27510_battery_props[] = {
 	POWER_SUPPLY_PROP_CYCLE_COUNT,
 	POWER_SUPPLY_PROP_POWER_AVG,
 	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
 static unsigned int poll_interval = 360;
@@ -749,6 +755,9 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
 	case POWER_SUPPLY_PROP_HEALTH:
 		ret = bq27x00_simple_value(di->cache.health, val);
 		break;
+	case POWER_SUPPLY_PROP_MANUFACTURER:
+		val->strval = BQ27XXX_MANUFACTURER;
+		break;
 	default:
 		return -EINVAL;
 	}
-- 
1.9.1

Re: [PATCH 1/8] power: bq27x00_battery: Add manufacturer property

[Dan Murphy]

On 07/22/2015 04:51 PM, Andrew F. Davis wrote:
> Add the manufacturer property to the bq27x00 driver.
>
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 9 +++++++++
>  1 file changed, 9 insertions(+)
>
> diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
> index b6b9837..2257bd4 100644
> --- a/drivers/power/bq27x00_battery.c
> +++ b/drivers/power/bq27x00_battery.c
> @@ -41,6 +41,8 @@
>  
>  #define DRIVER_VERSION			"1.2.0"
>  
> +#define BQ27XXX_MANUFACTURER	"Texas Instruments"
> +
>  #define BQ27x00_REG_TEMP		0x06
>  #define BQ27x00_REG_VOLT		0x08
>  #define BQ27x00_REG_AI			0x14
> @@ -142,6 +144,7 @@ static enum power_supply_property bq27x00_battery_props[] = {
>  	POWER_SUPPLY_PROP_ENERGY_NOW,
>  	POWER_SUPPLY_PROP_POWER_AVG,
>  	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
>  static enum power_supply_property bq27425_battery_props[] = {
> @@ -156,6 +159,7 @@ static enum power_supply_property bq27425_battery_props[] = {
>  	POWER_SUPPLY_PROP_CHARGE_FULL,
>  	POWER_SUPPLY_PROP_CHARGE_NOW,
>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
>  static enum power_supply_property bq27742_battery_props[] = {
> @@ -174,6 +178,7 @@ static enum power_supply_property bq27742_battery_props[] = {
>  	POWER_SUPPLY_PROP_CYCLE_COUNT,
>  	POWER_SUPPLY_PROP_POWER_AVG,
>  	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
>  static enum power_supply_property bq27510_battery_props[] = {
> @@ -192,6 +197,7 @@ static enum power_supply_property bq27510_battery_props[] = {
>  	POWER_SUPPLY_PROP_CYCLE_COUNT,
>  	POWER_SUPPLY_PROP_POWER_AVG,
>  	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
>  static unsigned int poll_interval = 360;
> @@ -749,6 +755,9 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
>  	case POWER_SUPPLY_PROP_HEALTH:
>  		ret = bq27x00_simple_value(di->cache.health, val);
>  		break;
> +	case POWER_SUPPLY_PROP_MANUFACTURER:
> +		val->strval = BQ27XXX_MANUFACTURER;
> +		break;
>  	default:
>  		return -EINVAL;
>  	}
Acked-by: Dan Murphy <dmurphy@ti.com>

-- 
------------------
Dan Murphy

Re: [PATCH 1/8] power: bq27x00_battery: Add manufacturer property

[Pali Rohár]

On Wednesday 22 July 2015 16:51:53 Andrew F. Davis wrote:
> Add the manufacturer property to the bq27x00 driver.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 9 +++++++++
>  1 file changed, 9 insertions(+)
> 

Acked-by: Pali Rohár <pali.rohar@gmail.com>

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 1/8] power: bq27x00_battery: Add manufacturer property

[Sebastian Reichel]

[-- Attachment #1: Type: text/plain, Size: 156 bytes --]

Hi,

On Wed, Jul 22, 2015 at 04:51:53PM -0500, Andrew F. Davis wrote:
> Add the manufacturer property to the bq27x00 driver.

Thanks, queued.

-- Sebastian

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

[PATCH 2/8] power: bq27x00_battery: Fix lines over 80 characters long

[Andrew F. Davis]

Shorted lines over 80 characters long by reducing tab count.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27x00_battery.c | 74 ++++++++++++++++++++---------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
index 2257bd4..203cf61 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27x00_battery.c
@@ -39,49 +39,49 @@
 
 #include <linux/power/bq27x00_battery.h>
 
-#define DRIVER_VERSION			"1.2.0"
+#define DRIVER_VERSION		"1.2.0"
 
 #define BQ27XXX_MANUFACTURER	"Texas Instruments"
 
-#define BQ27x00_REG_TEMP		0x06
-#define BQ27x00_REG_VOLT		0x08
-#define BQ27x00_REG_AI			0x14
-#define BQ27x00_REG_FLAGS		0x0A
-#define BQ27x00_REG_TTE			0x16
-#define BQ27x00_REG_TTF			0x18
-#define BQ27x00_REG_TTECP		0x26
-#define BQ27x00_REG_NAC			0x0C /* Nominal available capacity */
-#define BQ27x00_REG_LMD			0x12 /* Last measured discharge */
-#define BQ27x00_REG_CYCT		0x2A /* Cycle count total */
-#define BQ27x00_REG_AE			0x22 /* Available energy */
-#define BQ27x00_POWER_AVG		0x24
-
-#define BQ27000_REG_RSOC		0x0B /* Relative State-of-Charge */
-#define BQ27000_REG_ILMD		0x76 /* Initial last measured discharge */
-#define BQ27000_FLAG_EDVF		BIT(0) /* Final End-of-Discharge-Voltage flag */
-#define BQ27000_FLAG_EDV1		BIT(1) /* First End-of-Discharge-Voltage flag */
-#define BQ27000_FLAG_CI			BIT(4) /* Capacity Inaccurate flag */
-#define BQ27000_FLAG_FC			BIT(5)
-#define BQ27000_FLAG_CHGS		BIT(7) /* Charge state flag */
-
-#define BQ27500_REG_SOC			0x2C
-#define BQ27500_REG_DCAP		0x3C /* Design capacity */
-#define BQ27500_FLAG_DSC		BIT(0)
-#define BQ27500_FLAG_SOCF		BIT(1) /* State-of-Charge threshold final */
-#define BQ27500_FLAG_SOC1		BIT(2) /* State-of-Charge threshold 1 */
-#define BQ27500_FLAG_FC			BIT(9)
-#define BQ27500_FLAG_OTC		BIT(15)
-
-#define BQ27742_POWER_AVG		0x76
-
-#define BQ27510_REG_SOC			0x20
-#define BQ27510_REG_DCAP		0x2E /* Design capacity */
-#define BQ27510_REG_CYCT		0x1E /* Cycle count total */
+#define BQ27x00_REG_TEMP	0x06
+#define BQ27x00_REG_VOLT	0x08
+#define BQ27x00_REG_AI		0x14
+#define BQ27x00_REG_FLAGS	0x0A
+#define BQ27x00_REG_TTE		0x16
+#define BQ27x00_REG_TTF		0x18
+#define BQ27x00_REG_TTECP	0x26
+#define BQ27x00_REG_NAC		0x0C /* Nominal available capacity */
+#define BQ27x00_REG_LMD		0x12 /* Last measured discharge */
+#define BQ27x00_REG_CYCT	0x2A /* Cycle count total */
+#define BQ27x00_REG_AE		0x22 /* Available energy */
+#define BQ27x00_POWER_AVG	0x24
+
+#define BQ27000_REG_RSOC	0x0B /* Relative State-of-Charge */
+#define BQ27000_REG_ILMD	0x76 /* Initial last measured discharge */
+#define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
+#define BQ27000_FLAG_EDV1	BIT(1) /* First End-of-Discharge-Voltage flag */
+#define BQ27000_FLAG_CI		BIT(4) /* Capacity Inaccurate flag */
+#define BQ27000_FLAG_FC		BIT(5)
+#define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
+
+#define BQ27500_REG_SOC		0x2C
+#define BQ27500_REG_DCAP	0x3C /* Design capacity */
+#define BQ27500_FLAG_DSC	BIT(0)
+#define BQ27500_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
+#define BQ27500_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
+#define BQ27500_FLAG_FC		BIT(9)
+#define BQ27500_FLAG_OTC	BIT(15)
+
+#define BQ27742_POWER_AVG	0x76
+
+#define BQ27510_REG_SOC		0x20
+#define BQ27510_REG_DCAP	0x2E /* Design capacity */
+#define BQ27510_REG_CYCT	0x1E /* Cycle count total */
 
 /* bq27425 register addresses are same as bq27x00 addresses minus 4 */
-#define BQ27425_REG_OFFSET		0x04
+#define BQ27425_REG_OFFSET	0x04
 #define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
-#define BQ27425_REG_DCAP		(0x3C + BQ27425_REG_OFFSET)
+#define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
 
 #define BQ27000_RS			20 /* Resistor sense */
 #define BQ27x00_POWER_CONSTANT		(256 * 29200 / 1000)
-- 
1.9.1

Re: [PATCH 2/8] power: bq27x00_battery: Fix lines over 80 characters long

[Pali Rohár]

On Wednesday 22 July 2015 16:51:54 Andrew F. Davis wrote:
> Shorted lines over 80 characters long by reducing tab count.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 74 ++++++++++++++++++++---------------------
>  1 file changed, 37 insertions(+), 37 deletions(-)
> 

Acked-by: Pali Rohár <pali.rohar@gmail.com>

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 2/8] power: bq27x00_battery: Fix lines over 80 characters long

[Dan Murphy]

On 07/22/2015 04:51 PM, Andrew F. Davis wrote:
> Shorted lines over 80 characters long by reducing tab count.
>
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 74 ++++++++++++++++++++---------------------
>  1 file changed, 37 insertions(+), 37 deletions(-)
>
> diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
> index 2257bd4..203cf61 100644
> --- a/drivers/power/bq27x00_battery.c
> +++ b/drivers/power/bq27x00_battery.c
> @@ -39,49 +39,49 @@
>  
>  #include <linux/power/bq27x00_battery.h>
>  
> -#define DRIVER_VERSION			"1.2.0"
> +#define DRIVER_VERSION		"1.2.0"
>  
>  #define BQ27XXX_MANUFACTURER	"Texas Instruments"
>  
> -#define BQ27x00_REG_TEMP		0x06
> -#define BQ27x00_REG_VOLT		0x08
> -#define BQ27x00_REG_AI			0x14
> -#define BQ27x00_REG_FLAGS		0x0A
> -#define BQ27x00_REG_TTE			0x16
> -#define BQ27x00_REG_TTF			0x18
> -#define BQ27x00_REG_TTECP		0x26
> -#define BQ27x00_REG_NAC			0x0C /* Nominal available capacity */
> -#define BQ27x00_REG_LMD			0x12 /* Last measured discharge */
> -#define BQ27x00_REG_CYCT		0x2A /* Cycle count total */
> -#define BQ27x00_REG_AE			0x22 /* Available energy */
> -#define BQ27x00_POWER_AVG		0x24
> -
> -#define BQ27000_REG_RSOC		0x0B /* Relative State-of-Charge */
> -#define BQ27000_REG_ILMD		0x76 /* Initial last measured discharge */
> -#define BQ27000_FLAG_EDVF		BIT(0) /* Final End-of-Discharge-Voltage flag */
> -#define BQ27000_FLAG_EDV1		BIT(1) /* First End-of-Discharge-Voltage flag */
> -#define BQ27000_FLAG_CI			BIT(4) /* Capacity Inaccurate flag */
> -#define BQ27000_FLAG_FC			BIT(5)
> -#define BQ27000_FLAG_CHGS		BIT(7) /* Charge state flag */
> -
> -#define BQ27500_REG_SOC			0x2C
> -#define BQ27500_REG_DCAP		0x3C /* Design capacity */
> -#define BQ27500_FLAG_DSC		BIT(0)
> -#define BQ27500_FLAG_SOCF		BIT(1) /* State-of-Charge threshold final */
> -#define BQ27500_FLAG_SOC1		BIT(2) /* State-of-Charge threshold 1 */
> -#define BQ27500_FLAG_FC			BIT(9)
> -#define BQ27500_FLAG_OTC		BIT(15)
> -
> -#define BQ27742_POWER_AVG		0x76
> -
> -#define BQ27510_REG_SOC			0x20
> -#define BQ27510_REG_DCAP		0x2E /* Design capacity */
> -#define BQ27510_REG_CYCT		0x1E /* Cycle count total */
> +#define BQ27x00_REG_TEMP	0x06
> +#define BQ27x00_REG_VOLT	0x08
> +#define BQ27x00_REG_AI		0x14
> +#define BQ27x00_REG_FLAGS	0x0A
> +#define BQ27x00_REG_TTE		0x16
> +#define BQ27x00_REG_TTF		0x18
> +#define BQ27x00_REG_TTECP	0x26
> +#define BQ27x00_REG_NAC		0x0C /* Nominal available capacity */
> +#define BQ27x00_REG_LMD		0x12 /* Last measured discharge */
> +#define BQ27x00_REG_CYCT	0x2A /* Cycle count total */
> +#define BQ27x00_REG_AE		0x22 /* Available energy */
> +#define BQ27x00_POWER_AVG	0x24
> +
> +#define BQ27000_REG_RSOC	0x0B /* Relative State-of-Charge */
> +#define BQ27000_REG_ILMD	0x76 /* Initial last measured discharge */
> +#define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
> +#define BQ27000_FLAG_EDV1	BIT(1) /* First End-of-Discharge-Voltage flag */
> +#define BQ27000_FLAG_CI		BIT(4) /* Capacity Inaccurate flag */
> +#define BQ27000_FLAG_FC		BIT(5)
> +#define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
> +
> +#define BQ27500_REG_SOC		0x2C
> +#define BQ27500_REG_DCAP	0x3C /* Design capacity */
> +#define BQ27500_FLAG_DSC	BIT(0)
> +#define BQ27500_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
> +#define BQ27500_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
> +#define BQ27500_FLAG_FC		BIT(9)
> +#define BQ27500_FLAG_OTC	BIT(15)
> +
> +#define BQ27742_POWER_AVG	0x76
> +
> +#define BQ27510_REG_SOC		0x20
> +#define BQ27510_REG_DCAP	0x2E /* Design capacity */
> +#define BQ27510_REG_CYCT	0x1E /* Cycle count total */
>  
>  /* bq27425 register addresses are same as bq27x00 addresses minus 4 */
> -#define BQ27425_REG_OFFSET		0x04
> +#define BQ27425_REG_OFFSET	0x04
>  #define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
> -#define BQ27425_REG_DCAP		(0x3C + BQ27425_REG_OFFSET)
> +#define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
>  
>  #define BQ27000_RS			20 /* Resistor sense */
>  #define BQ27x00_POWER_CONSTANT		(256 * 29200 / 1000)

Acked-by: Dan Murphy <dmurphy@ti.com>


-- 
------------------
Dan Murphy

Re: [PATCH 2/8] power: bq27x00_battery: Fix lines over 80 characters long

[Sebastian Reichel]

[-- Attachment #1: Type: text/plain, Size: 164 bytes --]

Hi,

On Wed, Jul 22, 2015 at 04:51:54PM -0500, Andrew F. Davis wrote:
> Shorted lines over 80 characters long by reducing tab count.

Thanks, queued.

-- Sebastian

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

[PATCH 3/8] power: bq27x00_battery: Fix function parameter alignment

[Andrew F. Davis]

Fix the alignment of function parameters on new lines.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27x00_battery.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
index 203cf61..9cdad19 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27x00_battery.c
@@ -210,7 +210,7 @@ MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
  */
 
 static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
-		bool single)
+			       bool single)
 {
 	if (di->chip == BQ27425)
 		return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
@@ -565,7 +565,7 @@ static void bq27x00_battery_poll(struct work_struct *work)
  * Or 0 if something fails.
  */
 static int bq27x00_battery_current(struct bq27x00_device_info *di,
-	union power_supply_propval *val)
+				   union power_supply_propval *val)
 {
 	int curr;
 	int flags;
@@ -593,7 +593,7 @@ static int bq27x00_battery_current(struct bq27x00_device_info *di,
 }
 
 static int bq27x00_battery_status(struct bq27x00_device_info *di,
-	union power_supply_propval *val)
+				  union power_supply_propval *val)
 {
 	int status;
 
@@ -621,7 +621,7 @@ static int bq27x00_battery_status(struct bq27x00_device_info *di,
 }
 
 static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
-	union power_supply_propval *val)
+					  union power_supply_propval *val)
 {
 	int level;
 
@@ -655,7 +655,7 @@ static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
  * Or < 0 if something fails.
  */
 static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
-	union power_supply_propval *val)
+				   union power_supply_propval *val)
 {
 	int volt;
 
@@ -671,7 +671,7 @@ static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
 }
 
 static int bq27x00_simple_value(int value,
-	union power_supply_propval *val)
+				union power_supply_propval *val)
 {
 	if (value < 0)
 		return value;
@@ -987,7 +987,7 @@ static inline void bq27x00_battery_i2c_exit(void) {};
 #ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
 
 static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
-			bool single)
+				 bool single)
 {
 	struct device *dev = di->dev;
 	struct bq27000_platform_data *pdata = dev->platform_data;
-- 
1.9.1

Re: [PATCH 3/8] power: bq27x00_battery: Fix function parameter alignment

[Pali Rohár]

On Wednesday 22 July 2015 16:51:55 Andrew F. Davis wrote:
> Fix the alignment of function parameters on new lines.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 14 +++++++-------
>  1 file changed, 7 insertions(+), 7 deletions(-)
> 

Acked-by: Pali Rohár <pali.rohar@gmail.com>

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 3/8] power: bq27x00_battery: Fix function parameter alignment

[Dan Murphy]

On 07/22/2015 04:51 PM, Andrew F. Davis wrote:
> Fix the alignment of function parameters on new lines.
>
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 14 +++++++-------
>  1 file changed, 7 insertions(+), 7 deletions(-)
>
> diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
> index 203cf61..9cdad19 100644
> --- a/drivers/power/bq27x00_battery.c
> +++ b/drivers/power/bq27x00_battery.c
> @@ -210,7 +210,7 @@ MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
>   */
>  
>  static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
> -		bool single)
> +			       bool single)
>  {
>  	if (di->chip == BQ27425)
>  		return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
> @@ -565,7 +565,7 @@ static void bq27x00_battery_poll(struct work_struct *work)
>   * Or 0 if something fails.
>   */
>  static int bq27x00_battery_current(struct bq27x00_device_info *di,
> -	union power_supply_propval *val)
> +				   union power_supply_propval *val)
>  {
>  	int curr;
>  	int flags;
> @@ -593,7 +593,7 @@ static int bq27x00_battery_current(struct bq27x00_device_info *di,
>  }
>  
>  static int bq27x00_battery_status(struct bq27x00_device_info *di,
> -	union power_supply_propval *val)
> +				  union power_supply_propval *val)
>  {
>  	int status;
>  
> @@ -621,7 +621,7 @@ static int bq27x00_battery_status(struct bq27x00_device_info *di,
>  }
>  
>  static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
> -	union power_supply_propval *val)
> +					  union power_supply_propval *val)
>  {
>  	int level;
>  
> @@ -655,7 +655,7 @@ static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
>   * Or < 0 if something fails.
>   */
>  static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
> -	union power_supply_propval *val)
> +				   union power_supply_propval *val)
>  {
>  	int volt;
>  
> @@ -671,7 +671,7 @@ static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
>  }
>  
>  static int bq27x00_simple_value(int value,
> -	union power_supply_propval *val)
> +				union power_supply_propval *val)
>  {
>  	if (value < 0)
>  		return value;
> @@ -987,7 +987,7 @@ static inline void bq27x00_battery_i2c_exit(void) {};
>  #ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
>  
>  static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
> -			bool single)
> +				 bool single)
>  {
>  	struct device *dev = di->dev;
>  	struct bq27000_platform_data *pdata = dev->platform_data;

Acked-by: Dan Murphy <dmurphy@ti.com>


-- 
------------------
Dan Murphy

Re: [PATCH 3/8] power: bq27x00_battery: Fix function parameter alignment

[Sebastian Reichel]

[-- Attachment #1: Type: text/plain, Size: 158 bytes --]

Hi,

On Wed, Jul 22, 2015 at 04:51:55PM -0500, Andrew F. Davis wrote:
> Fix the alignment of function parameters on new lines.

Thanks, queued.

-- Sebastian

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

[PATCH 4/8] power: bq27x00_battery: Checkpatch fixes

[Andrew F. Davis]

Remove space before tab.
Remove unnecessary line continuations.
Add braces to else statement.
Remove unnecessary parentheses.
Remove unneeded blank lines.
Remove unnecessary 'out of memory' message.
Add missing line after declarations.
Change use of printk to pr_err.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27x00_battery.c | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
index 9cdad19..8287261f 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27x00_battery.c
@@ -108,7 +108,7 @@ struct bq27x00_reg_cache {
 };
 
 struct bq27x00_device_info {
-	struct device 		*dev;
+	struct device		*dev;
 	int			id;
 	enum bq27x00_chip	chip;
 
@@ -202,8 +202,8 @@ static enum power_supply_property bq27510_battery_props[] = {
 
 static unsigned int poll_interval = 360;
 module_param(poll_interval, uint, 0644);
-MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
-				"0 disables polling");
+MODULE_PARM_DESC(poll_interval,
+		 "battery poll interval in seconds - 0 disables polling");
 
 /*
  * Common code for BQ27x00 devices
@@ -319,8 +319,9 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
 			ilmd = bq27x00_read(di, BQ27510_REG_DCAP, false);
 		else
 			ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
-	} else
+	} else {
 		ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
+	}
 
 	if (ilmd < 0) {
 		dev_dbg(di->dev, "error reading initial last measured discharge\n");
@@ -451,7 +452,7 @@ static int bq27x00_battery_read_health(struct bq27x00_device_info *di)
 		return tval;
 	}
 
-	if ((di->chip == BQ27500)) {
+	if (di->chip == BQ27500) {
 		if (tval & BQ27500_FLAG_SOCF)
 			tval = POWER_SUPPLY_HEALTH_DEAD;
 		else if (tval & BQ27500_FLAG_OTC)
@@ -836,7 +837,6 @@ static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
 	mutex_destroy(&di->lock);
 }
 
-
 /* i2c specific code */
 #ifdef CONFIG_BATTERY_BQ27X00_I2C
 
@@ -897,14 +897,12 @@ static int bq27x00_battery_probe(struct i2c_client *client,
 
 	name = devm_kasprintf(&client->dev, GFP_KERNEL, "%s-%d", id->name, num);
 	if (!name) {
-		dev_err(&client->dev, "failed to allocate device name\n");
 		retval = -ENOMEM;
 		goto batt_failed;
 	}
 
 	di = devm_kzalloc(&client->dev, sizeof(*di), GFP_KERNEL);
 	if (!di) {
-		dev_err(&client->dev, "failed to allocate device info data\n");
 		retval = -ENOMEM;
 		goto batt_failed;
 	}
@@ -965,8 +963,9 @@ static struct i2c_driver bq27x00_battery_driver = {
 static inline int bq27x00_battery_i2c_init(void)
 {
 	int ret = i2c_add_driver(&bq27x00_battery_driver);
+
 	if (ret)
-		printk(KERN_ERR "Unable to register BQ27x00 i2c driver\n");
+		pr_err("Unable to register BQ27x00 i2c driver\n");
 
 	return ret;
 }
@@ -1037,10 +1036,8 @@ static int bq27000_battery_probe(struct platform_device *pdev)
 	}
 
 	di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
-	if (!di) {
-		dev_err(&pdev->dev, "failed to allocate device info data\n");
+	if (!di)
 		return -ENOMEM;
-	}
 
 	platform_set_drvdata(pdev, di);
 
@@ -1073,8 +1070,9 @@ static struct platform_driver bq27000_battery_driver = {
 static inline int bq27x00_battery_platform_init(void)
 {
 	int ret = platform_driver_register(&bq27000_battery_driver);
+
 	if (ret)
-		printk(KERN_ERR "Unable to register BQ27000 platform driver\n");
+		pr_err("Unable to register BQ27000 platform driver\n");
 
 	return ret;
 }
-- 
1.9.1

Re: [PATCH 4/8] power: bq27x00_battery: Checkpatch fixes

[Pali Rohár]

On Wednesday 22 July 2015 16:51:56 Andrew F. Davis wrote:
> Remove space before tab.
> Remove unnecessary line continuations.
> Add braces to else statement.
> Remove unnecessary parentheses.
> Remove unneeded blank lines.
> Remove unnecessary 'out of memory' message.
> Add missing line after declarations.
> Change use of printk to pr_err.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 24 +++++++++++-------------
>  1 file changed, 11 insertions(+), 13 deletions(-)
> 

Acked-by: Pali Rohár <pali.rohar@gmail.com>

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 4/8] power: bq27x00_battery: Checkpatch fixes

[Dan Murphy]

On 07/22/2015 04:51 PM, Andrew F. Davis wrote:
> Remove space before tab.
> Remove unnecessary line continuations.
> Add braces to else statement.
> Remove unnecessary parentheses.
> Remove unneeded blank lines.
> Remove unnecessary 'out of memory' message.
> Add missing line after declarations.
> Change use of printk to pr_err.
>
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27x00_battery.c | 24 +++++++++++-------------
>  1 file changed, 11 insertions(+), 13 deletions(-)
>
> diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
> index 9cdad19..8287261f 100644
> --- a/drivers/power/bq27x00_battery.c
> +++ b/drivers/power/bq27x00_battery.c
> @@ -108,7 +108,7 @@ struct bq27x00_reg_cache {
>  };
>  
>  struct bq27x00_device_info {
> -	struct device 		*dev;
> +	struct device		*dev;
>  	int			id;
>  	enum bq27x00_chip	chip;
>  
> @@ -202,8 +202,8 @@ static enum power_supply_property bq27510_battery_props[] = {
>  
>  static unsigned int poll_interval = 360;
>  module_param(poll_interval, uint, 0644);
> -MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
> -				"0 disables polling");
> +MODULE_PARM_DESC(poll_interval,
> +		 "battery poll interval in seconds - 0 disables polling");
>  
>  /*
>   * Common code for BQ27x00 devices
> @@ -319,8 +319,9 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
>  			ilmd = bq27x00_read(di, BQ27510_REG_DCAP, false);
>  		else
>  			ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
> -	} else
> +	} else {
>  		ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
> +	}
>  
>  	if (ilmd < 0) {
>  		dev_dbg(di->dev, "error reading initial last measured discharge\n");
> @@ -451,7 +452,7 @@ static int bq27x00_battery_read_health(struct bq27x00_device_info *di)
>  		return tval;
>  	}
>  
> -	if ((di->chip == BQ27500)) {
> +	if (di->chip == BQ27500) {
>  		if (tval & BQ27500_FLAG_SOCF)
>  			tval = POWER_SUPPLY_HEALTH_DEAD;
>  		else if (tval & BQ27500_FLAG_OTC)
> @@ -836,7 +837,6 @@ static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
>  	mutex_destroy(&di->lock);
>  }
>  
> -
>  /* i2c specific code */
>  #ifdef CONFIG_BATTERY_BQ27X00_I2C
>  
> @@ -897,14 +897,12 @@ static int bq27x00_battery_probe(struct i2c_client *client,
>  
>  	name = devm_kasprintf(&client->dev, GFP_KERNEL, "%s-%d", id->name, num);
>  	if (!name) {
> -		dev_err(&client->dev, "failed to allocate device name\n");
>  		retval = -ENOMEM;
>  		goto batt_failed;
>  	}
>  
>  	di = devm_kzalloc(&client->dev, sizeof(*di), GFP_KERNEL);
>  	if (!di) {
> -		dev_err(&client->dev, "failed to allocate device info data\n");
>  		retval = -ENOMEM;
>  		goto batt_failed;
>  	}
> @@ -965,8 +963,9 @@ static struct i2c_driver bq27x00_battery_driver = {
>  static inline int bq27x00_battery_i2c_init(void)
>  {
>  	int ret = i2c_add_driver(&bq27x00_battery_driver);
> +
>  	if (ret)
> -		printk(KERN_ERR "Unable to register BQ27x00 i2c driver\n");
> +		pr_err("Unable to register BQ27x00 i2c driver\n");
>  
>  	return ret;
>  }
> @@ -1037,10 +1036,8 @@ static int bq27000_battery_probe(struct platform_device *pdev)
>  	}
>  
>  	di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
> -	if (!di) {
> -		dev_err(&pdev->dev, "failed to allocate device info data\n");
> +	if (!di)
>  		return -ENOMEM;
> -	}
>  
>  	platform_set_drvdata(pdev, di);
>  
> @@ -1073,8 +1070,9 @@ static struct platform_driver bq27000_battery_driver = {
>  static inline int bq27x00_battery_platform_init(void)
>  {
>  	int ret = platform_driver_register(&bq27000_battery_driver);
> +
>  	if (ret)
> -		printk(KERN_ERR "Unable to register BQ27000 platform driver\n");
> +		pr_err("Unable to register BQ27000 platform driver\n");
>  
>  	return ret;

Just a nitpick and I realize this is a checkpatch fix patch but does it make sense just to
return the status of platform_driver_register?  Unless the message is useful

Dan


>  }

Acked-by: Dan Murphy <dmurphy@ti.com>


-- 
------------------
Dan Murphy

Re: [PATCH 4/8] power: bq27x00_battery: Checkpatch fixes

[Sebastian Reichel]

[-- Attachment #1: Type: text/plain, Size: 385 bytes --]

Hi,

On Wed, Jul 22, 2015 at 04:51:56PM -0500, Andrew F. Davis wrote:
> Remove space before tab.
> Remove unnecessary line continuations.
> Add braces to else statement.
> Remove unnecessary parentheses.
> Remove unneeded blank lines.
> Remove unnecessary 'out of memory' message.
> Add missing line after declarations.
> Change use of printk to pr_err.

Thanks, queued.

-- Sebastian

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

[PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Andrew F. Davis]

Rename functions that are used by multiple devices. New devices
have been added and the function names and driver name are no longer
general enough for the functionality they provide.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 MAINTAINERS                                        |   4 +-
 arch/arm/configs/omap2plus_defconfig               |   2 +-
 arch/unicore32/Kconfig                             |   2 +-
 drivers/power/Kconfig                              |  22 +-
 drivers/power/Makefile                             |   2 +-
 .../power/{bq27x00_battery.c => bq27xxx_battery.c} | 339 +++++++++++----------
 drivers/w1/slaves/w1_bq27000.c                     |   2 +-
 .../power/{bq27x00_battery.h => bq27xxx_battery.h} |   6 +-
 8 files changed, 190 insertions(+), 189 deletions(-)
 rename drivers/power/{bq27x00_battery.c => bq27xxx_battery.c} (70%)
 rename include/linux/power/{bq27x00_battery.h => bq27xxx_battery.h} (82%)

diff --git a/MAINTAINERS b/MAINTAINERS
index fd60784..9baf4e8 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -7226,10 +7226,10 @@ NOKIA N900 POWER SUPPLY DRIVERS
 M:	Pali Rohár <pali.rohar@gmail.com>
 S:	Maintained
 F:	include/linux/power/bq2415x_charger.h
-F:	include/linux/power/bq27x00_battery.h
+F:	include/linux/power/bq27xxx_battery.h
 F:	include/linux/power/isp1704_charger.h
 F:	drivers/power/bq2415x_charger.c
-F:	drivers/power/bq27x00_battery.c
+F:	drivers/power/bq27xxx_battery.c
 F:	drivers/power/isp1704_charger.c
 F:	drivers/power/rx51_battery.c
 
diff --git a/arch/arm/configs/omap2plus_defconfig b/arch/arm/configs/omap2plus_defconfig
index ac521e7..a79232c 100644
--- a/arch/arm/configs/omap2plus_defconfig
+++ b/arch/arm/configs/omap2plus_defconfig
@@ -241,7 +241,7 @@ CONFIG_GPIO_TWL4030=y
 CONFIG_GPIO_PALMAS=y
 CONFIG_W1=m
 CONFIG_HDQ_MASTER_OMAP=m
-CONFIG_BATTERY_BQ27x00=m
+CONFIG_BATTERY_BQ27XXX=m
 CONFIG_CHARGER_ISP1704=m
 CONFIG_CHARGER_TWL4030=m
 CONFIG_CHARGER_BQ2415X=m
diff --git a/arch/unicore32/Kconfig b/arch/unicore32/Kconfig
index 928237a..c9faddc 100644
--- a/arch/unicore32/Kconfig
+++ b/arch/unicore32/Kconfig
@@ -222,7 +222,7 @@ config I2C_BATTERY_BQ27200
 	tristate "I2C Battery BQ27200 Support"
 	select I2C_PUV3
 	select POWER_SUPPLY
-	select BATTERY_BQ27x00
+	select BATTERY_BQ27XXX
 
 config I2C_EEPROM_AT24
 	tristate "I2C EEPROMs AT24 support"
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 08beeed..cafcfe2 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -157,26 +157,26 @@ config BATTERY_SBS
 	  Say Y to include support for SBS battery driver for SBS-compliant
 	  gas gauges.
 
-config BATTERY_BQ27x00
-	tristate "BQ27x00 battery driver"
+config BATTERY_BQ27XXX
+	tristate "BQ27xxx battery driver"
 	depends on I2C || I2C=n
 	help
-	  Say Y here to enable support for batteries with BQ27x00 (I2C/HDQ) chips.
+	  Say Y here to enable support for batteries with BQ27xxx (I2C/HDQ) chips.
 
-config BATTERY_BQ27X00_I2C
-	bool "BQ27200/BQ27500 support"
-	depends on BATTERY_BQ27x00
+config BATTERY_BQ27XXX_I2C
+	bool "BQ27xxx I2C support"
+	depends on BATTERY_BQ27XXX
 	depends on I2C
 	default y
 	help
-	  Say Y here to enable support for batteries with BQ27x00 (I2C) chips.
+	  Say Y here to enable support for batteries with BQ27xxx (I2C) chips.
 
-config BATTERY_BQ27X00_PLATFORM
-	bool "BQ27000 support"
-	depends on BATTERY_BQ27x00
+config BATTERY_BQ27XXX_PLATFORM
+	bool "BQ27xxx HDQ support"
+	depends on BATTERY_BQ27XXX
 	default y
 	help
-	  Say Y here to enable support for batteries with BQ27000 (HDQ) chips.
+	  Say Y here to enable support for batteries with BQ27xxx (HDQ) chips.
 
 config BATTERY_DA9030
 	tristate "DA9030 battery driver"
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 5752ce8..7a5bc96 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -29,7 +29,7 @@ obj-$(CONFIG_BATTERY_COLLIE)	+= collie_battery.o
 obj-$(CONFIG_BATTERY_IPAQ_MICRO) += ipaq_micro_battery.o
 obj-$(CONFIG_BATTERY_WM97XX)	+= wm97xx_battery.o
 obj-$(CONFIG_BATTERY_SBS)	+= sbs-battery.o
-obj-$(CONFIG_BATTERY_BQ27x00)	+= bq27x00_battery.o
+obj-$(CONFIG_BATTERY_BQ27XXX)	+= bq27xxx_battery.o
 obj-$(CONFIG_BATTERY_DA9030)	+= da9030_battery.o
 obj-$(CONFIG_BATTERY_DA9052)	+= da9052-battery.o
 obj-$(CONFIG_CHARGER_DA9150)	+= da9150-charger.o
diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27xxx_battery.c
similarity index 70%
rename from drivers/power/bq27x00_battery.c
rename to drivers/power/bq27xxx_battery.c
index 8287261f..f5d7a137 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27xxx_battery.c
@@ -1,5 +1,5 @@
 /*
- * BQ27x00 battery driver
+ * BQ27xxx battery driver
  *
  * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
  * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
@@ -37,7 +37,7 @@
 #include <linux/slab.h>
 #include <asm/unaligned.h>
 
-#include <linux/power/bq27x00_battery.h>
+#include <linux/power/bq27xxx_battery.h>
 
 #define DRIVER_VERSION		"1.2.0"
 
@@ -83,17 +83,17 @@
 #define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
 #define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
 
-#define BQ27000_RS			20 /* Resistor sense */
-#define BQ27x00_POWER_CONSTANT		(256 * 29200 / 1000)
+#define BQ27XXX_RS			20 /* Resistor sense */
+#define BQ27XXX_POWER_CONSTANT		(256 * 29200 / 1000)
 
-struct bq27x00_device_info;
-struct bq27x00_access_methods {
-	int (*read)(struct bq27x00_device_info *di, u8 reg, bool single);
+struct bq27xxx_device_info;
+struct bq27xxx_access_methods {
+	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
 };
 
-enum bq27x00_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
+enum bq27xxx_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
 
-struct bq27x00_reg_cache {
+struct bq27xxx_reg_cache {
 	int temperature;
 	int time_to_empty;
 	int time_to_empty_avg;
@@ -107,12 +107,12 @@ struct bq27x00_reg_cache {
 	int health;
 };
 
-struct bq27x00_device_info {
+struct bq27xxx_device_info {
 	struct device		*dev;
 	int			id;
-	enum bq27x00_chip	chip;
+	enum bq27xxx_chip	chip;
 
-	struct bq27x00_reg_cache cache;
+	struct bq27xxx_reg_cache cache;
 	int charge_design_full;
 
 	unsigned long last_update;
@@ -120,7 +120,7 @@ struct bq27x00_device_info {
 
 	struct power_supply	*bat;
 
-	struct bq27x00_access_methods bus;
+	struct bq27xxx_access_methods bus;
 
 	struct mutex lock;
 };
@@ -206,10 +206,10 @@ MODULE_PARM_DESC(poll_interval,
 		 "battery poll interval in seconds - 0 disables polling");
 
 /*
- * Common code for BQ27x00 devices
+ * Common code for BQ27xxx devices
  */
 
-static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
+static inline int bq27xxx_read(struct bq27xxx_device_info *di, u8 reg,
 			       bool single)
 {
 	if (di->chip == BQ27425)
@@ -222,7 +222,7 @@ static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
  * differ from BQ27000 and BQ27200 in calculation of certain
  * parameters. Hence we need to check for the chip type.
  */
-static bool bq27xxx_is_chip_version_higher(struct bq27x00_device_info *di)
+static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
 {
 	if (di->chip == BQ27425 || di->chip == BQ27500 || di->chip == BQ27742
 	    || di->chip == BQ27510)
@@ -234,18 +234,18 @@ static bool bq27xxx_is_chip_version_higher(struct bq27x00_device_info *di)
  * Return the battery Relative State-of-Charge
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
+static int bq27xxx_battery_read_rsoc(struct bq27xxx_device_info *di)
 {
 	int rsoc;
 
 	if (di->chip == BQ27500 || di->chip == BQ27742)
-		rsoc = bq27x00_read(di, BQ27500_REG_SOC, false);
+		rsoc = bq27xxx_read(di, BQ27500_REG_SOC, false);
 	else if (di->chip == BQ27510)
-		rsoc = bq27x00_read(di, BQ27510_REG_SOC, false);
+		rsoc = bq27xxx_read(di, BQ27510_REG_SOC, false);
 	else if (di->chip == BQ27425)
-		rsoc = bq27x00_read(di, BQ27425_REG_SOC, false);
+		rsoc = bq27xxx_read(di, BQ27425_REG_SOC, false);
 	else
-		rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true);
+		rsoc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
 
 	if (rsoc < 0)
 		dev_dbg(di->dev, "error reading relative State-of-Charge\n");
@@ -257,11 +257,11 @@ static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
  * Return a battery charge value in µAh
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
+static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
 {
 	int charge;
 
-	charge = bq27x00_read(di, reg, false);
+	charge = bq27xxx_read(di, reg, false);
 	if (charge < 0) {
 		dev_dbg(di->dev, "error reading charge register %02x: %d\n",
 			reg, charge);
@@ -271,7 +271,7 @@ static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
 	if (bq27xxx_is_chip_version_higher(di))
 		charge *= 1000;
 	else
-		charge = charge * 3570 / BQ27000_RS;
+		charge = charge * 3570 / BQ27XXX_RS;
 
 	return charge;
 }
@@ -280,7 +280,7 @@ static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
  * Return the battery Nominal available capaciy in µAh
  * Or < 0 if something fails.
  */
-static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di)
+static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
 {
 	int flags;
 	bool is_bq27500 = di->chip == BQ27500;
@@ -288,39 +288,39 @@ static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di)
 	bool is_higher = bq27xxx_is_chip_version_higher(di);
 	bool flags_1b = !(is_bq27500 || is_bq27742);
 
-	flags = bq27x00_read(di, BQ27x00_REG_FLAGS, flags_1b);
+	flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
 	if (flags >= 0 && !is_higher && (flags & BQ27000_FLAG_CI))
 		return -ENODATA;
 
-	return bq27x00_battery_read_charge(di, BQ27x00_REG_NAC);
+	return bq27xxx_battery_read_charge(di, BQ27x00_REG_NAC);
 }
 
 /*
  * Return the battery Last measured discharge in µAh
  * Or < 0 if something fails.
  */
-static inline int bq27x00_battery_read_lmd(struct bq27x00_device_info *di)
+static inline int bq27xxx_battery_read_lmd(struct bq27xxx_device_info *di)
 {
-	return bq27x00_battery_read_charge(di, BQ27x00_REG_LMD);
+	return bq27xxx_battery_read_charge(di, BQ27x00_REG_LMD);
 }
 
 /*
  * Return the battery Initial last measured discharge in µAh
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
+static int bq27xxx_battery_read_ilmd(struct bq27xxx_device_info *di)
 {
 	int ilmd;
 
 	if (bq27xxx_is_chip_version_higher(di)) {
 		if (di->chip == BQ27425)
-			ilmd = bq27x00_read(di, BQ27425_REG_DCAP, false);
+			ilmd = bq27xxx_read(di, BQ27425_REG_DCAP, false);
 		else if (di->chip == BQ27510)
-			ilmd = bq27x00_read(di, BQ27510_REG_DCAP, false);
+			ilmd = bq27xxx_read(di, BQ27510_REG_DCAP, false);
 		else
-			ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
+			ilmd = bq27xxx_read(di, BQ27500_REG_DCAP, false);
 	} else {
-		ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
+		ilmd = bq27xxx_read(di, BQ27000_REG_ILMD, true);
 	}
 
 	if (ilmd < 0) {
@@ -331,7 +331,7 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
 	if (bq27xxx_is_chip_version_higher(di))
 		ilmd *= 1000;
 	else
-		ilmd = ilmd * 256 * 3570 / BQ27000_RS;
+		ilmd = ilmd * 256 * 3570 / BQ27XXX_RS;
 
 	return ilmd;
 }
@@ -340,11 +340,11 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
  * Return the battery Available energy in µWh
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
+static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
 {
 	int ae;
 
-	ae = bq27x00_read(di, BQ27x00_REG_AE, false);
+	ae = bq27xxx_read(di, BQ27x00_REG_AE, false);
 	if (ae < 0) {
 		dev_dbg(di->dev, "error reading available energy\n");
 		return ae;
@@ -353,7 +353,7 @@ static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
 	if (di->chip == BQ27500)
 		ae *= 1000;
 	else
-		ae = ae * 29200 / BQ27000_RS;
+		ae = ae * 29200 / BQ27XXX_RS;
 
 	return ae;
 }
@@ -362,11 +362,11 @@ static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
  * Return the battery temperature in tenths of degree Kelvin
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di)
+static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
 {
 	int temp;
 
-	temp = bq27x00_read(di, BQ27x00_REG_TEMP, false);
+	temp = bq27xxx_read(di, BQ27x00_REG_TEMP, false);
 	if (temp < 0) {
 		dev_err(di->dev, "error reading temperature\n");
 		return temp;
@@ -382,14 +382,14 @@ static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di)
  * Return the battery Cycle count total
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di)
+static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
 {
 	int cyct;
 
 	if (di->chip == BQ27510)
-		cyct = bq27x00_read(di, BQ27510_REG_CYCT, false);
+		cyct = bq27xxx_read(di, BQ27510_REG_CYCT, false);
 	else
-		cyct = bq27x00_read(di, BQ27x00_REG_CYCT, false);
+		cyct = bq27xxx_read(di, BQ27x00_REG_CYCT, false);
 	if (cyct < 0)
 		dev_err(di->dev, "error reading cycle count total\n");
 
@@ -400,11 +400,11 @@ static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di)
  * Read a time register.
  * Return < 0 if something fails.
  */
-static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)
+static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
 {
 	int tval;
 
-	tval = bq27x00_read(di, reg, false);
+	tval = bq27xxx_read(di, reg, false);
 	if (tval < 0) {
 		dev_dbg(di->dev, "error reading time register %02x: %d\n",
 			reg, tval);
@@ -421,11 +421,11 @@ static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)
  * Read a power avg register.
  * Return < 0 if something fails.
  */
-static int bq27x00_battery_read_pwr_avg(struct bq27x00_device_info *di, u8 reg)
+static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
 {
 	int tval;
 
-	tval = bq27x00_read(di, reg, false);
+	tval = bq27xxx_read(di, reg, false);
 	if (tval < 0) {
 		dev_err(di->dev, "error reading power avg rgister  %02x: %d\n",
 			reg, tval);
@@ -435,18 +435,18 @@ static int bq27x00_battery_read_pwr_avg(struct bq27x00_device_info *di, u8 reg)
 	if (di->chip == BQ27500)
 		return tval;
 	else
-		return (tval * BQ27x00_POWER_CONSTANT) / BQ27000_RS;
+		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
 }
 
 /*
  * Read flag register.
  * Return < 0 if something fails.
  */
-static int bq27x00_battery_read_health(struct bq27x00_device_info *di)
+static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
 {
 	int tval;
 
-	tval = bq27x00_read(di, BQ27x00_REG_FLAGS, false);
+	tval = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
 	if (tval < 0) {
 		dev_err(di->dev, "error reading flag register:%d\n", tval);
 		return tval;
@@ -475,16 +475,16 @@ static int bq27x00_battery_read_health(struct bq27x00_device_info *di)
 	return -1;
 }
 
-static void bq27x00_update(struct bq27x00_device_info *di)
+static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
 {
-	struct bq27x00_reg_cache cache = {0, };
+	struct bq27xxx_reg_cache cache = {0, };
 	bool is_bq27500 = di->chip == BQ27500;
 	bool is_bq27510 = di->chip == BQ27510;
 	bool is_bq27425 = di->chip == BQ27425;
 	bool is_bq27742 = di->chip == BQ27742;
 	bool flags_1b = !(is_bq27500 || is_bq27742);
 
-	cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, flags_1b);
+	cache.flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
 	if ((cache.flags & 0xff) == 0xff)
 		/* read error */
 		cache.flags = -1;
@@ -500,41 +500,41 @@ static void bq27x00_update(struct bq27x00_device_info *di)
 			cache.charge_full = -ENODATA;
 			cache.health = -ENODATA;
 		} else {
-			cache.capacity = bq27x00_battery_read_rsoc(di);
+			cache.capacity = bq27xxx_battery_read_rsoc(di);
 			if (is_bq27742 || is_bq27510)
 				cache.time_to_empty =
-					bq27x00_battery_read_time(di,
+					bq27xxx_battery_read_time(di,
 							BQ27x00_REG_TTE);
 			else if (!is_bq27425) {
-				cache.energy = bq27x00_battery_read_energy(di);
+				cache.energy = bq27xxx_battery_read_energy(di);
 				cache.time_to_empty =
-					bq27x00_battery_read_time(di,
+					bq27xxx_battery_read_time(di,
 							BQ27x00_REG_TTE);
 				cache.time_to_empty_avg =
-					bq27x00_battery_read_time(di,
+					bq27xxx_battery_read_time(di,
 							BQ27x00_REG_TTECP);
 				cache.time_to_full =
-					bq27x00_battery_read_time(di,
+					bq27xxx_battery_read_time(di,
 							BQ27x00_REG_TTF);
 			}
-			cache.charge_full = bq27x00_battery_read_lmd(di);
-			cache.health = bq27x00_battery_read_health(di);
+			cache.charge_full = bq27xxx_battery_read_lmd(di);
+			cache.health = bq27xxx_battery_read_health(di);
 		}
-		cache.temperature = bq27x00_battery_read_temperature(di);
+		cache.temperature = bq27xxx_battery_read_temperature(di);
 		if (!is_bq27425)
-			cache.cycle_count = bq27x00_battery_read_cyct(di);
+			cache.cycle_count = bq27xxx_battery_read_cyct(di);
 		if (is_bq27742)
 			cache.power_avg =
-				bq27x00_battery_read_pwr_avg(di,
+				bq27xxx_battery_read_pwr_avg(di,
 						BQ27742_POWER_AVG);
 		else
 			cache.power_avg =
-				bq27x00_battery_read_pwr_avg(di,
+				bq27xxx_battery_read_pwr_avg(di,
 						BQ27x00_POWER_AVG);
 
 		/* We only have to read charge design full once */
 		if (di->charge_design_full <= 0)
-			di->charge_design_full = bq27x00_battery_read_ilmd(di);
+			di->charge_design_full = bq27xxx_battery_read_ilmd(di);
 	}
 
 	if (di->cache.capacity != cache.capacity)
@@ -546,12 +546,12 @@ static void bq27x00_update(struct bq27x00_device_info *di)
 	di->last_update = jiffies;
 }
 
-static void bq27x00_battery_poll(struct work_struct *work)
+static void bq27xxx_battery_poll(struct work_struct *work)
 {
-	struct bq27x00_device_info *di =
-		container_of(work, struct bq27x00_device_info, work.work);
+	struct bq27xxx_device_info *di =
+		container_of(work, struct bq27xxx_device_info, work.work);
 
-	bq27x00_update(di);
+	bq27xxx_battery_update(di);
 
 	if (poll_interval > 0) {
 		/* The timer does not have to be accurate. */
@@ -565,13 +565,13 @@ static void bq27x00_battery_poll(struct work_struct *work)
  * Note that current can be negative signed as well
  * Or 0 if something fails.
  */
-static int bq27x00_battery_current(struct bq27x00_device_info *di,
+static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
 				   union power_supply_propval *val)
 {
 	int curr;
 	int flags;
 
-	curr = bq27x00_read(di, BQ27x00_REG_AI, false);
+	curr = bq27xxx_read(di, BQ27x00_REG_AI, false);
 	if (curr < 0) {
 		dev_err(di->dev, "error reading current\n");
 		return curr;
@@ -581,19 +581,19 @@ static int bq27x00_battery_current(struct bq27x00_device_info *di,
 		/* bq27500 returns signed value */
 		val->intval = (int)((s16)curr) * 1000;
 	} else {
-		flags = bq27x00_read(di, BQ27x00_REG_FLAGS, false);
+		flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
 		if (flags & BQ27000_FLAG_CHGS) {
 			dev_dbg(di->dev, "negative current!\n");
 			curr = -curr;
 		}
 
-		val->intval = curr * 3570 / BQ27000_RS;
+		val->intval = curr * 3570 / BQ27XXX_RS;
 	}
 
 	return 0;
 }
 
-static int bq27x00_battery_status(struct bq27x00_device_info *di,
+static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
 				  union power_supply_propval *val)
 {
 	int status;
@@ -621,7 +621,7 @@ static int bq27x00_battery_status(struct bq27x00_device_info *di,
 	return 0;
 }
 
-static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
+static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
 					  union power_supply_propval *val)
 {
 	int level;
@@ -655,12 +655,12 @@ static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
  * Return the battery Voltage in millivolts
  * Or < 0 if something fails.
  */
-static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
+static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
 				   union power_supply_propval *val)
 {
 	int volt;
 
-	volt = bq27x00_read(di, BQ27x00_REG_VOLT, false);
+	volt = bq27xxx_read(di, BQ27x00_REG_VOLT, false);
 	if (volt < 0) {
 		dev_err(di->dev, "error reading voltage\n");
 		return volt;
@@ -671,7 +671,7 @@ static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
 	return 0;
 }
 
-static int bq27x00_simple_value(int value,
+static int bq27xxx_simple_value(int value,
 				union power_supply_propval *val)
 {
 	if (value < 0)
@@ -682,17 +682,17 @@ static int bq27x00_simple_value(int value,
 	return 0;
 }
 
-static int bq27x00_battery_get_property(struct power_supply *psy,
+static int bq27xxx_battery_get_property(struct power_supply *psy,
 					enum power_supply_property psp,
 					union power_supply_propval *val)
 {
 	int ret = 0;
-	struct bq27x00_device_info *di = power_supply_get_drvdata(psy);
+	struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
 
 	mutex_lock(&di->lock);
 	if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
 		cancel_delayed_work_sync(&di->work);
-		bq27x00_battery_poll(&di->work.work);
+		bq27xxx_battery_poll(&di->work.work);
 	}
 	mutex_unlock(&di->lock);
 
@@ -701,60 +701,60 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
 
 	switch (psp) {
 	case POWER_SUPPLY_PROP_STATUS:
-		ret = bq27x00_battery_status(di, val);
+		ret = bq27xxx_battery_status(di, val);
 		break;
 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-		ret = bq27x00_battery_voltage(di, val);
+		ret = bq27xxx_battery_voltage(di, val);
 		break;
 	case POWER_SUPPLY_PROP_PRESENT:
 		val->intval = di->cache.flags < 0 ? 0 : 1;
 		break;
 	case POWER_SUPPLY_PROP_CURRENT_NOW:
-		ret = bq27x00_battery_current(di, val);
+		ret = bq27xxx_battery_current(di, val);
 		break;
 	case POWER_SUPPLY_PROP_CAPACITY:
-		ret = bq27x00_simple_value(di->cache.capacity, val);
+		ret = bq27xxx_simple_value(di->cache.capacity, val);
 		break;
 	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
-		ret = bq27x00_battery_capacity_level(di, val);
+		ret = bq27xxx_battery_capacity_level(di, val);
 		break;
 	case POWER_SUPPLY_PROP_TEMP:
-		ret = bq27x00_simple_value(di->cache.temperature, val);
+		ret = bq27xxx_simple_value(di->cache.temperature, val);
 		if (ret == 0)
 			val->intval -= 2731;
 		break;
 	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
-		ret = bq27x00_simple_value(di->cache.time_to_empty, val);
+		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
 		break;
 	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
-		ret = bq27x00_simple_value(di->cache.time_to_empty_avg, val);
+		ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
 		break;
 	case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
-		ret = bq27x00_simple_value(di->cache.time_to_full, val);
+		ret = bq27xxx_simple_value(di->cache.time_to_full, val);
 		break;
 	case POWER_SUPPLY_PROP_TECHNOLOGY:
 		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_NOW:
-		ret = bq27x00_simple_value(bq27x00_battery_read_nac(di), val);
+		ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_FULL:
-		ret = bq27x00_simple_value(di->cache.charge_full, val);
+		ret = bq27xxx_simple_value(di->cache.charge_full, val);
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
-		ret = bq27x00_simple_value(di->charge_design_full, val);
+		ret = bq27xxx_simple_value(di->charge_design_full, val);
 		break;
 	case POWER_SUPPLY_PROP_CYCLE_COUNT:
-		ret = bq27x00_simple_value(di->cache.cycle_count, val);
+		ret = bq27xxx_simple_value(di->cache.cycle_count, val);
 		break;
 	case POWER_SUPPLY_PROP_ENERGY_NOW:
-		ret = bq27x00_simple_value(di->cache.energy, val);
+		ret = bq27xxx_simple_value(di->cache.energy, val);
 		break;
 	case POWER_SUPPLY_PROP_POWER_AVG:
-		ret = bq27x00_simple_value(di->cache.power_avg, val);
+		ret = bq27xxx_simple_value(di->cache.power_avg, val);
 		break;
 	case POWER_SUPPLY_PROP_HEALTH:
-		ret = bq27x00_simple_value(di->cache.health, val);
+		ret = bq27xxx_simple_value(di->cache.health, val);
 		break;
 	case POWER_SUPPLY_PROP_MANUFACTURER:
 		val->strval = BQ27XXX_MANUFACTURER;
@@ -766,15 +766,15 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
 	return ret;
 }
 
-static void bq27x00_external_power_changed(struct power_supply *psy)
+static void bq27xxx_external_power_changed(struct power_supply *psy)
 {
-	struct bq27x00_device_info *di = power_supply_get_drvdata(psy);
+	struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
 
 	cancel_delayed_work_sync(&di->work);
 	schedule_delayed_work(&di->work, 0);
 }
 
-static int bq27x00_powersupply_init(struct bq27x00_device_info *di,
+static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
 				    const char *name)
 {
 	int ret;
@@ -800,10 +800,10 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di,
 		psy_desc->properties = bq27x00_battery_props;
 		psy_desc->num_properties = ARRAY_SIZE(bq27x00_battery_props);
 	}
-	psy_desc->get_property = bq27x00_battery_get_property;
-	psy_desc->external_power_changed = bq27x00_external_power_changed;
+	psy_desc->get_property = bq27xxx_battery_get_property;
+	psy_desc->external_power_changed = bq27xxx_external_power_changed;
 
-	INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll);
+	INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
 	mutex_init(&di->lock);
 
 	di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
@@ -815,17 +815,17 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di,
 
 	dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION);
 
-	bq27x00_update(di);
+	bq27xxx_battery_update(di);
 
 	return 0;
 }
 
-static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
+static void bq27xxx_powersupply_unregister(struct bq27xxx_device_info *di)
 {
 	/*
-	 * power_supply_unregister call bq27x00_battery_get_property which
-	 * call bq27x00_battery_poll.
-	 * Make sure that bq27x00_battery_poll will not call
+	 * power_supply_unregister call bq27xxx_battery_get_property which
+	 * call bq27xxx_battery_poll.
+	 * Make sure that bq27xxx_battery_poll will not call
 	 * schedule_delayed_work again after unregister (which cause OOPS).
 	 */
 	poll_interval = 0;
@@ -838,7 +838,7 @@ static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
 }
 
 /* i2c specific code */
-#ifdef CONFIG_BATTERY_BQ27X00_I2C
+#ifdef CONFIG_BATTERY_BQ27XXX_I2C
 
 /* If the system has several batteries we need a different name for each
  * of them...
@@ -846,7 +846,8 @@ static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
 static DEFINE_IDR(battery_id);
 static DEFINE_MUTEX(battery_mutex);
 
-static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)
+static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
+				    bool single)
 {
 	struct i2c_client *client = to_i2c_client(di->dev);
 	struct i2c_msg msg[2];
@@ -880,11 +881,11 @@ static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)
 	return ret;
 }
 
-static int bq27x00_battery_probe(struct i2c_client *client,
-				 const struct i2c_device_id *id)
+static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
+				     const struct i2c_device_id *id)
 {
 	char *name;
-	struct bq27x00_device_info *di;
+	struct bq27xxx_device_info *di;
 	int num;
 	int retval = 0;
 
@@ -910,9 +911,9 @@ static int bq27x00_battery_probe(struct i2c_client *client,
 	di->id = num;
 	di->dev = &client->dev;
 	di->chip = id->driver_data;
-	di->bus.read = &bq27x00_read_i2c;
+	di->bus.read = &bq27xxx_battery_i2c_read;
 
-	retval = bq27x00_powersupply_init(di, name);
+	retval = bq27xxx_powersupply_init(di, name);
 	if (retval)
 		goto batt_failed;
 
@@ -928,11 +929,11 @@ batt_failed:
 	return retval;
 }
 
-static int bq27x00_battery_remove(struct i2c_client *client)
+static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
 {
-	struct bq27x00_device_info *di = i2c_get_clientdata(client);
+	struct bq27xxx_device_info *di = i2c_get_clientdata(client);
 
-	bq27x00_powersupply_unregister(di);
+	bq27xxx_powersupply_unregister(di);
 
 	mutex_lock(&battery_mutex);
 	idr_remove(&battery_id, di->id);
@@ -941,7 +942,7 @@ static int bq27x00_battery_remove(struct i2c_client *client)
 	return 0;
 }
 
-static const struct i2c_device_id bq27x00_id[] = {
+static const struct i2c_device_id bq27xxx_id[] = {
 	{ "bq27200", BQ27000 },	/* bq27200 is same as bq27000, but with i2c */
 	{ "bq27500", BQ27500 },
 	{ "bq27425", BQ27425 },
@@ -949,47 +950,47 @@ static const struct i2c_device_id bq27x00_id[] = {
 	{ "bq27510", BQ27510 },
 	{},
 };
-MODULE_DEVICE_TABLE(i2c, bq27x00_id);
+MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
 
-static struct i2c_driver bq27x00_battery_driver = {
+static struct i2c_driver bq27xxx_battery_i2c_driver = {
 	.driver = {
-		.name = "bq27x00-battery",
+		.name = "bq27xxx-battery",
 	},
-	.probe = bq27x00_battery_probe,
-	.remove = bq27x00_battery_remove,
-	.id_table = bq27x00_id,
+	.probe = bq27xxx_battery_i2c_probe,
+	.remove = bq27xxx_battery_i2c_remove,
+	.id_table = bq27xxx_id,
 };
 
-static inline int bq27x00_battery_i2c_init(void)
+static inline int bq27xxx_battery_i2c_init(void)
 {
-	int ret = i2c_add_driver(&bq27x00_battery_driver);
+	int ret = i2c_add_driver(&bq27xxx_battery_i2c_driver);
 
 	if (ret)
-		pr_err("Unable to register BQ27x00 i2c driver\n");
+		pr_err("Unable to register BQ27xxx i2c driver\n");
 
 	return ret;
 }
 
-static inline void bq27x00_battery_i2c_exit(void)
+static inline void bq27xxx_battery_i2c_exit(void)
 {
-	i2c_del_driver(&bq27x00_battery_driver);
+	i2c_del_driver(&bq27xxx_battery_i2c_driver);
 }
 
 #else
 
-static inline int bq27x00_battery_i2c_init(void) { return 0; }
-static inline void bq27x00_battery_i2c_exit(void) {};
+static inline int bq27xxx_battery_i2c_init(void) { return 0; }
+static inline void bq27xxx_battery_i2c_exit(void) {};
 
 #endif
 
 /* platform specific code */
-#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
+#ifdef CONFIG_BATTERY_BQ27XXX_PLATFORM
 
-static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
-				 bool single)
+static int bq27xxx_battery_platform_read(struct bq27xxx_device_info *di, u8 reg,
+					 bool single)
 {
 	struct device *dev = di->dev;
-	struct bq27000_platform_data *pdata = dev->platform_data;
+	struct bq27xxx_platform_data *pdata = dev->platform_data;
 	unsigned int timeout = 3;
 	int upper, lower;
 	int temp;
@@ -1019,10 +1020,10 @@ static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
 	return pdata->read(dev, reg);
 }
 
-static int bq27000_battery_probe(struct platform_device *pdev)
+static int bq27xxx_battery_platform_probe(struct platform_device *pdev)
 {
-	struct bq27x00_device_info *di;
-	struct bq27000_platform_data *pdata = pdev->dev.platform_data;
+	struct bq27xxx_device_info *di;
+	struct bq27xxx_platform_data *pdata = pdev->dev.platform_data;
 	const char *name;
 
 	if (!pdata) {
@@ -1045,47 +1046,47 @@ static int bq27000_battery_probe(struct platform_device *pdev)
 	di->chip = BQ27000;
 
 	name = pdata->name ?: dev_name(&pdev->dev);
-	di->bus.read = &bq27000_read_platform;
+	di->bus.read = &bq27xxx_battery_platform_read;
 
-	return bq27x00_powersupply_init(di, name);
+	return bq27xxx_powersupply_init(di, name);
 }
 
-static int bq27000_battery_remove(struct platform_device *pdev)
+static int bq27xxx_battery_platform_remove(struct platform_device *pdev)
 {
-	struct bq27x00_device_info *di = platform_get_drvdata(pdev);
+	struct bq27xxx_device_info *di = platform_get_drvdata(pdev);
 
-	bq27x00_powersupply_unregister(di);
+	bq27xxx_powersupply_unregister(di);
 
 	return 0;
 }
 
-static struct platform_driver bq27000_battery_driver = {
-	.probe	= bq27000_battery_probe,
-	.remove = bq27000_battery_remove,
+static struct platform_driver bq27xxx_battery_platform_driver = {
+	.probe	= bq27xxx_battery_platform_probe,
+	.remove = bq27xxx_battery_platform_remove,
 	.driver = {
 		.name = "bq27000-battery",
 	},
 };
 
-static inline int bq27x00_battery_platform_init(void)
+static inline int bq27xxx_battery_platform_init(void)
 {
-	int ret = platform_driver_register(&bq27000_battery_driver);
+	int ret = platform_driver_register(&bq27xxx_battery_platform_driver);
 
 	if (ret)
-		pr_err("Unable to register BQ27000 platform driver\n");
+		pr_err("Unable to register BQ27xxx platform driver\n");
 
 	return ret;
 }
 
-static inline void bq27x00_battery_platform_exit(void)
+static inline void bq27xxx_battery_platform_exit(void)
 {
-	platform_driver_unregister(&bq27000_battery_driver);
+	platform_driver_unregister(&bq27xxx_battery_platform_driver);
 }
 
 #else
 
-static inline int bq27x00_battery_platform_init(void) { return 0; }
-static inline void bq27x00_battery_platform_exit(void) {};
+static inline int bq27xxx_battery_platform_init(void) { return 0; }
+static inline void bq27xxx_battery_platform_exit(void) {};
 
 #endif
 
@@ -1093,37 +1094,37 @@ static inline void bq27x00_battery_platform_exit(void) {};
  * Module stuff
  */
 
-static int __init bq27x00_battery_init(void)
+static int __init bq27xxx_battery_init(void)
 {
 	int ret;
 
-	ret = bq27x00_battery_i2c_init();
+	ret = bq27xxx_battery_i2c_init();
 	if (ret)
 		return ret;
 
-	ret = bq27x00_battery_platform_init();
+	ret = bq27xxx_battery_platform_init();
 	if (ret)
-		bq27x00_battery_i2c_exit();
+		bq27xxx_battery_i2c_exit();
 
 	return ret;
 }
-module_init(bq27x00_battery_init);
+module_init(bq27xxx_battery_init);
 
-static void __exit bq27x00_battery_exit(void)
+static void __exit bq27xxx_battery_exit(void)
 {
-	bq27x00_battery_platform_exit();
-	bq27x00_battery_i2c_exit();
+	bq27xxx_battery_platform_exit();
+	bq27xxx_battery_i2c_exit();
 }
-module_exit(bq27x00_battery_exit);
+module_exit(bq27xxx_battery_exit);
 
-#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
-MODULE_ALIAS("platform:bq27000-battery");
+#ifdef CONFIG_BATTERY_BQ27XXX_PLATFORM
+MODULE_ALIAS("platform:bq27xxx-battery");
 #endif
 
-#ifdef CONFIG_BATTERY_BQ27X00_I2C
-MODULE_ALIAS("i2c:bq27000-battery");
+#ifdef CONFIG_BATTERY_BQ27XXX_I2C
+MODULE_ALIAS("i2c:bq27xxx-battery");
 #endif
 
 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
-MODULE_DESCRIPTION("BQ27x00 battery monitor driver");
+MODULE_DESCRIPTION("BQ27xxx battery monitor driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/w1/slaves/w1_bq27000.c b/drivers/w1/slaves/w1_bq27000.c
index caafb17..27935c0 100644
--- a/drivers/w1/slaves/w1_bq27000.c
+++ b/drivers/w1/slaves/w1_bq27000.c
@@ -15,7 +15,7 @@
 #include <linux/types.h>
 #include <linux/platform_device.h>
 #include <linux/mutex.h>
-#include <linux/power/bq27x00_battery.h>
+#include <linux/power/bq27xxx_battery.h>
 
 #include "../w1.h"
 #include "../w1_int.h"
diff --git a/include/linux/power/bq27x00_battery.h b/include/linux/power/bq27xxx_battery.h
similarity index 82%
rename from include/linux/power/bq27x00_battery.h
rename to include/linux/power/bq27xxx_battery.h
index a857f71..2d455f4 100644
--- a/include/linux/power/bq27x00_battery.h
+++ b/include/linux/power/bq27xxx_battery.h
@@ -2,8 +2,8 @@
 #define __LINUX_BQ27X00_BATTERY_H__
 
 /**
- * struct bq27000_plaform_data - Platform data for bq27000 devices
- * @name: Name of the battery. If NULL the driver will fallback to "bq27000".
+ * struct bq27xxx_plaform_data - Platform data for bq27xxx devices
+ * @name: Name of the battery. If NULL the driver will fallback to "bq27xxx".
  * @read: HDQ read callback.
  *	This function should provide access to the HDQ bus the battery is
  *	connected to.
@@ -11,7 +11,7 @@
  *	register to be read. The return value should either be the content of
  *	the passed register or an error value.
  */
-struct bq27000_platform_data {
+struct bq27xxx_platform_data {
 	const char *name;
 	int (*read)(struct device *dev, unsigned int);
 };
-- 
1.9.1

Re: [PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Pali Rohár]

On Wednesday 22 July 2015 16:51:57 Andrew F. Davis wrote:
> Rename functions that are used by multiple devices. New devices
> have been added and the function names and driver name are no longer
> general enough for the functionality they provide.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  MAINTAINERS                                        |   4 +-
>  arch/arm/configs/omap2plus_defconfig               |   2 +-
>  arch/unicore32/Kconfig                             |   2 +-
>  drivers/power/Kconfig                              |  22 +-
>  drivers/power/Makefile                             |   2 +-
>  .../power/{bq27x00_battery.c => bq27xxx_battery.c} | 339 +++++++++++----------
>  drivers/w1/slaves/w1_bq27000.c                     |   2 +-
>  .../power/{bq27x00_battery.h => bq27xxx_battery.h} |   6 +-
>  8 files changed, 190 insertions(+), 189 deletions(-)
>  rename drivers/power/{bq27x00_battery.c => bq27xxx_battery.c} (70%)
>  rename include/linux/power/{bq27x00_battery.h => bq27xxx_battery.h} (82%)
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index fd60784..9baf4e8 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -7226,10 +7226,10 @@ NOKIA N900 POWER SUPPLY DRIVERS
>  M:	Pali Rohár <pali.rohar@gmail.com>
>  S:	Maintained
>  F:	include/linux/power/bq2415x_charger.h
> -F:	include/linux/power/bq27x00_battery.h
> +F:	include/linux/power/bq27xxx_battery.h
>  F:	include/linux/power/isp1704_charger.h
>  F:	drivers/power/bq2415x_charger.c
> -F:	drivers/power/bq27x00_battery.c
> +F:	drivers/power/bq27xxx_battery.c
>  F:	drivers/power/isp1704_charger.c
>  F:	drivers/power/rx51_battery.c
>  
> diff --git a/arch/arm/configs/omap2plus_defconfig b/arch/arm/configs/omap2plus_defconfig
> index ac521e7..a79232c 100644
> --- a/arch/arm/configs/omap2plus_defconfig
> +++ b/arch/arm/configs/omap2plus_defconfig
> @@ -241,7 +241,7 @@ CONFIG_GPIO_TWL4030=y
>  CONFIG_GPIO_PALMAS=y
>  CONFIG_W1=m
>  CONFIG_HDQ_MASTER_OMAP=m
> -CONFIG_BATTERY_BQ27x00=m
> +CONFIG_BATTERY_BQ27XXX=m
>  CONFIG_CHARGER_ISP1704=m
>  CONFIG_CHARGER_TWL4030=m
>  CONFIG_CHARGER_BQ2415X=m
> diff --git a/arch/unicore32/Kconfig b/arch/unicore32/Kconfig
> index 928237a..c9faddc 100644
> --- a/arch/unicore32/Kconfig
> +++ b/arch/unicore32/Kconfig
> @@ -222,7 +222,7 @@ config I2C_BATTERY_BQ27200
>  	tristate "I2C Battery BQ27200 Support"
>  	select I2C_PUV3
>  	select POWER_SUPPLY
> -	select BATTERY_BQ27x00
> +	select BATTERY_BQ27XXX
>  
>  config I2C_EEPROM_AT24
>  	tristate "I2C EEPROMs AT24 support"
> diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
> index 08beeed..cafcfe2 100644
> --- a/drivers/power/Kconfig
> +++ b/drivers/power/Kconfig
> @@ -157,26 +157,26 @@ config BATTERY_SBS
>  	  Say Y to include support for SBS battery driver for SBS-compliant
>  	  gas gauges.
>  
> -config BATTERY_BQ27x00
> -	tristate "BQ27x00 battery driver"
> +config BATTERY_BQ27XXX
> +	tristate "BQ27xxx battery driver"
>  	depends on I2C || I2C=n
>  	help
> -	  Say Y here to enable support for batteries with BQ27x00 (I2C/HDQ) chips.
> +	  Say Y here to enable support for batteries with BQ27xxx (I2C/HDQ) chips.
>  
> -config BATTERY_BQ27X00_I2C
> -	bool "BQ27200/BQ27500 support"
> -	depends on BATTERY_BQ27x00
> +config BATTERY_BQ27XXX_I2C
> +	bool "BQ27xxx I2C support"
> +	depends on BATTERY_BQ27XXX
>  	depends on I2C
>  	default y
>  	help
> -	  Say Y here to enable support for batteries with BQ27x00 (I2C) chips.
> +	  Say Y here to enable support for batteries with BQ27xxx (I2C) chips.
>  
> -config BATTERY_BQ27X00_PLATFORM
> -	bool "BQ27000 support"
> -	depends on BATTERY_BQ27x00
> +config BATTERY_BQ27XXX_PLATFORM
> +	bool "BQ27xxx HDQ support"
> +	depends on BATTERY_BQ27XXX
>  	default y
>  	help
> -	  Say Y here to enable support for batteries with BQ27000 (HDQ) chips.
> +	  Say Y here to enable support for batteries with BQ27xxx (HDQ) chips.
>  

HDQ is just BQ27000 chip, right? Then please do not change these strings

>  config BATTERY_DA9030
>  	tristate "DA9030 battery driver"
> diff --git a/drivers/power/Makefile b/drivers/power/Makefile
> index 5752ce8..7a5bc96 100644
> --- a/drivers/power/Makefile
> +++ b/drivers/power/Makefile
> @@ -29,7 +29,7 @@ obj-$(CONFIG_BATTERY_COLLIE)	+= collie_battery.o
>  obj-$(CONFIG_BATTERY_IPAQ_MICRO) += ipaq_micro_battery.o
>  obj-$(CONFIG_BATTERY_WM97XX)	+= wm97xx_battery.o
>  obj-$(CONFIG_BATTERY_SBS)	+= sbs-battery.o
> -obj-$(CONFIG_BATTERY_BQ27x00)	+= bq27x00_battery.o
> +obj-$(CONFIG_BATTERY_BQ27XXX)	+= bq27xxx_battery.o
>  obj-$(CONFIG_BATTERY_DA9030)	+= da9030_battery.o
>  obj-$(CONFIG_BATTERY_DA9052)	+= da9052-battery.o
>  obj-$(CONFIG_CHARGER_DA9150)	+= da9150-charger.o
> diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27xxx_battery.c
> similarity index 70%
> rename from drivers/power/bq27x00_battery.c
> rename to drivers/power/bq27xxx_battery.c
> index 8287261f..f5d7a137 100644
> --- a/drivers/power/bq27x00_battery.c
> +++ b/drivers/power/bq27xxx_battery.c
> @@ -1,5 +1,5 @@
>  /*
> - * BQ27x00 battery driver
> + * BQ27xxx battery driver
>   *
>   * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
>   * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
> @@ -37,7 +37,7 @@
>  #include <linux/slab.h>
>  #include <asm/unaligned.h>
>  
> -#include <linux/power/bq27x00_battery.h>
> +#include <linux/power/bq27xxx_battery.h>
>  
>  #define DRIVER_VERSION		"1.2.0"
>  
> @@ -83,17 +83,17 @@
>  #define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
>  #define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
>  
> -#define BQ27000_RS			20 /* Resistor sense */
> -#define BQ27x00_POWER_CONSTANT		(256 * 29200 / 1000)
> +#define BQ27XXX_RS			20 /* Resistor sense */
> +#define BQ27XXX_POWER_CONSTANT		(256 * 29200 / 1000)
>  
> -struct bq27x00_device_info;
> -struct bq27x00_access_methods {
> -	int (*read)(struct bq27x00_device_info *di, u8 reg, bool single);
> +struct bq27xxx_device_info;
> +struct bq27xxx_access_methods {
> +	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
>  };
>  
> -enum bq27x00_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
> +enum bq27xxx_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
>  
> -struct bq27x00_reg_cache {
> +struct bq27xxx_reg_cache {
>  	int temperature;
>  	int time_to_empty;
>  	int time_to_empty_avg;
> @@ -107,12 +107,12 @@ struct bq27x00_reg_cache {
>  	int health;
>  };
>  
> -struct bq27x00_device_info {
> +struct bq27xxx_device_info {
>  	struct device		*dev;
>  	int			id;
> -	enum bq27x00_chip	chip;
> +	enum bq27xxx_chip	chip;
>  
> -	struct bq27x00_reg_cache cache;
> +	struct bq27xxx_reg_cache cache;
>  	int charge_design_full;
>  
>  	unsigned long last_update;
> @@ -120,7 +120,7 @@ struct bq27x00_device_info {
>  
>  	struct power_supply	*bat;
>  
> -	struct bq27x00_access_methods bus;
> +	struct bq27xxx_access_methods bus;
>  
>  	struct mutex lock;
>  };
> @@ -206,10 +206,10 @@ MODULE_PARM_DESC(poll_interval,
>  		 "battery poll interval in seconds - 0 disables polling");
>  
>  /*
> - * Common code for BQ27x00 devices
> + * Common code for BQ27xxx devices
>   */
>  
> -static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
> +static inline int bq27xxx_read(struct bq27xxx_device_info *di, u8 reg,
>  			       bool single)
>  {
>  	if (di->chip == BQ27425)
> @@ -222,7 +222,7 @@ static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
>   * differ from BQ27000 and BQ27200 in calculation of certain
>   * parameters. Hence we need to check for the chip type.
>   */
> -static bool bq27xxx_is_chip_version_higher(struct bq27x00_device_info *di)
> +static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
>  {
>  	if (di->chip == BQ27425 || di->chip == BQ27500 || di->chip == BQ27742
>  	    || di->chip == BQ27510)
> @@ -234,18 +234,18 @@ static bool bq27xxx_is_chip_version_higher(struct bq27x00_device_info *di)
>   * Return the battery Relative State-of-Charge
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
> +static int bq27xxx_battery_read_rsoc(struct bq27xxx_device_info *di)
>  {
>  	int rsoc;
>  
>  	if (di->chip == BQ27500 || di->chip == BQ27742)
> -		rsoc = bq27x00_read(di, BQ27500_REG_SOC, false);
> +		rsoc = bq27xxx_read(di, BQ27500_REG_SOC, false);
>  	else if (di->chip == BQ27510)
> -		rsoc = bq27x00_read(di, BQ27510_REG_SOC, false);
> +		rsoc = bq27xxx_read(di, BQ27510_REG_SOC, false);
>  	else if (di->chip == BQ27425)
> -		rsoc = bq27x00_read(di, BQ27425_REG_SOC, false);
> +		rsoc = bq27xxx_read(di, BQ27425_REG_SOC, false);
>  	else
> -		rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true);
> +		rsoc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
>  
>  	if (rsoc < 0)
>  		dev_dbg(di->dev, "error reading relative State-of-Charge\n");
> @@ -257,11 +257,11 @@ static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
>   * Return a battery charge value in µAh
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
> +static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>  {
>  	int charge;
>  
> -	charge = bq27x00_read(di, reg, false);
> +	charge = bq27xxx_read(di, reg, false);
>  	if (charge < 0) {
>  		dev_dbg(di->dev, "error reading charge register %02x: %d\n",
>  			reg, charge);
> @@ -271,7 +271,7 @@ static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
>  	if (bq27xxx_is_chip_version_higher(di))
>  		charge *= 1000;
>  	else
> -		charge = charge * 3570 / BQ27000_RS;
> +		charge = charge * 3570 / BQ27XXX_RS;
>  
>  	return charge;
>  }
> @@ -280,7 +280,7 @@ static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
>   * Return the battery Nominal available capaciy in µAh
>   * Or < 0 if something fails.
>   */
> -static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di)
> +static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
>  {
>  	int flags;
>  	bool is_bq27500 = di->chip == BQ27500;
> @@ -288,39 +288,39 @@ static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di)
>  	bool is_higher = bq27xxx_is_chip_version_higher(di);
>  	bool flags_1b = !(is_bq27500 || is_bq27742);
>  
> -	flags = bq27x00_read(di, BQ27x00_REG_FLAGS, flags_1b);
> +	flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
>  	if (flags >= 0 && !is_higher && (flags & BQ27000_FLAG_CI))
>  		return -ENODATA;
>  
> -	return bq27x00_battery_read_charge(di, BQ27x00_REG_NAC);
> +	return bq27xxx_battery_read_charge(di, BQ27x00_REG_NAC);
>  }
>  
>  /*
>   * Return the battery Last measured discharge in µAh
>   * Or < 0 if something fails.
>   */
> -static inline int bq27x00_battery_read_lmd(struct bq27x00_device_info *di)
> +static inline int bq27xxx_battery_read_lmd(struct bq27xxx_device_info *di)
>  {
> -	return bq27x00_battery_read_charge(di, BQ27x00_REG_LMD);
> +	return bq27xxx_battery_read_charge(di, BQ27x00_REG_LMD);
>  }
>  
>  /*
>   * Return the battery Initial last measured discharge in µAh
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
> +static int bq27xxx_battery_read_ilmd(struct bq27xxx_device_info *di)
>  {
>  	int ilmd;
>  
>  	if (bq27xxx_is_chip_version_higher(di)) {
>  		if (di->chip == BQ27425)
> -			ilmd = bq27x00_read(di, BQ27425_REG_DCAP, false);
> +			ilmd = bq27xxx_read(di, BQ27425_REG_DCAP, false);
>  		else if (di->chip == BQ27510)
> -			ilmd = bq27x00_read(di, BQ27510_REG_DCAP, false);
> +			ilmd = bq27xxx_read(di, BQ27510_REG_DCAP, false);
>  		else
> -			ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
> +			ilmd = bq27xxx_read(di, BQ27500_REG_DCAP, false);
>  	} else {
> -		ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
> +		ilmd = bq27xxx_read(di, BQ27000_REG_ILMD, true);
>  	}
>  
>  	if (ilmd < 0) {
> @@ -331,7 +331,7 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
>  	if (bq27xxx_is_chip_version_higher(di))
>  		ilmd *= 1000;
>  	else
> -		ilmd = ilmd * 256 * 3570 / BQ27000_RS;
> +		ilmd = ilmd * 256 * 3570 / BQ27XXX_RS;
>  
>  	return ilmd;
>  }
> @@ -340,11 +340,11 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
>   * Return the battery Available energy in µWh
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
> +static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
>  {
>  	int ae;
>  
> -	ae = bq27x00_read(di, BQ27x00_REG_AE, false);
> +	ae = bq27xxx_read(di, BQ27x00_REG_AE, false);
>  	if (ae < 0) {
>  		dev_dbg(di->dev, "error reading available energy\n");
>  		return ae;
> @@ -353,7 +353,7 @@ static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
>  	if (di->chip == BQ27500)
>  		ae *= 1000;
>  	else
> -		ae = ae * 29200 / BQ27000_RS;
> +		ae = ae * 29200 / BQ27XXX_RS;
>  
>  	return ae;
>  }
> @@ -362,11 +362,11 @@ static int bq27x00_battery_read_energy(struct bq27x00_device_info *di)
>   * Return the battery temperature in tenths of degree Kelvin
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di)
> +static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
>  {
>  	int temp;
>  
> -	temp = bq27x00_read(di, BQ27x00_REG_TEMP, false);
> +	temp = bq27xxx_read(di, BQ27x00_REG_TEMP, false);
>  	if (temp < 0) {
>  		dev_err(di->dev, "error reading temperature\n");
>  		return temp;
> @@ -382,14 +382,14 @@ static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di)
>   * Return the battery Cycle count total
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di)
> +static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
>  {
>  	int cyct;
>  
>  	if (di->chip == BQ27510)
> -		cyct = bq27x00_read(di, BQ27510_REG_CYCT, false);
> +		cyct = bq27xxx_read(di, BQ27510_REG_CYCT, false);
>  	else
> -		cyct = bq27x00_read(di, BQ27x00_REG_CYCT, false);
> +		cyct = bq27xxx_read(di, BQ27x00_REG_CYCT, false);
>  	if (cyct < 0)
>  		dev_err(di->dev, "error reading cycle count total\n");
>  
> @@ -400,11 +400,11 @@ static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di)
>   * Read a time register.
>   * Return < 0 if something fails.
>   */
> -static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)
> +static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
>  {
>  	int tval;
>  
> -	tval = bq27x00_read(di, reg, false);
> +	tval = bq27xxx_read(di, reg, false);
>  	if (tval < 0) {
>  		dev_dbg(di->dev, "error reading time register %02x: %d\n",
>  			reg, tval);
> @@ -421,11 +421,11 @@ static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg)
>   * Read a power avg register.
>   * Return < 0 if something fails.
>   */
> -static int bq27x00_battery_read_pwr_avg(struct bq27x00_device_info *di, u8 reg)
> +static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
>  {
>  	int tval;
>  
> -	tval = bq27x00_read(di, reg, false);
> +	tval = bq27xxx_read(di, reg, false);
>  	if (tval < 0) {
>  		dev_err(di->dev, "error reading power avg rgister  %02x: %d\n",
>  			reg, tval);
> @@ -435,18 +435,18 @@ static int bq27x00_battery_read_pwr_avg(struct bq27x00_device_info *di, u8 reg)
>  	if (di->chip == BQ27500)
>  		return tval;
>  	else
> -		return (tval * BQ27x00_POWER_CONSTANT) / BQ27000_RS;
> +		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
>  }
>  
>  /*
>   * Read flag register.
>   * Return < 0 if something fails.
>   */
> -static int bq27x00_battery_read_health(struct bq27x00_device_info *di)
> +static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
>  {
>  	int tval;
>  
> -	tval = bq27x00_read(di, BQ27x00_REG_FLAGS, false);
> +	tval = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
>  	if (tval < 0) {
>  		dev_err(di->dev, "error reading flag register:%d\n", tval);
>  		return tval;
> @@ -475,16 +475,16 @@ static int bq27x00_battery_read_health(struct bq27x00_device_info *di)
>  	return -1;
>  }
>  
> -static void bq27x00_update(struct bq27x00_device_info *di)
> +static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>  {
> -	struct bq27x00_reg_cache cache = {0, };
> +	struct bq27xxx_reg_cache cache = {0, };
>  	bool is_bq27500 = di->chip == BQ27500;
>  	bool is_bq27510 = di->chip == BQ27510;
>  	bool is_bq27425 = di->chip == BQ27425;
>  	bool is_bq27742 = di->chip == BQ27742;
>  	bool flags_1b = !(is_bq27500 || is_bq27742);
>  
> -	cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, flags_1b);
> +	cache.flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
>  	if ((cache.flags & 0xff) == 0xff)
>  		/* read error */
>  		cache.flags = -1;
> @@ -500,41 +500,41 @@ static void bq27x00_update(struct bq27x00_device_info *di)
>  			cache.charge_full = -ENODATA;
>  			cache.health = -ENODATA;
>  		} else {
> -			cache.capacity = bq27x00_battery_read_rsoc(di);
> +			cache.capacity = bq27xxx_battery_read_rsoc(di);
>  			if (is_bq27742 || is_bq27510)
>  				cache.time_to_empty =
> -					bq27x00_battery_read_time(di,
> +					bq27xxx_battery_read_time(di,
>  							BQ27x00_REG_TTE);
>  			else if (!is_bq27425) {
> -				cache.energy = bq27x00_battery_read_energy(di);
> +				cache.energy = bq27xxx_battery_read_energy(di);
>  				cache.time_to_empty =
> -					bq27x00_battery_read_time(di,
> +					bq27xxx_battery_read_time(di,
>  							BQ27x00_REG_TTE);
>  				cache.time_to_empty_avg =
> -					bq27x00_battery_read_time(di,
> +					bq27xxx_battery_read_time(di,
>  							BQ27x00_REG_TTECP);
>  				cache.time_to_full =
> -					bq27x00_battery_read_time(di,
> +					bq27xxx_battery_read_time(di,
>  							BQ27x00_REG_TTF);
>  			}
> -			cache.charge_full = bq27x00_battery_read_lmd(di);
> -			cache.health = bq27x00_battery_read_health(di);
> +			cache.charge_full = bq27xxx_battery_read_lmd(di);
> +			cache.health = bq27xxx_battery_read_health(di);
>  		}
> -		cache.temperature = bq27x00_battery_read_temperature(di);
> +		cache.temperature = bq27xxx_battery_read_temperature(di);
>  		if (!is_bq27425)
> -			cache.cycle_count = bq27x00_battery_read_cyct(di);
> +			cache.cycle_count = bq27xxx_battery_read_cyct(di);
>  		if (is_bq27742)
>  			cache.power_avg =
> -				bq27x00_battery_read_pwr_avg(di,
> +				bq27xxx_battery_read_pwr_avg(di,
>  						BQ27742_POWER_AVG);
>  		else
>  			cache.power_avg =
> -				bq27x00_battery_read_pwr_avg(di,
> +				bq27xxx_battery_read_pwr_avg(di,
>  						BQ27x00_POWER_AVG);
>  
>  		/* We only have to read charge design full once */
>  		if (di->charge_design_full <= 0)
> -			di->charge_design_full = bq27x00_battery_read_ilmd(di);
> +			di->charge_design_full = bq27xxx_battery_read_ilmd(di);
>  	}
>  
>  	if (di->cache.capacity != cache.capacity)
> @@ -546,12 +546,12 @@ static void bq27x00_update(struct bq27x00_device_info *di)
>  	di->last_update = jiffies;
>  }
>  
> -static void bq27x00_battery_poll(struct work_struct *work)
> +static void bq27xxx_battery_poll(struct work_struct *work)
>  {
> -	struct bq27x00_device_info *di =
> -		container_of(work, struct bq27x00_device_info, work.work);
> +	struct bq27xxx_device_info *di =
> +		container_of(work, struct bq27xxx_device_info, work.work);
>  
> -	bq27x00_update(di);
> +	bq27xxx_battery_update(di);
>  
>  	if (poll_interval > 0) {
>  		/* The timer does not have to be accurate. */
> @@ -565,13 +565,13 @@ static void bq27x00_battery_poll(struct work_struct *work)
>   * Note that current can be negative signed as well
>   * Or 0 if something fails.
>   */
> -static int bq27x00_battery_current(struct bq27x00_device_info *di,
> +static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
>  				   union power_supply_propval *val)
>  {
>  	int curr;
>  	int flags;
>  
> -	curr = bq27x00_read(di, BQ27x00_REG_AI, false);
> +	curr = bq27xxx_read(di, BQ27x00_REG_AI, false);
>  	if (curr < 0) {
>  		dev_err(di->dev, "error reading current\n");
>  		return curr;
> @@ -581,19 +581,19 @@ static int bq27x00_battery_current(struct bq27x00_device_info *di,
>  		/* bq27500 returns signed value */
>  		val->intval = (int)((s16)curr) * 1000;
>  	} else {
> -		flags = bq27x00_read(di, BQ27x00_REG_FLAGS, false);
> +		flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
>  		if (flags & BQ27000_FLAG_CHGS) {
>  			dev_dbg(di->dev, "negative current!\n");
>  			curr = -curr;
>  		}
>  
> -		val->intval = curr * 3570 / BQ27000_RS;
> +		val->intval = curr * 3570 / BQ27XXX_RS;
>  	}
>  
>  	return 0;
>  }
>  
> -static int bq27x00_battery_status(struct bq27x00_device_info *di,
> +static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
>  				  union power_supply_propval *val)
>  {
>  	int status;
> @@ -621,7 +621,7 @@ static int bq27x00_battery_status(struct bq27x00_device_info *di,
>  	return 0;
>  }
>  
> -static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
> +static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
>  					  union power_supply_propval *val)
>  {
>  	int level;
> @@ -655,12 +655,12 @@ static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
>   * Return the battery Voltage in millivolts
>   * Or < 0 if something fails.
>   */
> -static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
> +static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
>  				   union power_supply_propval *val)
>  {
>  	int volt;
>  
> -	volt = bq27x00_read(di, BQ27x00_REG_VOLT, false);
> +	volt = bq27xxx_read(di, BQ27x00_REG_VOLT, false);
>  	if (volt < 0) {
>  		dev_err(di->dev, "error reading voltage\n");
>  		return volt;
> @@ -671,7 +671,7 @@ static int bq27x00_battery_voltage(struct bq27x00_device_info *di,
>  	return 0;
>  }
>  
> -static int bq27x00_simple_value(int value,
> +static int bq27xxx_simple_value(int value,
>  				union power_supply_propval *val)
>  {
>  	if (value < 0)
> @@ -682,17 +682,17 @@ static int bq27x00_simple_value(int value,
>  	return 0;
>  }
>  
> -static int bq27x00_battery_get_property(struct power_supply *psy,
> +static int bq27xxx_battery_get_property(struct power_supply *psy,
>  					enum power_supply_property psp,
>  					union power_supply_propval *val)
>  {
>  	int ret = 0;
> -	struct bq27x00_device_info *di = power_supply_get_drvdata(psy);
> +	struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
>  
>  	mutex_lock(&di->lock);
>  	if (time_is_before_jiffies(di->last_update + 5 * HZ)) {
>  		cancel_delayed_work_sync(&di->work);
> -		bq27x00_battery_poll(&di->work.work);
> +		bq27xxx_battery_poll(&di->work.work);
>  	}
>  	mutex_unlock(&di->lock);
>  
> @@ -701,60 +701,60 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
>  
>  	switch (psp) {
>  	case POWER_SUPPLY_PROP_STATUS:
> -		ret = bq27x00_battery_status(di, val);
> +		ret = bq27xxx_battery_status(di, val);
>  		break;
>  	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
> -		ret = bq27x00_battery_voltage(di, val);
> +		ret = bq27xxx_battery_voltage(di, val);
>  		break;
>  	case POWER_SUPPLY_PROP_PRESENT:
>  		val->intval = di->cache.flags < 0 ? 0 : 1;
>  		break;
>  	case POWER_SUPPLY_PROP_CURRENT_NOW:
> -		ret = bq27x00_battery_current(di, val);
> +		ret = bq27xxx_battery_current(di, val);
>  		break;
>  	case POWER_SUPPLY_PROP_CAPACITY:
> -		ret = bq27x00_simple_value(di->cache.capacity, val);
> +		ret = bq27xxx_simple_value(di->cache.capacity, val);
>  		break;
>  	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
> -		ret = bq27x00_battery_capacity_level(di, val);
> +		ret = bq27xxx_battery_capacity_level(di, val);
>  		break;
>  	case POWER_SUPPLY_PROP_TEMP:
> -		ret = bq27x00_simple_value(di->cache.temperature, val);
> +		ret = bq27xxx_simple_value(di->cache.temperature, val);
>  		if (ret == 0)
>  			val->intval -= 2731;
>  		break;
>  	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
> -		ret = bq27x00_simple_value(di->cache.time_to_empty, val);
> +		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
>  		break;
>  	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
> -		ret = bq27x00_simple_value(di->cache.time_to_empty_avg, val);
> +		ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val);
>  		break;
>  	case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
> -		ret = bq27x00_simple_value(di->cache.time_to_full, val);
> +		ret = bq27xxx_simple_value(di->cache.time_to_full, val);
>  		break;
>  	case POWER_SUPPLY_PROP_TECHNOLOGY:
>  		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
>  		break;
>  	case POWER_SUPPLY_PROP_CHARGE_NOW:
> -		ret = bq27x00_simple_value(bq27x00_battery_read_nac(di), val);
> +		ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val);
>  		break;
>  	case POWER_SUPPLY_PROP_CHARGE_FULL:
> -		ret = bq27x00_simple_value(di->cache.charge_full, val);
> +		ret = bq27xxx_simple_value(di->cache.charge_full, val);
>  		break;
>  	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
> -		ret = bq27x00_simple_value(di->charge_design_full, val);
> +		ret = bq27xxx_simple_value(di->charge_design_full, val);
>  		break;
>  	case POWER_SUPPLY_PROP_CYCLE_COUNT:
> -		ret = bq27x00_simple_value(di->cache.cycle_count, val);
> +		ret = bq27xxx_simple_value(di->cache.cycle_count, val);
>  		break;
>  	case POWER_SUPPLY_PROP_ENERGY_NOW:
> -		ret = bq27x00_simple_value(di->cache.energy, val);
> +		ret = bq27xxx_simple_value(di->cache.energy, val);
>  		break;
>  	case POWER_SUPPLY_PROP_POWER_AVG:
> -		ret = bq27x00_simple_value(di->cache.power_avg, val);
> +		ret = bq27xxx_simple_value(di->cache.power_avg, val);
>  		break;
>  	case POWER_SUPPLY_PROP_HEALTH:
> -		ret = bq27x00_simple_value(di->cache.health, val);
> +		ret = bq27xxx_simple_value(di->cache.health, val);
>  		break;
>  	case POWER_SUPPLY_PROP_MANUFACTURER:
>  		val->strval = BQ27XXX_MANUFACTURER;
> @@ -766,15 +766,15 @@ static int bq27x00_battery_get_property(struct power_supply *psy,
>  	return ret;
>  }
>  
> -static void bq27x00_external_power_changed(struct power_supply *psy)
> +static void bq27xxx_external_power_changed(struct power_supply *psy)
>  {
> -	struct bq27x00_device_info *di = power_supply_get_drvdata(psy);
> +	struct bq27xxx_device_info *di = power_supply_get_drvdata(psy);
>  
>  	cancel_delayed_work_sync(&di->work);
>  	schedule_delayed_work(&di->work, 0);
>  }
>  
> -static int bq27x00_powersupply_init(struct bq27x00_device_info *di,
> +static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
>  				    const char *name)
>  {
>  	int ret;
> @@ -800,10 +800,10 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di,
>  		psy_desc->properties = bq27x00_battery_props;
>  		psy_desc->num_properties = ARRAY_SIZE(bq27x00_battery_props);
>  	}
> -	psy_desc->get_property = bq27x00_battery_get_property;
> -	psy_desc->external_power_changed = bq27x00_external_power_changed;
> +	psy_desc->get_property = bq27xxx_battery_get_property;
> +	psy_desc->external_power_changed = bq27xxx_external_power_changed;
>  
> -	INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll);
> +	INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll);
>  	mutex_init(&di->lock);
>  
>  	di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg);
> @@ -815,17 +815,17 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di,
>  
>  	dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION);
>  
> -	bq27x00_update(di);
> +	bq27xxx_battery_update(di);
>  
>  	return 0;
>  }
>  
> -static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
> +static void bq27xxx_powersupply_unregister(struct bq27xxx_device_info *di)
>  {
>  	/*
> -	 * power_supply_unregister call bq27x00_battery_get_property which
> -	 * call bq27x00_battery_poll.
> -	 * Make sure that bq27x00_battery_poll will not call
> +	 * power_supply_unregister call bq27xxx_battery_get_property which
> +	 * call bq27xxx_battery_poll.
> +	 * Make sure that bq27xxx_battery_poll will not call
>  	 * schedule_delayed_work again after unregister (which cause OOPS).
>  	 */
>  	poll_interval = 0;
> @@ -838,7 +838,7 @@ static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
>  }
>  
>  /* i2c specific code */
> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
>  
>  /* If the system has several batteries we need a different name for each
>   * of them...
> @@ -846,7 +846,8 @@ static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di)
>  static DEFINE_IDR(battery_id);
>  static DEFINE_MUTEX(battery_mutex);
>  
> -static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)
> +static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
> +				    bool single)
>  {
>  	struct i2c_client *client = to_i2c_client(di->dev);
>  	struct i2c_msg msg[2];
> @@ -880,11 +881,11 @@ static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single)
>  	return ret;
>  }
>  
> -static int bq27x00_battery_probe(struct i2c_client *client,
> -				 const struct i2c_device_id *id)
> +static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
> +				     const struct i2c_device_id *id)
>  {
>  	char *name;
> -	struct bq27x00_device_info *di;
> +	struct bq27xxx_device_info *di;
>  	int num;
>  	int retval = 0;
>  
> @@ -910,9 +911,9 @@ static int bq27x00_battery_probe(struct i2c_client *client,
>  	di->id = num;
>  	di->dev = &client->dev;
>  	di->chip = id->driver_data;
> -	di->bus.read = &bq27x00_read_i2c;
> +	di->bus.read = &bq27xxx_battery_i2c_read;
>  
> -	retval = bq27x00_powersupply_init(di, name);
> +	retval = bq27xxx_powersupply_init(di, name);
>  	if (retval)
>  		goto batt_failed;
>  
> @@ -928,11 +929,11 @@ batt_failed:
>  	return retval;
>  }
>  
> -static int bq27x00_battery_remove(struct i2c_client *client)
> +static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
>  {
> -	struct bq27x00_device_info *di = i2c_get_clientdata(client);
> +	struct bq27xxx_device_info *di = i2c_get_clientdata(client);
>  
> -	bq27x00_powersupply_unregister(di);
> +	bq27xxx_powersupply_unregister(di);
>  
>  	mutex_lock(&battery_mutex);
>  	idr_remove(&battery_id, di->id);
> @@ -941,7 +942,7 @@ static int bq27x00_battery_remove(struct i2c_client *client)
>  	return 0;
>  }
>  
> -static const struct i2c_device_id bq27x00_id[] = {
> +static const struct i2c_device_id bq27xxx_id[] = {
>  	{ "bq27200", BQ27000 },	/* bq27200 is same as bq27000, but with i2c */
>  	{ "bq27500", BQ27500 },
>  	{ "bq27425", BQ27425 },
> @@ -949,47 +950,47 @@ static const struct i2c_device_id bq27x00_id[] = {
>  	{ "bq27510", BQ27510 },
>  	{},
>  };
> -MODULE_DEVICE_TABLE(i2c, bq27x00_id);
> +MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
>  
> -static struct i2c_driver bq27x00_battery_driver = {
> +static struct i2c_driver bq27xxx_battery_i2c_driver = {
>  	.driver = {
> -		.name = "bq27x00-battery",
> +		.name = "bq27xxx-battery",
>  	},
> -	.probe = bq27x00_battery_probe,
> -	.remove = bq27x00_battery_remove,
> -	.id_table = bq27x00_id,
> +	.probe = bq27xxx_battery_i2c_probe,
> +	.remove = bq27xxx_battery_i2c_remove,
> +	.id_table = bq27xxx_id,
>  };
>  
> -static inline int bq27x00_battery_i2c_init(void)
> +static inline int bq27xxx_battery_i2c_init(void)
>  {
> -	int ret = i2c_add_driver(&bq27x00_battery_driver);
> +	int ret = i2c_add_driver(&bq27xxx_battery_i2c_driver);
>  
>  	if (ret)
> -		pr_err("Unable to register BQ27x00 i2c driver\n");
> +		pr_err("Unable to register BQ27xxx i2c driver\n");
>  
>  	return ret;
>  }
>  
> -static inline void bq27x00_battery_i2c_exit(void)
> +static inline void bq27xxx_battery_i2c_exit(void)
>  {
> -	i2c_del_driver(&bq27x00_battery_driver);
> +	i2c_del_driver(&bq27xxx_battery_i2c_driver);
>  }
>  
>  #else
>  
> -static inline int bq27x00_battery_i2c_init(void) { return 0; }
> -static inline void bq27x00_battery_i2c_exit(void) {};
> +static inline int bq27xxx_battery_i2c_init(void) { return 0; }
> +static inline void bq27xxx_battery_i2c_exit(void) {};
>  
>  #endif
>  
>  /* platform specific code */
> -#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
> +#ifdef CONFIG_BATTERY_BQ27XXX_PLATFORM
>  
> -static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
> -				 bool single)
> +static int bq27xxx_battery_platform_read(struct bq27xxx_device_info *di, u8 reg,
> +					 bool single)
>  {
>  	struct device *dev = di->dev;
> -	struct bq27000_platform_data *pdata = dev->platform_data;
> +	struct bq27xxx_platform_data *pdata = dev->platform_data;
>  	unsigned int timeout = 3;
>  	int upper, lower;
>  	int temp;
> @@ -1019,10 +1020,10 @@ static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg,
>  	return pdata->read(dev, reg);
>  }
>  
> -static int bq27000_battery_probe(struct platform_device *pdev)
> +static int bq27xxx_battery_platform_probe(struct platform_device *pdev)
>  {
> -	struct bq27x00_device_info *di;
> -	struct bq27000_platform_data *pdata = pdev->dev.platform_data;
> +	struct bq27xxx_device_info *di;
> +	struct bq27xxx_platform_data *pdata = pdev->dev.platform_data;
>  	const char *name;
>  
>  	if (!pdata) {
> @@ -1045,47 +1046,47 @@ static int bq27000_battery_probe(struct platform_device *pdev)
>  	di->chip = BQ27000;
>  
>  	name = pdata->name ?: dev_name(&pdev->dev);
> -	di->bus.read = &bq27000_read_platform;
> +	di->bus.read = &bq27xxx_battery_platform_read;
>  
> -	return bq27x00_powersupply_init(di, name);
> +	return bq27xxx_powersupply_init(di, name);
>  }
>  
> -static int bq27000_battery_remove(struct platform_device *pdev)
> +static int bq27xxx_battery_platform_remove(struct platform_device *pdev)
>  {
> -	struct bq27x00_device_info *di = platform_get_drvdata(pdev);
> +	struct bq27xxx_device_info *di = platform_get_drvdata(pdev);
>  
> -	bq27x00_powersupply_unregister(di);
> +	bq27xxx_powersupply_unregister(di);
>  
>  	return 0;
>  }
>  
> -static struct platform_driver bq27000_battery_driver = {
> -	.probe	= bq27000_battery_probe,
> -	.remove = bq27000_battery_remove,
> +static struct platform_driver bq27xxx_battery_platform_driver = {
> +	.probe	= bq27xxx_battery_platform_probe,
> +	.remove = bq27xxx_battery_platform_remove,
>  	.driver = {
>  		.name = "bq27000-battery",
>  	},
>  };
>  
> -static inline int bq27x00_battery_platform_init(void)
> +static inline int bq27xxx_battery_platform_init(void)
>  {
> -	int ret = platform_driver_register(&bq27000_battery_driver);
> +	int ret = platform_driver_register(&bq27xxx_battery_platform_driver);
>  
>  	if (ret)
> -		pr_err("Unable to register BQ27000 platform driver\n");
> +		pr_err("Unable to register BQ27xxx platform driver\n");
>  
>  	return ret;
>  }
>  
> -static inline void bq27x00_battery_platform_exit(void)
> +static inline void bq27xxx_battery_platform_exit(void)
>  {
> -	platform_driver_unregister(&bq27000_battery_driver);
> +	platform_driver_unregister(&bq27xxx_battery_platform_driver);
>  }
>  
>  #else
>  
> -static inline int bq27x00_battery_platform_init(void) { return 0; }
> -static inline void bq27x00_battery_platform_exit(void) {};
> +static inline int bq27xxx_battery_platform_init(void) { return 0; }
> +static inline void bq27xxx_battery_platform_exit(void) {};
>  
>  #endif
>  
> @@ -1093,37 +1094,37 @@ static inline void bq27x00_battery_platform_exit(void) {};
>   * Module stuff
>   */
>  
> -static int __init bq27x00_battery_init(void)
> +static int __init bq27xxx_battery_init(void)
>  {
>  	int ret;
>  
> -	ret = bq27x00_battery_i2c_init();
> +	ret = bq27xxx_battery_i2c_init();
>  	if (ret)
>  		return ret;
>  
> -	ret = bq27x00_battery_platform_init();
> +	ret = bq27xxx_battery_platform_init();
>  	if (ret)
> -		bq27x00_battery_i2c_exit();
> +		bq27xxx_battery_i2c_exit();
>  
>  	return ret;
>  }
> -module_init(bq27x00_battery_init);
> +module_init(bq27xxx_battery_init);
>  
> -static void __exit bq27x00_battery_exit(void)
> +static void __exit bq27xxx_battery_exit(void)
>  {
> -	bq27x00_battery_platform_exit();
> -	bq27x00_battery_i2c_exit();
> +	bq27xxx_battery_platform_exit();
> +	bq27xxx_battery_i2c_exit();
>  }
> -module_exit(bq27x00_battery_exit);
> +module_exit(bq27xxx_battery_exit);
>  
> -#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM
> -MODULE_ALIAS("platform:bq27000-battery");
> +#ifdef CONFIG_BATTERY_BQ27XXX_PLATFORM
> +MODULE_ALIAS("platform:bq27xxx-battery");
>  #endif

Same here, HDQ is just BQ27000 chip?

>  
> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
> -MODULE_ALIAS("i2c:bq27000-battery");
> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
> +MODULE_ALIAS("i2c:bq27xxx-battery");
>  #endif

Why is this MODULE_ALIAS needed? Some lines upper there is

 MODULE_DEVICE_TABLE(i2c, bq27xxx_id);

which add proper i2c: module alias...

>  
>  MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
> -MODULE_DESCRIPTION("BQ27x00 battery monitor driver");
> +MODULE_DESCRIPTION("BQ27xxx battery monitor driver");
>  MODULE_LICENSE("GPL");
> diff --git a/drivers/w1/slaves/w1_bq27000.c b/drivers/w1/slaves/w1_bq27000.c
> index caafb17..27935c0 100644
> --- a/drivers/w1/slaves/w1_bq27000.c
> +++ b/drivers/w1/slaves/w1_bq27000.c
> @@ -15,7 +15,7 @@
>  #include <linux/types.h>
>  #include <linux/platform_device.h>
>  #include <linux/mutex.h>
> -#include <linux/power/bq27x00_battery.h>
> +#include <linux/power/bq27xxx_battery.h>
>  
>  #include "../w1.h"
>  #include "../w1_int.h"
> diff --git a/include/linux/power/bq27x00_battery.h b/include/linux/power/bq27xxx_battery.h
> similarity index 82%
> rename from include/linux/power/bq27x00_battery.h
> rename to include/linux/power/bq27xxx_battery.h
> index a857f71..2d455f4 100644
> --- a/include/linux/power/bq27x00_battery.h
> +++ b/include/linux/power/bq27xxx_battery.h
> @@ -2,8 +2,8 @@
>  #define __LINUX_BQ27X00_BATTERY_H__
>  
>  /**
> - * struct bq27000_plaform_data - Platform data for bq27000 devices
> - * @name: Name of the battery. If NULL the driver will fallback to "bq27000".
> + * struct bq27xxx_plaform_data - Platform data for bq27xxx devices
> + * @name: Name of the battery. If NULL the driver will fallback to "bq27xxx".

Uhm... Fallback to default chip bq27xxx? Sounds like "replace" error.

Anyway, I do not think that any fallback value is good. When
bq27x00_battery.c supported only bq27000 and bq27200 it made sense as
all supported chips (at that time) used same registers. But now when
more chip families use different registers, I'm for removing default
fallback value and force all users of this platform data to specify
name and type.

>   * @read: HDQ read callback.
>   *	This function should provide access to the HDQ bus the battery is
>   *	connected to.
> @@ -11,7 +11,7 @@
>   *	register to be read. The return value should either be the content of
>   *	the passed register or an error value.
>   */
> -struct bq27000_platform_data {
> +struct bq27xxx_platform_data {
>  	const char *name;
>  	int (*read)(struct device *dev, unsigned int);
>  };

Also this patch is doing big rename... Are you sure that no changes to
existing DT files are needed? I just need to be sure that nothing will
be broken...

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Pali Rohár]

[-- Attachment #1: Type: Text/Plain, Size: 1172 bytes --]

On Thursday 23 July 2015 19:03:08 Andrew F. Davis wrote:
> >> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
> >> -MODULE_ALIAS("i2c:bq27000-battery");
> >> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
> >> +MODULE_ALIAS("i2c:bq27xxx-battery");
> >> 
> >>  #endif
> > 
> > Why is this MODULE_ALIAS needed? Some lines upper there is
> > 
> >  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
> > 
> > which add proper i2c: module alias...
> 
> Not sure, looks like it was added in commit
> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 which claims that the
> "module won't get loaded automatically" without it, but I have not
> had this problem, so I'm not sure why it's there.
> 

git grep bq27000-battery show me that only one driver uses that name:
drivers/w1/slaves/w1_bq27000.c

And more over, it is platform device, not i2c device. So that commit 
8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 is wrong! CCing Marek.

MODULE_ALIAS("platform:bq27000-battery") is really needed for 
w1_bq27000.c but MODULE_ALIAS("i2c:bq27000-battery") should be removed. 
It is not used by any board platform code or DT.

Marek, correct me if I'm wrong.

-- 
Pali Rohár
pali.rohar@gmail.com

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: [PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Belisko Marek]

Hi Pali,

On Thu, Jul 23, 2015 at 10:15 PM, Pali Rohár <pali.rohar@gmail.com> wrote:
> On Thursday 23 July 2015 19:03:08 Andrew F. Davis wrote:
>> >> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
>> >> -MODULE_ALIAS("i2c:bq27000-battery");
>> >> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
>> >> +MODULE_ALIAS("i2c:bq27xxx-battery");
>> >>
>> >>  #endif
>> >
>> > Why is this MODULE_ALIAS needed? Some lines upper there is
>> >
>> >  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
>> >
>> > which add proper i2c: module alias...
>>
>> Not sure, looks like it was added in commit
>> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 which claims that the
>> "module won't get loaded automatically" without it, but I have not
>> had this problem, so I'm not sure why it's there.
>>
>
> git grep bq27000-battery show me that only one driver uses that name:
> drivers/w1/slaves/w1_bq27000.c
>
> And more over, it is platform device, not i2c device. So that commit
> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 is wrong! CCing Marek.
If you look to power/bq27x00 driver then there is I2C part and
platform part only
both selectable by config. In 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 was added
MODULE_ALIAS to have this driver working as module for both buses.
Even if I2C isn't used anywhere
I add MODULE_ALIAS also for that.
>
> MODULE_ALIAS("platform:bq27000-battery") is really needed for
> w1_bq27000.c but MODULE_ALIAS("i2c:bq27000-battery") should be removed.
> It is not used by any board platform code or DT.
Not sure if it's good idea to remove it. Somebody outside can use it.
>
> Marek, correct me if I'm wrong.
>
> --
> Pali Rohár
> pali.rohar@gmail.com

BR,

marek



-- 
as simple and primitive as possible
-------------------------------------------------
Marek Belisko - OPEN-NANDRA
Freelance Developer

Ruska Nova Ves 219 | Presov, 08005 Slovak Republic
Tel: +421 915 052 184
skype: marekwhite
twitter: #opennandra
web: http://open-nandra.com

Re: [PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Pali Rohár]

[-- Attachment #1: Type: Text/Plain, Size: 2376 bytes --]

On Thursday 23 July 2015 22:56:26 Belisko Marek wrote:
> Hi Pali,
> 
> On Thu, Jul 23, 2015 at 10:15 PM, Pali Rohár <pali.rohar@gmail.com>
> wrote:
> > On Thursday 23 July 2015 19:03:08 Andrew F. Davis wrote:
> >> >> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
> >> >> -MODULE_ALIAS("i2c:bq27000-battery");
> >> >> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
> >> >> +MODULE_ALIAS("i2c:bq27xxx-battery");
> >> >> 
> >> >>  #endif
> >> > 
> >> > Why is this MODULE_ALIAS needed? Some lines upper there is
> >> > 
> >> >  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
> >> > 
> >> > which add proper i2c: module alias...
> >> 
> >> Not sure, looks like it was added in commit
> >> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 which claims that the
> >> "module won't get loaded automatically" without it, but I have not
> >> had this problem, so I'm not sure why it's there.
> > 
> > git grep bq27000-battery show me that only one driver uses that
> > name: drivers/w1/slaves/w1_bq27000.c
> > 
> > And more over, it is platform device, not i2c device. So that
> > commit 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 is wrong! CCing
> > Marek.
> 
> If you look to power/bq27x00 driver then there is I2C part and
> platform part only
> both selectable by config. In
> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 was added MODULE_ALIAS to
> have this driver working as module for both buses. Even if I2C isn't
> used anywhere
> I add MODULE_ALIAS also for that.
> 
> > MODULE_ALIAS("platform:bq27000-battery") is really needed for
> > w1_bq27000.c but MODULE_ALIAS("i2c:bq27000-battery") should be
> > removed. It is not used by any board platform code or DT.
> 
> Not sure if it's good idea to remove it. Somebody outside can use it.
> 
> > Marek, correct me if I'm wrong.
> > 
> > --
> > Pali Rohár
> > pali.rohar@gmail.com
> 
> BR,
> 
> marek

Who, where any why is using alias i2c:bq27000-battery??

It is obviously wrong to add that alias. MODULE_DEVICE_TABLE(i2c, ... 
macro automatically adds all MODULE_ALIASes for all i2c devices.

If there is such device with needs i2c:bq27000-battery is should be 
fixed to use i2c:bq27??? identifier exported by MODULE_DEVICE_TABLE.

git grep on kernel tree did not return anything, so there is no usage.

Of course alias for platform:bq27000-battery is needed.

-- 
Pali Rohár
pali.rohar@gmail.com

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: [PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Belisko Marek]

On Thu, Jul 23, 2015 at 11:15 PM, Pali Rohár <pali.rohar@gmail.com> wrote:
> On Thursday 23 July 2015 22:56:26 Belisko Marek wrote:
>> Hi Pali,
>>
>> On Thu, Jul 23, 2015 at 10:15 PM, Pali Rohár <pali.rohar@gmail.com>
>> wrote:
>> > On Thursday 23 July 2015 19:03:08 Andrew F. Davis wrote:
>> >> >> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
>> >> >> -MODULE_ALIAS("i2c:bq27000-battery");
>> >> >> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
>> >> >> +MODULE_ALIAS("i2c:bq27xxx-battery");
>> >> >>
>> >> >>  #endif
>> >> >
>> >> > Why is this MODULE_ALIAS needed? Some lines upper there is
>> >> >
>> >> >  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
>> >> >
>> >> > which add proper i2c: module alias...
>> >>
>> >> Not sure, looks like it was added in commit
>> >> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 which claims that the
>> >> "module won't get loaded automatically" without it, but I have not
>> >> had this problem, so I'm not sure why it's there.
>> >
>> > git grep bq27000-battery show me that only one driver uses that
>> > name: drivers/w1/slaves/w1_bq27000.c
>> >
>> > And more over, it is platform device, not i2c device. So that
>> > commit 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 is wrong! CCing
>> > Marek.
>>
>> If you look to power/bq27x00 driver then there is I2C part and
>> platform part only
>> both selectable by config. In
>> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 was added MODULE_ALIAS to
>> have this driver working as module for both buses. Even if I2C isn't
>> used anywhere
>> I add MODULE_ALIAS also for that.
>>
>> > MODULE_ALIAS("platform:bq27000-battery") is really needed for
>> > w1_bq27000.c but MODULE_ALIAS("i2c:bq27000-battery") should be
>> > removed. It is not used by any board platform code or DT.
>>
>> Not sure if it's good idea to remove it. Somebody outside can use it.
>>
>> > Marek, correct me if I'm wrong.
>> >
>> > --
>> > Pali Rohár
>> > pali.rohar@gmail.com
>>
>> BR,
>>
>> marek
>
> Who, where any why is using alias i2c:bq27000-battery??
>
> It is obviously wrong to add that alias. MODULE_DEVICE_TABLE(i2c, ...
> macro automatically adds all MODULE_ALIASes for all i2c devices.
Hmm are you sure? I think it's not true if you look to include/linux/module.h
Those 2 macros have completely other purposes.
>
> If there is such device with needs i2c:bq27000-battery is should be
> fixed to use i2c:bq27??? identifier exported by MODULE_DEVICE_TABLE.
Look if you don't like it remove i2c part from driver and post patch.
But as I said
somebody can use it (not talking about vanilla tree).
>
> git grep on kernel tree did not return anything, so there is no usage.
>
> Of course alias for platform:bq27000-battery is needed.
>
> --
> Pali Rohár
> pali.rohar@gmail.com

BR,

marek



-- 
as simple and primitive as possible
-------------------------------------------------
Marek Belisko - OPEN-NANDRA
Freelance Developer

Ruska Nova Ves 219 | Presov, 08005 Slovak Republic
Tel: +421 915 052 184
skype: marekwhite
twitter: #opennandra
web: http://open-nandra.com

Re: [PATCH 5/8] power: bq27x00_battery: Renaming for consistency

[Pali Rohár]

On Thursday 23 July 2015 23:36:24 Belisko Marek wrote:
> On Thu, Jul 23, 2015 at 11:15 PM, Pali Rohár <pali.rohar@gmail.com> wrote:
> > On Thursday 23 July 2015 22:56:26 Belisko Marek wrote:
> >> Hi Pali,
> >>
> >> On Thu, Jul 23, 2015 at 10:15 PM, Pali Rohár <pali.rohar@gmail.com>
> >> wrote:
> >> > On Thursday 23 July 2015 19:03:08 Andrew F. Davis wrote:
> >> >> >> -#ifdef CONFIG_BATTERY_BQ27X00_I2C
> >> >> >> -MODULE_ALIAS("i2c:bq27000-battery");
> >> >> >> +#ifdef CONFIG_BATTERY_BQ27XXX_I2C
> >> >> >> +MODULE_ALIAS("i2c:bq27xxx-battery");
> >> >> >>
> >> >> >>  #endif
> >> >> >
> >> >> > Why is this MODULE_ALIAS needed? Some lines upper there is
> >> >> >
> >> >> >  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
> >> >> >
> >> >> > which add proper i2c: module alias...
> >> >>
> >> >> Not sure, looks like it was added in commit
> >> >> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 which claims that the
> >> >> "module won't get loaded automatically" without it, but I have not
> >> >> had this problem, so I'm not sure why it's there.
> >> >
> >> > git grep bq27000-battery show me that only one driver uses that
> >> > name: drivers/w1/slaves/w1_bq27000.c
> >> >
> >> > And more over, it is platform device, not i2c device. So that
> >> > commit 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 is wrong! CCing
> >> > Marek.
> >>
> >> If you look to power/bq27x00 driver then there is I2C part and
> >> platform part only
> >> both selectable by config. In
> >> 8ebb7e9c1a502cfc300618c19c3c6f06fc76d237 was added MODULE_ALIAS to
> >> have this driver working as module for both buses. Even if I2C isn't
> >> used anywhere
> >> I add MODULE_ALIAS also for that.
> >>
> >> > MODULE_ALIAS("platform:bq27000-battery") is really needed for
> >> > w1_bq27000.c but MODULE_ALIAS("i2c:bq27000-battery") should be
> >> > removed. It is not used by any board platform code or DT.
> >>
> >> Not sure if it's good idea to remove it. Somebody outside can use it.
> >>
> >> > Marek, correct me if I'm wrong.
> >> >
> >> > --
> >> > Pali Rohár
> >> > pali.rohar@gmail.com
> >>
> >> BR,
> >>
> >> marek
> >
> > Who, where any why is using alias i2c:bq27000-battery??
> >
> > It is obviously wrong to add that alias. MODULE_DEVICE_TABLE(i2c, ...
> > macro automatically adds all MODULE_ALIASes for all i2c devices.
> Hmm are you sure? I think it's not true if you look to include/linux/module.h
> Those 2 macros have completely other purposes.

This is some magic which is generated to autogenerated c file when
compiling driver as module. Look at output from modinfo bq27x00_battery

Anyway, alias i2c:bq27000-battery is wrong and not only because it is
added by MODULE_ALIAS but also because bq27000 chip is HDQ and not i2c.

> >
> > If there is such device with needs i2c:bq27000-battery is should be
> > fixed to use i2c:bq27??? identifier exported by MODULE_DEVICE_TABLE.
> Look if you don't like it remove i2c part from driver and post patch.

I'm for removing i2c part and it can be done as part of Andrew's cleanup
patch.

> But as I said
> somebody can use it (not talking about vanilla tree).

Then they should fix their code.

> >
> > git grep on kernel tree did not return anything, so there is no usage.
> >
> > Of course alias for platform:bq27000-battery is needed.
> >
> > --
> > Pali Rohár
> > pali.rohar@gmail.com
> 
> BR,
> 
> marek
> 
> 
> 

-- 
Pali Rohár
pali.rohar@gmail.com

[PATCH 6/8] power: bq27xxx_battery: Fix typos and change naming for state of charge functions

[Andrew F. Davis]

Fix typos and change "relative state of charge" to "state of charge" as not
all supported devices use relative state of charge.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27xxx_battery.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
index f5d7a137..5686da6 100644
--- a/drivers/power/bq27xxx_battery.c
+++ b/drivers/power/bq27xxx_battery.c
@@ -231,26 +231,26 @@ static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
 }
 
 /*
- * Return the battery Relative State-of-Charge
+ * Return the battery State-of-Charge
  * Or < 0 if something fails.
  */
-static int bq27xxx_battery_read_rsoc(struct bq27xxx_device_info *di)
+static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
 {
-	int rsoc;
+	int soc;
 
 	if (di->chip == BQ27500 || di->chip == BQ27742)
-		rsoc = bq27xxx_read(di, BQ27500_REG_SOC, false);
+		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
 	else if (di->chip == BQ27510)
-		rsoc = bq27xxx_read(di, BQ27510_REG_SOC, false);
+		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
 	else if (di->chip == BQ27425)
-		rsoc = bq27xxx_read(di, BQ27425_REG_SOC, false);
+		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
 	else
-		rsoc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
+		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
 
-	if (rsoc < 0)
-		dev_dbg(di->dev, "error reading relative State-of-Charge\n");
+	if (soc < 0)
+		dev_dbg(di->dev, "error reading State-of-Charge\n");
 
-	return rsoc;
+	return soc;
 }
 
 /*
@@ -277,7 +277,7 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
 }
 
 /*
- * Return the battery Nominal available capaciy in µAh
+ * Return the battery Nominal available capacity in µAh
  * Or < 0 if something fails.
  */
 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
@@ -418,7 +418,7 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
 }
 
 /*
- * Read a power avg register.
+ * Read an average power register.
  * Return < 0 if something fails.
  */
 static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
@@ -500,7 +500,7 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
 			cache.charge_full = -ENODATA;
 			cache.health = -ENODATA;
 		} else {
-			cache.capacity = bq27xxx_battery_read_rsoc(di);
+			cache.capacity = bq27xxx_battery_read_soc(di);
 			if (is_bq27742 || is_bq27510)
 				cache.time_to_empty =
 					bq27xxx_battery_read_time(di,
-- 
1.9.1

Re: [PATCH 6/8] power: bq27xxx_battery: Fix typos and change naming for state of charge functions

[Pali Rohár]

On Wednesday 22 July 2015 16:51:58 Andrew F. Davis wrote:
> Fix typos and change "relative state of charge" to "state of charge" as not
> all supported devices use relative state of charge.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27xxx_battery.c | 26 +++++++++++++-------------
>  1 file changed, 13 insertions(+), 13 deletions(-)
> 
> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
> index f5d7a137..5686da6 100644
> --- a/drivers/power/bq27xxx_battery.c
> +++ b/drivers/power/bq27xxx_battery.c
> @@ -231,26 +231,26 @@ static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
>  }
>  
>  /*
> - * Return the battery Relative State-of-Charge
> + * Return the battery State-of-Charge
>   * Or < 0 if something fails.
>   */
> -static int bq27xxx_battery_read_rsoc(struct bq27xxx_device_info *di)
> +static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
>  {
> -	int rsoc;
> +	int soc;
>  
>  	if (di->chip == BQ27500 || di->chip == BQ27742)
> -		rsoc = bq27xxx_read(di, BQ27500_REG_SOC, false);
> +		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
>  	else if (di->chip == BQ27510)
> -		rsoc = bq27xxx_read(di, BQ27510_REG_SOC, false);
> +		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
>  	else if (di->chip == BQ27425)
> -		rsoc = bq27xxx_read(di, BQ27425_REG_SOC, false);
> +		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
>  	else
> -		rsoc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
> +		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
>  
> -	if (rsoc < 0)
> -		dev_dbg(di->dev, "error reading relative State-of-Charge\n");
> +	if (soc < 0)
> +		dev_dbg(di->dev, "error reading State-of-Charge\n");
>  
> -	return rsoc;
> +	return soc;
>  }
>  

It is good idea to have name function name "read_soc" with description
"Return State-of-Charge" and for some chips that function returns RSOC
(Relative)? For me it is quite misleading.

>  /*
> @@ -277,7 +277,7 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>  }
>  
>  /*
> - * Return the battery Nominal available capaciy in µAh
> + * Return the battery Nominal available capacity in µAh
>   * Or < 0 if something fails.
>   */
>  static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
> @@ -418,7 +418,7 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
>  }
>  
>  /*
> - * Read a power avg register.
> + * Read an average power register.
>   * Return < 0 if something fails.
>   */
>  static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
> @@ -500,7 +500,7 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>  			cache.charge_full = -ENODATA;
>  			cache.health = -ENODATA;
>  		} else {
> -			cache.capacity = bq27xxx_battery_read_rsoc(di);
> +			cache.capacity = bq27xxx_battery_read_soc(di);
>  			if (is_bq27742 || is_bq27510)
>  				cache.time_to_empty =
>  					bq27xxx_battery_read_time(di,

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 6/8] power: bq27xxx_battery: Fix typos and change naming for state of charge functions

[Andrew F. Davis]

On 07/23/2015 11:15 AM, Pali Rohár wrote:
> On Wednesday 22 July 2015 16:51:58 Andrew F. Davis wrote:
>> Fix typos and change "relative state of charge" to "state of charge" as not
>> all supported devices use relative state of charge.
>>
>> Signed-off-by: Andrew F. Davis <afd@ti.com>
>> ---
>>  drivers/power/bq27xxx_battery.c | 26 +++++++++++++-------------
>>  1 file changed, 13 insertions(+), 13 deletions(-)
>>
>> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
>> index f5d7a137..5686da6 100644
>> --- a/drivers/power/bq27xxx_battery.c
>> +++ b/drivers/power/bq27xxx_battery.c
>> @@ -231,26 +231,26 @@ static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
>>  }
>>  
>>  /*
>> - * Return the battery Relative State-of-Charge
>> + * Return the battery State-of-Charge
>>   * Or < 0 if something fails.
>>   */
>> -static int bq27xxx_battery_read_rsoc(struct bq27xxx_device_info *di)
>> +static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
>>  {
>> -	int rsoc;
>> +	int soc;
>>  
>>  	if (di->chip == BQ27500 || di->chip == BQ27742)
>> -		rsoc = bq27xxx_read(di, BQ27500_REG_SOC, false);
>> +		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
>>  	else if (di->chip == BQ27510)
>> -		rsoc = bq27xxx_read(di, BQ27510_REG_SOC, false);
>> +		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
>>  	else if (di->chip == BQ27425)
>> -		rsoc = bq27xxx_read(di, BQ27425_REG_SOC, false);
>> +		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
>>  	else
>> -		rsoc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
>> +		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
>>  
>> -	if (rsoc < 0)
>> -		dev_dbg(di->dev, "error reading relative State-of-Charge\n");
>> +	if (soc < 0)
>> +		dev_dbg(di->dev, "error reading State-of-Charge\n");
>>  
>> -	return rsoc;
>> +	return soc;
>>  }
>>  
> 
> It is good idea to have name function name "read_soc" with description
> "Return State-of-Charge" and for some chips that function returns RSOC
> (Relative)? For me it is quite misleading.
> 

Most of the chips only return one type of SOC, and the docs refer to this
as just "State-of-Charge". The bq27000 has "Relative" and " Compensated"
but we only return one (Relative). So I figured this would be the more
correct way to describe the general SOC reading function even when the
chips may expose other types.

>>  /*
>> @@ -277,7 +277,7 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>>  }
>>  
>>  /*
>> - * Return the battery Nominal available capaciy in µAh
>> + * Return the battery Nominal available capacity in µAh
>>   * Or < 0 if something fails.
>>   */
>>  static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
>> @@ -418,7 +418,7 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
>>  }
>>  
>>  /*
>> - * Read a power avg register.
>> + * Read an average power register.
>>   * Return < 0 if something fails.
>>   */
>>  static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
>> @@ -500,7 +500,7 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>>  			cache.charge_full = -ENODATA;
>>  			cache.health = -ENODATA;
>>  		} else {
>> -			cache.capacity = bq27xxx_battery_read_rsoc(di);
>> +			cache.capacity = bq27xxx_battery_read_soc(di);
>>  			if (is_bq27742 || is_bq27510)
>>  				cache.time_to_empty =
>>  					bq27xxx_battery_read_time(di,
> 

-- 
Andrew F. Davis

Re: [PATCH 6/8] power: bq27xxx_battery: Fix typos and change naming for state of charge functions

[Pali Rohár]

On Thursday 23 July 2015 12:19:16 Andrew F. Davis wrote:
> On 07/23/2015 11:15 AM, Pali Rohár wrote:
> > On Wednesday 22 July 2015 16:51:58 Andrew F. Davis wrote:
> >> Fix typos and change "relative state of charge" to "state of charge" as not
> >> all supported devices use relative state of charge.
> >>
> >> Signed-off-by: Andrew F. Davis <afd@ti.com>
> >> ---
> >>  drivers/power/bq27xxx_battery.c | 26 +++++++++++++-------------
> >>  1 file changed, 13 insertions(+), 13 deletions(-)
> >>
> >> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
> >> index f5d7a137..5686da6 100644
> >> --- a/drivers/power/bq27xxx_battery.c
> >> +++ b/drivers/power/bq27xxx_battery.c
> >> @@ -231,26 +231,26 @@ static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
> >>  }
> >>  
> >>  /*
> >> - * Return the battery Relative State-of-Charge
> >> + * Return the battery State-of-Charge
> >>   * Or < 0 if something fails.
> >>   */
> >> -static int bq27xxx_battery_read_rsoc(struct bq27xxx_device_info *di)
> >> +static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
> >>  {
> >> -	int rsoc;
> >> +	int soc;
> >>  
> >>  	if (di->chip == BQ27500 || di->chip == BQ27742)
> >> -		rsoc = bq27xxx_read(di, BQ27500_REG_SOC, false);
> >> +		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
> >>  	else if (di->chip == BQ27510)
> >> -		rsoc = bq27xxx_read(di, BQ27510_REG_SOC, false);
> >> +		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
> >>  	else if (di->chip == BQ27425)
> >> -		rsoc = bq27xxx_read(di, BQ27425_REG_SOC, false);
> >> +		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
> >>  	else
> >> -		rsoc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
> >> +		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
> >>  
> >> -	if (rsoc < 0)
> >> -		dev_dbg(di->dev, "error reading relative State-of-Charge\n");
> >> +	if (soc < 0)
> >> +		dev_dbg(di->dev, "error reading State-of-Charge\n");
> >>  
> >> -	return rsoc;
> >> +	return soc;
> >>  }
> >>  
> > 
> > It is good idea to have name function name "read_soc" with description
> > "Return State-of-Charge" and for some chips that function returns RSOC
> > (Relative)? For me it is quite misleading.
> > 
> 
> Most of the chips only return one type of SOC, and the docs refer to this
> as just "State-of-Charge". The bq27000 has "Relative" and " Compensated"
> but we only return one (Relative). So I figured this would be the more
> correct way to describe the general SOC reading function even when the
> chips may expose other types.
> 

Can you add short comment for bq27000 if-branch about it?

> >>  /*
> >> @@ -277,7 +277,7 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
> >>  }
> >>  
> >>  /*
> >> - * Return the battery Nominal available capaciy in µAh
> >> + * Return the battery Nominal available capacity in µAh
> >>   * Or < 0 if something fails.
> >>   */
> >>  static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
> >> @@ -418,7 +418,7 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
> >>  }
> >>  
> >>  /*
> >> - * Read a power avg register.
> >> + * Read an average power register.
> >>   * Return < 0 if something fails.
> >>   */
> >>  static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
> >> @@ -500,7 +500,7 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
> >>  			cache.charge_full = -ENODATA;
> >>  			cache.health = -ENODATA;
> >>  		} else {
> >> -			cache.capacity = bq27xxx_battery_read_rsoc(di);
> >> +			cache.capacity = bq27xxx_battery_read_soc(di);
> >>  			if (is_bq27742 || is_bq27510)
> >>  				cache.time_to_empty =
> >>  					bq27xxx_battery_read_time(di,
> > 
> 

-- 
Pali Rohár
pali.rohar@gmail.com

[PATCH 7/8] power: bq27xxx_battery: Add support for additional bq27xxx family devices

[Andrew F. Davis]

Add support for additional devices and register equivalent family devices
including the bq27010, bq27210, bq272500, bq27510, bq27520, bq27530,
bq27531, bq27541, bq27542, bq27546, bq27545, bq27441, bq27421, and the
bq27641.

To facilitate this process the register mapings have been moved to tables
and other small cleanups have been made.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27xxx_battery.c | 618 ++++++++++++++++++++++++++--------------
 1 file changed, 409 insertions(+), 209 deletions(-)

diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
index 5686da6..f148222 100644
--- a/drivers/power/bq27xxx_battery.c
+++ b/drivers/power/bq27xxx_battery.c
@@ -17,11 +17,15 @@
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
  * Datasheets:
- * http://focus.ti.com/docs/prod/folders/print/bq27000.html
- * http://focus.ti.com/docs/prod/folders/print/bq27500.html
+ * http://www.ti.com/product/bq27000
+ * http://www.ti.com/product/bq27010
+ * http://www.ti.com/product/bq27510-g3
+ * http://www.ti.com/product/bq27520-g4
+ * http://www.ti.com/product/bq27411-g1
+ * http://www.ti.com/product/bq27421-g1
  * http://www.ti.com/product/bq27425-g1
- * http://www.ti.com/product/BQ27742-G1
- * http://www.ti.com/product/BQ27510-G3
+ * http://www.ti.com/product/bq27742-g1
+ * http://www.ti.com/product/bq27621-g1
  */
 
 #include <linux/device.h>
@@ -43,55 +47,66 @@
 
 #define BQ27XXX_MANUFACTURER	"Texas Instruments"
 
-#define BQ27x00_REG_TEMP	0x06
-#define BQ27x00_REG_VOLT	0x08
-#define BQ27x00_REG_AI		0x14
-#define BQ27x00_REG_FLAGS	0x0A
-#define BQ27x00_REG_TTE		0x16
-#define BQ27x00_REG_TTF		0x18
-#define BQ27x00_REG_TTECP	0x26
-#define BQ27x00_REG_NAC		0x0C /* Nominal available capacity */
-#define BQ27x00_REG_LMD		0x12 /* Last measured discharge */
-#define BQ27x00_REG_CYCT	0x2A /* Cycle count total */
-#define BQ27x00_REG_AE		0x22 /* Available energy */
-#define BQ27x00_POWER_AVG	0x24
-
-#define BQ27000_REG_RSOC	0x0B /* Relative State-of-Charge */
-#define BQ27000_REG_ILMD	0x76 /* Initial last measured discharge */
+/* BQ27XXX Flags */
+#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_FC		BIT(9)
+#define BQ27XXX_FLAG_OTD	BIT(14)
+#define BQ27XXX_FLAG_OTC	BIT(15)
+
+/* BQ27000 has different layout for Flags register */
 #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
 #define BQ27000_FLAG_EDV1	BIT(1) /* First End-of-Discharge-Voltage flag */
 #define BQ27000_FLAG_CI		BIT(4) /* Capacity Inaccurate flag */
 #define BQ27000_FLAG_FC		BIT(5)
 #define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
 
-#define BQ27500_REG_SOC		0x2C
-#define BQ27500_REG_DCAP	0x3C /* Design capacity */
-#define BQ27500_FLAG_DSC	BIT(0)
-#define BQ27500_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
-#define BQ27500_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
-#define BQ27500_FLAG_FC		BIT(9)
-#define BQ27500_FLAG_OTC	BIT(15)
-
-#define BQ27742_POWER_AVG	0x76
-
-#define BQ27510_REG_SOC		0x20
-#define BQ27510_REG_DCAP	0x2E /* Design capacity */
-#define BQ27510_REG_CYCT	0x1E /* Cycle count total */
-
-/* bq27425 register addresses are same as bq27x00 addresses minus 4 */
-#define BQ27425_REG_OFFSET	0x04
-#define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
-#define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
-
-#define BQ27XXX_RS			20 /* Resistor sense */
-#define BQ27XXX_POWER_CONSTANT		(256 * 29200 / 1000)
+#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 */
 
 struct bq27xxx_device_info;
 struct bq27xxx_access_methods {
 	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
 };
 
-enum bq27xxx_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
+#define INVALID_REG_ADDR	0xff
+
+enum bq27xxx_chip {
+	BQ27000, /* bq27000, bq27200 */
+	BQ27010, /* bq27010, bq27210 */
+	BQ27500, /* bq27500, bq27510, bq27520 */
+	BQ27530, /* bq27530, bq27531 */
+	BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
+	BQ27545, /* bq27545 */
+	BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+};
+
+/*
+ * bq27xxx_reg_index - Register names
+ *
+ * These are indexes into a device's register mapping array.
+ */
+enum bq27xxx_reg_index {
+	BQ27XXX_REG_CTRL = 0,	/* Control */
+	BQ27XXX_REG_TEMP,	/* Temperature */
+	BQ27XXX_REG_INT_TEMP,	/* Internal Temperature */
+	BQ27XXX_REG_VOLT,	/* Voltage */
+	BQ27XXX_REG_AI,		/* Average Current */
+	BQ27XXX_REG_FLAGS,	/* Flags */
+	BQ27XXX_REG_TTE,	/* Time-to-Empty */
+	BQ27XXX_REG_TTF,	/* Time-to-Full */
+	BQ27XXX_REG_TTES,	/* Time-to-Empty Standby */
+	BQ27XXX_REG_TTECP,	/* Time-to-Empty at Constant Power */
+	BQ27XXX_REG_NAC,	/* Nominal Available Capacity */
+	BQ27XXX_REG_FCC,	/* Full Charge Capacity */
+	BQ27XXX_REG_CYCT,	/* Cycle Count */
+	BQ27XXX_REG_AE,		/* Available Energy */
+	BQ27XXX_REG_SOC,	/* State-of-Charge */
+	BQ27XXX_REG_DCAP,	/* Design Capacity */
+	BQ27XXX_REG_AP,		/* Average Power */
+};
 
 struct bq27xxx_reg_cache {
 	int temperature;
@@ -123,9 +138,152 @@ struct bq27xxx_device_info {
 	struct bq27xxx_access_methods bus;
 
 	struct mutex lock;
+
+	u8 *regs;
 };
 
-static enum power_supply_property bq27x00_battery_props[] = {
+/* Register mappings */
+static u8 bq27000_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x06,	/* TEMP		*/
+	0xff,	/* INT TEMP - NA*/
+	0x08,	/* VOLT		*/
+	0x14,	/* AVG CURR	*/
+	0x0a,	/* FLAGS	*/
+	0x16,	/* TTE		*/
+	0x18,	/* TTF		*/
+	0x1c,	/* TTES		*/
+	0x26,	/* TTECP	*/
+	0x0c,	/* NAC		*/
+	0x12,	/* LMD(FCC)	*/
+	0x2a,	/* CYCT		*/
+	0x22,	/* AE		*/
+	0x0b,	/* SOC(RSOC)	*/
+	0x76,	/* DCAP(ILMD)	*/
+	0x24,	/* AP		*/
+};
+
+static u8 bq27010_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x06,	/* TEMP		*/
+	0xff,	/* INT TEMP - NA*/
+	0x08,	/* VOLT		*/
+	0x14,	/* AVG CURR	*/
+	0x0a,	/* FLAGS	*/
+	0x16,	/* TTE		*/
+	0x18,	/* TTF		*/
+	0x1c,	/* TTES		*/
+	0x26,	/* TTECP	*/
+	0x0c,	/* NAC		*/
+	0x12,	/* LMD(FCC)	*/
+	0x2a,	/* CYCT		*/
+	0xff,	/* AE - NA	*/
+	0x0b,	/* SOC(RSOC)	*/
+	0x76,	/* DCAP(ILMD)	*/
+	0xff,	/* AP - NA	*/
+};
+
+static u8 bq27500_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x06,	/* TEMP		*/
+	0x28,	/* INT TEMP	*/
+	0x08,	/* VOLT		*/
+	0x14,	/* AVG CURR	*/
+	0x0a,	/* FLAGS	*/
+	0x16,	/* TTE		*/
+	0xff,	/* TTF - NA	*/
+	0x1a,	/* TTES		*/
+	0xff,	/* TTECP - NA	*/
+	0x0c,	/* NAC		*/
+	0x12,	/* LMD(FCC)	*/
+	0x1e,	/* CYCT		*/
+	0xff,	/* AE - NA	*/
+	0x20,	/* SOC(RSOC)	*/
+	0x2e,	/* DCAP(ILMD)	*/
+	0xff,	/* AP - NA	*/
+};
+
+static u8 bq27530_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x06,	/* TEMP		*/
+	0x32,	/* INT TEMP	*/
+	0x08,	/* VOLT		*/
+	0x14,	/* AVG CURR	*/
+	0x0a,	/* FLAGS	*/
+	0x16,	/* TTE		*/
+	0xff,	/* TTF - NA	*/
+	0xff,	/* TTES - NA	*/
+	0xff,	/* TTECP - NA	*/
+	0x0c,	/* NAC		*/
+	0x12,	/* LMD(FCC)	*/
+	0x2a,	/* CYCT		*/
+	0xff,	/* AE - NA	*/
+	0x2c,	/* SOC(RSOC)	*/
+	0xff,	/* DCAP - NA	*/
+	0x24,	/* AP		*/
+};
+
+static u8 bq27541_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x06,	/* TEMP		*/
+	0x28,	/* INT TEMP	*/
+	0x08,	/* VOLT		*/
+	0x14,	/* AVG CURR	*/
+	0x0a,	/* FLAGS	*/
+	0x16,	/* TTE		*/
+	0xff,	/* TTF - NA	*/
+	0xff,	/* TTES - NA	*/
+	0xff,	/* TTECP - NA	*/
+	0x0c,	/* NAC		*/
+	0x12,	/* LMD(FCC)	*/
+	0x2a,	/* CYCT		*/
+	0xff,	/* AE - NA	*/
+	0x2c,	/* SOC(RSOC)	*/
+	0x3c,	/* DCAP		*/
+	0x76,	/* AP		*/
+};
+
+static u8 bq27545_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x06,	/* TEMP		*/
+	0x28,	/* INT TEMP	*/
+	0x08,	/* VOLT		*/
+	0x14,	/* AVG CURR	*/
+	0x0a,	/* FLAGS	*/
+	0x16,	/* TTE		*/
+	0xff,	/* TTF - NA	*/
+	0xff,	/* TTES - NA	*/
+	0xff,	/* TTECP - NA	*/
+	0x0c,	/* NAC		*/
+	0x12,	/* LMD(FCC)	*/
+	0x2a,	/* CYCT		*/
+	0xff,	/* AE - NA	*/
+	0x2c,	/* SOC(RSOC)	*/
+	0xff,	/* DCAP - NA */
+	0x24,	/* AP		*/
+};
+
+static u8 bq27421_regs[] = {
+	0x00,	/* CONTROL	*/
+	0x02,	/* TEMP		*/
+	0x1e,	/* INT TEMP	*/
+	0x04,	/* VOLT		*/
+	0x10,	/* AVG CURR	*/
+	0x06,	/* FLAGS	*/
+	0xff,	/* TTE - NA	*/
+	0xff,	/* TTF - NA	*/
+	0xff,	/* TTES - NA	*/
+	0xff,	/* TTECP - NA	*/
+	0x08,	/* NAC		*/
+	0x0e,	/* FCC		*/
+	0xff,	/* CYCT - NA	*/
+	0xff,	/* AE - NA	*/
+	0x1c,	/* SOC		*/
+	0x3c,	/* DCAP		*/
+	0x18,	/* AP		*/
+};
+
+static enum power_supply_property bq27000_battery_props[] = {
 	POWER_SUPPLY_PROP_STATUS,
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
@@ -147,7 +305,7 @@ static enum power_supply_property bq27x00_battery_props[] = {
 	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
-static enum power_supply_property bq27425_battery_props[] = {
+static enum power_supply_property bq27010_battery_props[] = {
 	POWER_SUPPLY_PROP_STATUS,
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
@@ -155,14 +313,19 @@ static enum power_supply_property bq27425_battery_props[] = {
 	POWER_SUPPLY_PROP_CAPACITY,
 	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 	POWER_SUPPLY_PROP_TEMP,
+	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
+	POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
+	POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
 	POWER_SUPPLY_PROP_TECHNOLOGY,
 	POWER_SUPPLY_PROP_CHARGE_FULL,
 	POWER_SUPPLY_PROP_CHARGE_NOW,
 	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
+	POWER_SUPPLY_PROP_CYCLE_COUNT,
+	POWER_SUPPLY_PROP_HEALTH,
 	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
-static enum power_supply_property bq27742_battery_props[] = {
+static enum power_supply_property bq27500_battery_props[] = {
 	POWER_SUPPLY_PROP_STATUS,
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
@@ -176,12 +339,29 @@ static enum power_supply_property bq27742_battery_props[] = {
 	POWER_SUPPLY_PROP_CHARGE_NOW,
 	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 	POWER_SUPPLY_PROP_CYCLE_COUNT,
+	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_MANUFACTURER,
+};
+
+static enum power_supply_property bq27530_battery_props[] = {
+	POWER_SUPPLY_PROP_STATUS,
+	POWER_SUPPLY_PROP_PRESENT,
+	POWER_SUPPLY_PROP_VOLTAGE_NOW,
+	POWER_SUPPLY_PROP_CURRENT_NOW,
+	POWER_SUPPLY_PROP_CAPACITY,
+	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
+	POWER_SUPPLY_PROP_TEMP,
+	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
+	POWER_SUPPLY_PROP_TECHNOLOGY,
+	POWER_SUPPLY_PROP_CHARGE_FULL,
+	POWER_SUPPLY_PROP_CHARGE_NOW,
 	POWER_SUPPLY_PROP_POWER_AVG,
 	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_CYCLE_COUNT,
 	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
-static enum power_supply_property bq27510_battery_props[] = {
+static enum power_supply_property bq27541_battery_props[] = {
 	POWER_SUPPLY_PROP_STATUS,
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
@@ -200,6 +380,39 @@ static enum power_supply_property bq27510_battery_props[] = {
 	POWER_SUPPLY_PROP_MANUFACTURER,
 };
 
+static enum power_supply_property bq27545_battery_props[] = {
+	POWER_SUPPLY_PROP_STATUS,
+	POWER_SUPPLY_PROP_PRESENT,
+	POWER_SUPPLY_PROP_VOLTAGE_NOW,
+	POWER_SUPPLY_PROP_CURRENT_NOW,
+	POWER_SUPPLY_PROP_CAPACITY,
+	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
+	POWER_SUPPLY_PROP_TEMP,
+	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
+	POWER_SUPPLY_PROP_TECHNOLOGY,
+	POWER_SUPPLY_PROP_CHARGE_FULL,
+	POWER_SUPPLY_PROP_CHARGE_NOW,
+	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_CYCLE_COUNT,
+	POWER_SUPPLY_PROP_POWER_AVG,
+	POWER_SUPPLY_PROP_MANUFACTURER,
+};
+
+static enum power_supply_property bq27421_battery_props[] = {
+	POWER_SUPPLY_PROP_STATUS,
+	POWER_SUPPLY_PROP_PRESENT,
+	POWER_SUPPLY_PROP_VOLTAGE_NOW,
+	POWER_SUPPLY_PROP_CURRENT_NOW,
+	POWER_SUPPLY_PROP_CAPACITY,
+	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
+	POWER_SUPPLY_PROP_TEMP,
+	POWER_SUPPLY_PROP_TECHNOLOGY,
+	POWER_SUPPLY_PROP_CHARGE_FULL,
+	POWER_SUPPLY_PROP_CHARGE_NOW,
+	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
+	POWER_SUPPLY_PROP_MANUFACTURER,
+};
+
 static unsigned int poll_interval = 360;
 module_param(poll_interval, uint, 0644);
 MODULE_PARM_DESC(poll_interval,
@@ -209,25 +422,14 @@ MODULE_PARM_DESC(poll_interval,
  * Common code for BQ27xxx devices
  */
 
-static inline int bq27xxx_read(struct bq27xxx_device_info *di, u8 reg,
+static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
 			       bool single)
 {
-	if (di->chip == BQ27425)
-		return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
-	return di->bus.read(di, reg, single);
-}
+	/* Reports EINVAL for invalid/missing registers */
+	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
+		return -EINVAL;
 
-/*
- * Higher versions of the chip like BQ27425 and BQ27500
- * differ from BQ27000 and BQ27200 in calculation of certain
- * parameters. Hence we need to check for the chip type.
- */
-static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
-{
-	if (di->chip == BQ27425 || di->chip == BQ27500 || di->chip == BQ27742
-	    || di->chip == BQ27510)
-		return true;
-	return false;
+	return di->bus.read(di, di->regs[reg_index], single);
 }
 
 /*
@@ -238,14 +440,7 @@ static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
 {
 	int soc;
 
-	if (di->chip == BQ27500 || di->chip == BQ27742)
-		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
-	else if (di->chip == BQ27510)
-		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
-	else if (di->chip == BQ27425)
-		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
-	else
-		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
+	soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
 
 	if (soc < 0)
 		dev_dbg(di->dev, "error reading State-of-Charge\n");
@@ -268,10 +463,10 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
 		return charge;
 	}
 
-	if (bq27xxx_is_chip_version_higher(di))
-		charge *= 1000;
+	if (di->chip == BQ27000 || di->chip == BQ27010)
+		charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
 	else
-		charge = charge * 3570 / BQ27XXX_RS;
+		charge *= 1000;
 
 	return charge;
 }
@@ -283,57 +478,46 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
 {
 	int flags;
-	bool is_bq27500 = di->chip == BQ27500;
-	bool is_bq27742 = di->chip == BQ27742;
-	bool is_higher = bq27xxx_is_chip_version_higher(di);
-	bool flags_1b = !(is_bq27500 || is_bq27742);
 
-	flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
-	if (flags >= 0 && !is_higher && (flags & BQ27000_FLAG_CI))
-		return -ENODATA;
+	if (di->chip == BQ27000 || di->chip == BQ27010) {
+		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
+		if (flags >= 0 && (flags & BQ27000_FLAG_CI))
+			return -ENODATA;
+	}
 
-	return bq27xxx_battery_read_charge(di, BQ27x00_REG_NAC);
+	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
 }
 
 /*
- * Return the battery Last measured discharge in µAh
+ * Return the battery Full Charge Capacity in µAh
  * Or < 0 if something fails.
  */
-static inline int bq27xxx_battery_read_lmd(struct bq27xxx_device_info *di)
+static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
 {
-	return bq27xxx_battery_read_charge(di, BQ27x00_REG_LMD);
+	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
 }
 
 /*
- * Return the battery Initial last measured discharge in µAh
+ * Return the Design Capacity in µAh
  * Or < 0 if something fails.
  */
-static int bq27xxx_battery_read_ilmd(struct bq27xxx_device_info *di)
+static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
 {
-	int ilmd;
+	int dcap;
 
-	if (bq27xxx_is_chip_version_higher(di)) {
-		if (di->chip == BQ27425)
-			ilmd = bq27xxx_read(di, BQ27425_REG_DCAP, false);
-		else if (di->chip == BQ27510)
-			ilmd = bq27xxx_read(di, BQ27510_REG_DCAP, false);
-		else
-			ilmd = bq27xxx_read(di, BQ27500_REG_DCAP, false);
-	} else {
-		ilmd = bq27xxx_read(di, BQ27000_REG_ILMD, true);
-	}
+	dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
 
-	if (ilmd < 0) {
+	if (dcap < 0) {
 		dev_dbg(di->dev, "error reading initial last measured discharge\n");
-		return ilmd;
+		return dcap;
 	}
 
-	if (bq27xxx_is_chip_version_higher(di))
-		ilmd *= 1000;
+	if (di->chip == BQ27000 || di->chip == BQ27010)
+		dcap *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
 	else
-		ilmd = ilmd * 256 * 3570 / BQ27XXX_RS;
+		dcap *= 1000;
 
-	return ilmd;
+	return dcap;
 }
 
 /*
@@ -344,16 +528,16 @@ static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
 {
 	int ae;
 
-	ae = bq27xxx_read(di, BQ27x00_REG_AE, false);
+	ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
 	if (ae < 0) {
 		dev_dbg(di->dev, "error reading available energy\n");
 		return ae;
 	}
 
-	if (di->chip == BQ27500)
-		ae *= 1000;
+	if (di->chip == BQ27000 || di->chip == BQ27010)
+		ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS;
 	else
-		ae = ae * 29200 / BQ27XXX_RS;
+		ae *= 1000;
 
 	return ae;
 }
@@ -366,13 +550,13 @@ static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
 {
 	int temp;
 
-	temp = bq27xxx_read(di, BQ27x00_REG_TEMP, false);
+	temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
 	if (temp < 0) {
 		dev_err(di->dev, "error reading temperature\n");
 		return temp;
 	}
 
-	if (!bq27xxx_is_chip_version_higher(di))
+	if (di->chip == BQ27000 || di->chip == BQ27010)
 		temp = 5 * temp / 2;
 
 	return temp;
@@ -386,10 +570,7 @@ static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
 {
 	int cyct;
 
-	if (di->chip == BQ27510)
-		cyct = bq27xxx_read(di, BQ27510_REG_CYCT, false);
-	else
-		cyct = bq27xxx_read(di, BQ27x00_REG_CYCT, false);
+	cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
 	if (cyct < 0)
 		dev_err(di->dev, "error reading cycle count total\n");
 
@@ -421,21 +602,32 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
  * Read an average power register.
  * Return < 0 if something fails.
  */
-static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
+static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
 {
 	int tval;
 
-	tval = bq27xxx_read(di, reg, false);
+	tval = bq27xxx_read(di, BQ27XXX_REG_AP, false);
 	if (tval < 0) {
-		dev_err(di->dev, "error reading power avg rgister  %02x: %d\n",
-			reg, tval);
+		dev_err(di->dev, "error reading average power register  %02x: %d\n",
+			BQ27XXX_REG_AP, tval);
 		return tval;
 	}
 
-	if (di->chip == BQ27500)
+	if (di->chip == BQ27000 || di->chip == BQ27010)
+		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
+	else
 		return tval;
+}
+
+/*
+ * Returns true if a battery over temperature condition is detected
+ */
+static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
+{
+	if (di->chip == BQ27500 || di->chip == BQ27541)
+		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
 	else
-		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
+		return flags & BQ27XXX_FLAG_OTC;
 }
 
 /*
@@ -444,53 +636,43 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
  */
 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
 {
-	int tval;
+	u16 tval;
 
-	tval = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
+	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
 	if (tval < 0) {
 		dev_err(di->dev, "error reading flag register:%d\n", tval);
 		return tval;
 	}
 
-	if (di->chip == BQ27500) {
-		if (tval & BQ27500_FLAG_SOCF)
+	if (di->chip == BQ27000 || di->chip == BQ27010) {
+		if (tval & BQ27000_FLAG_EDV1)
 			tval = POWER_SUPPLY_HEALTH_DEAD;
-		else if (tval & BQ27500_FLAG_OTC)
-			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
 		else
 			tval = POWER_SUPPLY_HEALTH_GOOD;
-		return tval;
-	} else if (di->chip == BQ27510) {
-		if (tval & BQ27500_FLAG_OTC)
-			return POWER_SUPPLY_HEALTH_OVERHEAT;
-		return POWER_SUPPLY_HEALTH_GOOD;
 	} else {
-		if (tval & BQ27000_FLAG_EDV1)
+		if (tval & BQ27XXX_FLAG_SOCF)
 			tval = POWER_SUPPLY_HEALTH_DEAD;
+		else if (bq27xxx_battery_overtemp(di, tval))
+			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
 		else
 			tval = POWER_SUPPLY_HEALTH_GOOD;
-		return tval;
 	}
 
-	return -1;
+	return tval;
 }
 
 static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
 {
 	struct bq27xxx_reg_cache cache = {0, };
-	bool is_bq27500 = di->chip == BQ27500;
-	bool is_bq27510 = di->chip == BQ27510;
-	bool is_bq27425 = di->chip == BQ27425;
-	bool is_bq27742 = di->chip == BQ27742;
-	bool flags_1b = !(is_bq27500 || is_bq27742);
+	bool has_ci_flag = di->chip == BQ27000 || di->chip == BQ27010;
+	bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010;
 
-	cache.flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
+	cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
 	if ((cache.flags & 0xff) == 0xff)
-		/* read error */
-		cache.flags = -1;
+		cache.flags = -1; /* read error */
 	if (cache.flags >= 0) {
-		if (!is_bq27500 && !is_bq27425 && !is_bq27742 && !is_bq27510
-				&& (cache.flags & BQ27000_FLAG_CI)) {
+		cache.temperature = bq27xxx_battery_read_temperature(di);
+		if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) {
 			dev_info(di->dev, "battery is not calibrated! ignoring capacity values\n");
 			cache.capacity = -ENODATA;
 			cache.energy = -ENODATA;
@@ -500,41 +682,25 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
 			cache.charge_full = -ENODATA;
 			cache.health = -ENODATA;
 		} else {
+			if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
+				cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
+			if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
+				cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
+			if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
+				cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
+			cache.charge_full = bq27xxx_battery_read_fcc(di);
 			cache.capacity = bq27xxx_battery_read_soc(di);
-			if (is_bq27742 || is_bq27510)
-				cache.time_to_empty =
-					bq27xxx_battery_read_time(di,
-							BQ27x00_REG_TTE);
-			else if (!is_bq27425) {
+			if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
 				cache.energy = bq27xxx_battery_read_energy(di);
-				cache.time_to_empty =
-					bq27xxx_battery_read_time(di,
-							BQ27x00_REG_TTE);
-				cache.time_to_empty_avg =
-					bq27xxx_battery_read_time(di,
-							BQ27x00_REG_TTECP);
-				cache.time_to_full =
-					bq27xxx_battery_read_time(di,
-							BQ27x00_REG_TTF);
-			}
-			cache.charge_full = bq27xxx_battery_read_lmd(di);
 			cache.health = bq27xxx_battery_read_health(di);
 		}
-		cache.temperature = bq27xxx_battery_read_temperature(di);
-		if (!is_bq27425)
+		if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
 			cache.cycle_count = bq27xxx_battery_read_cyct(di);
-		if (is_bq27742)
-			cache.power_avg =
-				bq27xxx_battery_read_pwr_avg(di,
-						BQ27742_POWER_AVG);
-		else
-			cache.power_avg =
-				bq27xxx_battery_read_pwr_avg(di,
-						BQ27x00_POWER_AVG);
+		cache.power_avg = bq27xxx_battery_read_pwr_avg(di);
 
 		/* We only have to read charge design full once */
 		if (di->charge_design_full <= 0)
-			di->charge_design_full = bq27xxx_battery_read_ilmd(di);
+			di->charge_design_full = bq27xxx_battery_read_dcap(di);
 	}
 
 	if (di->cache.capacity != cache.capacity)
@@ -549,7 +715,8 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
 static void bq27xxx_battery_poll(struct work_struct *work)
 {
 	struct bq27xxx_device_info *di =
-		container_of(work, struct bq27xxx_device_info, work.work);
+			container_of(work, struct bq27xxx_device_info,
+				     work.work);
 
 	bq27xxx_battery_update(di);
 
@@ -571,23 +738,23 @@ static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
 	int curr;
 	int flags;
 
-	curr = bq27xxx_read(di, BQ27x00_REG_AI, false);
+	curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
 	if (curr < 0) {
 		dev_err(di->dev, "error reading current\n");
 		return curr;
 	}
 
-	if (bq27xxx_is_chip_version_higher(di)) {
-		/* bq27500 returns signed value */
-		val->intval = (int)((s16)curr) * 1000;
-	} else {
-		flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
+	if (di->chip == BQ27000 || di->chip == BQ27010) {
+		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
 		if (flags & BQ27000_FLAG_CHGS) {
 			dev_dbg(di->dev, "negative current!\n");
 			curr = -curr;
 		}
 
-		val->intval = curr * 3570 / BQ27XXX_RS;
+		val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
+	} else {
+		/* Other gauges return signed value */
+		val->intval = (int)((s16)curr) * 1000;
 	}
 
 	return 0;
@@ -598,14 +765,7 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
 {
 	int status;
 
-	if (bq27xxx_is_chip_version_higher(di)) {
-		if (di->cache.flags & BQ27500_FLAG_FC)
-			status = POWER_SUPPLY_STATUS_FULL;
-		else if (di->cache.flags & BQ27500_FLAG_DSC)
-			status = POWER_SUPPLY_STATUS_DISCHARGING;
-		else
-			status = POWER_SUPPLY_STATUS_CHARGING;
-	} else {
+	if (di->chip == BQ27000 || di->chip == BQ27010) {
 		if (di->cache.flags & BQ27000_FLAG_FC)
 			status = POWER_SUPPLY_STATUS_FULL;
 		else if (di->cache.flags & BQ27000_FLAG_CHGS)
@@ -614,6 +774,13 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
 			status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 		else
 			status = POWER_SUPPLY_STATUS_DISCHARGING;
+	} else {
+		if (di->cache.flags & BQ27XXX_FLAG_FC)
+			status = POWER_SUPPLY_STATUS_FULL;
+		else if (di->cache.flags & BQ27XXX_FLAG_DSC)
+			status = POWER_SUPPLY_STATUS_DISCHARGING;
+		else
+			status = POWER_SUPPLY_STATUS_CHARGING;
 	}
 
 	val->intval = status;
@@ -626,21 +793,21 @@ static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
 {
 	int level;
 
-	if (bq27xxx_is_chip_version_higher(di)) {
-		if (di->cache.flags & BQ27500_FLAG_FC)
+	if (di->chip == BQ27000 || di->chip == BQ27010) {
+		if (di->cache.flags & BQ27000_FLAG_FC)
 			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
-		else if (di->cache.flags & BQ27500_FLAG_SOC1)
+		else if (di->cache.flags & BQ27000_FLAG_EDV1)
 			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
-		else if (di->cache.flags & BQ27500_FLAG_SOCF)
+		else if (di->cache.flags & BQ27000_FLAG_EDVF)
 			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 		else
 			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 	} else {
-		if (di->cache.flags & BQ27000_FLAG_FC)
+		if (di->cache.flags & BQ27XXX_FLAG_FC)
 			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
-		else if (di->cache.flags & BQ27000_FLAG_EDV1)
+		else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
 			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
-		else if (di->cache.flags & BQ27000_FLAG_EDVF)
+		else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
 			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 		else
 			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
@@ -660,7 +827,7 @@ static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
 {
 	int volt;
 
-	volt = bq27xxx_read(di, BQ27x00_REG_VOLT, false);
+	volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
 	if (volt < 0) {
 		dev_err(di->dev, "error reading voltage\n");
 		return volt;
@@ -721,7 +888,7 @@ static int bq27xxx_battery_get_property(struct power_supply *psy,
 	case POWER_SUPPLY_PROP_TEMP:
 		ret = bq27xxx_simple_value(di->cache.temperature, val);
 		if (ret == 0)
-			val->intval -= 2731;
+			val->intval -= 2731; /* convert decidegree k to c */
 		break;
 	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
@@ -787,18 +954,27 @@ static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
 
 	psy_desc->name = name;
 	psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
-	if (di->chip == BQ27425) {
-		psy_desc->properties = bq27425_battery_props;
-		psy_desc->num_properties = ARRAY_SIZE(bq27425_battery_props);
-	} else if (di->chip == BQ27742) {
-		psy_desc->properties = bq27742_battery_props;
-		psy_desc->num_properties = ARRAY_SIZE(bq27742_battery_props);
-	} else if (di->chip == BQ27510) {
-		psy_desc->properties = bq27510_battery_props;
-		psy_desc->num_properties = ARRAY_SIZE(bq27510_battery_props);
+	if (di->chip == BQ27000) {
+		psy_desc->properties = bq27000_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27000_battery_props);
+	} else if (di->chip == BQ27010) {
+		psy_desc->properties = bq27010_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27010_battery_props);
+	} else if (di->chip == BQ27500) {
+		psy_desc->properties = bq27500_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27500_battery_props);
+	} else if (di->chip == BQ27530) {
+		psy_desc->properties = bq27530_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27530_battery_props);
+	} else if (di->chip == BQ27541) {
+		psy_desc->properties = bq27541_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27541_battery_props);
+	} else if (di->chip == BQ27545) {
+		psy_desc->properties = bq27545_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27545_battery_props);
 	} else {
-		psy_desc->properties = bq27x00_battery_props;
-		psy_desc->num_properties = ARRAY_SIZE(bq27x00_battery_props);
+		psy_desc->properties = bq27421_battery_props;
+		psy_desc->num_properties = ARRAY_SIZE(bq27421_battery_props);
 	}
 	psy_desc->get_property = bq27xxx_battery_get_property;
 	psy_desc->external_power_changed = bq27xxx_external_power_changed;
@@ -913,10 +1089,32 @@ static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
 	di->chip = id->driver_data;
 	di->bus.read = &bq27xxx_battery_i2c_read;
 
+	if (di->chip == BQ27000) {
+		di->regs = bq27000_regs;
+	} else if (di->chip == BQ27010) {
+		di->regs = bq27010_regs;
+	} else if (di->chip == BQ27500) {
+		di->regs = bq27500_regs;
+	} else if (di->chip == BQ27530) {
+		di->regs = bq27530_regs;
+	} else if (di->chip == BQ27541) {
+		di->regs = bq27541_regs;
+	} else if (di->chip == BQ27545) {
+		di->regs = bq27545_regs;
+	} else if (di->chip == BQ27421) {
+		di->regs = bq27421_regs;
+	} else {
+		dev_err(&client->dev, "Unexpected gas gauge: %d\n", di->chip);
+		di->regs = bq27000_regs;
+	}
+
 	retval = bq27xxx_powersupply_init(di, name);
 	if (retval)
 		goto batt_failed;
 
+	/* Schedule a polling after about 1 min */
+	schedule_delayed_work(&di->work, 60 * HZ);
+
 	i2c_set_clientdata(client, di);
 
 	return 0;
@@ -943,11 +1141,13 @@ static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
 }
 
 static const struct i2c_device_id bq27xxx_id[] = {
-	{ "bq27200", BQ27000 },	/* bq27200 is same as bq27000, but with i2c */
+	{ "bq27000", BQ27000 },
+	{ "bq27010", BQ27010 },
 	{ "bq27500", BQ27500 },
-	{ "bq27425", BQ27425 },
-	{ "bq27742", BQ27742 },
-	{ "bq27510", BQ27510 },
+	{ "bq27530", BQ27530 },
+	{ "bq27541", BQ27541 },
+	{ "bq27545", BQ27545 },
+	{ "bq27421", BQ27421 },
 	{},
 };
 MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
-- 
1.9.1

Re: [PATCH 7/8] power: bq27xxx_battery: Add support for additional bq27xxx family devices

[Pali Rohár]

On Wednesday 22 July 2015 16:51:59 Andrew F. Davis wrote:
> Add support for additional devices and register equivalent family devices
> including the bq27010, bq27210, bq272500, bq27510, bq27520, bq27530,
> bq27531, bq27541, bq27542, bq27546, bq27545, bq27441, bq27421, and the
> bq27641.
> 
> To facilitate this process the register mapings have been moved to tables
> and other small cleanups have been made.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27xxx_battery.c | 618 ++++++++++++++++++++++++++--------------
>  1 file changed, 409 insertions(+), 209 deletions(-)
> 
> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
> index 5686da6..f148222 100644
> --- a/drivers/power/bq27xxx_battery.c
> +++ b/drivers/power/bq27xxx_battery.c
> @@ -17,11 +17,15 @@
>   * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
>   *
>   * Datasheets:
> - * http://focus.ti.com/docs/prod/folders/print/bq27000.html
> - * http://focus.ti.com/docs/prod/folders/print/bq27500.html
> + * http://www.ti.com/product/bq27000
> + * http://www.ti.com/product/bq27010
> + * http://www.ti.com/product/bq27510-g3
> + * http://www.ti.com/product/bq27520-g4
> + * http://www.ti.com/product/bq27411-g1
> + * http://www.ti.com/product/bq27421-g1
>   * http://www.ti.com/product/bq27425-g1
> - * http://www.ti.com/product/BQ27742-G1
> - * http://www.ti.com/product/BQ27510-G3
> + * http://www.ti.com/product/bq27742-g1
> + * http://www.ti.com/product/bq27621-g1
>   */

Now, when you touching list of links to documentation, you can add also
one for bq27200: http://www.ti.com/product/bq27200

>  
>  #include <linux/device.h>
> @@ -43,55 +47,66 @@
>  
>  #define BQ27XXX_MANUFACTURER	"Texas Instruments"
>  
> -#define BQ27x00_REG_TEMP	0x06
> -#define BQ27x00_REG_VOLT	0x08
> -#define BQ27x00_REG_AI		0x14
> -#define BQ27x00_REG_FLAGS	0x0A
> -#define BQ27x00_REG_TTE		0x16
> -#define BQ27x00_REG_TTF		0x18
> -#define BQ27x00_REG_TTECP	0x26
> -#define BQ27x00_REG_NAC		0x0C /* Nominal available capacity */
> -#define BQ27x00_REG_LMD		0x12 /* Last measured discharge */
> -#define BQ27x00_REG_CYCT	0x2A /* Cycle count total */
> -#define BQ27x00_REG_AE		0x22 /* Available energy */
> -#define BQ27x00_POWER_AVG	0x24
> -
> -#define BQ27000_REG_RSOC	0x0B /* Relative State-of-Charge */
> -#define BQ27000_REG_ILMD	0x76 /* Initial last measured discharge */
> +/* BQ27XXX Flags */
> +#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_FC		BIT(9)
> +#define BQ27XXX_FLAG_OTD	BIT(14)
> +#define BQ27XXX_FLAG_OTC	BIT(15)
> +
> +/* BQ27000 has different layout for Flags register */
>  #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
>  #define BQ27000_FLAG_EDV1	BIT(1) /* First End-of-Discharge-Voltage flag */
>  #define BQ27000_FLAG_CI		BIT(4) /* Capacity Inaccurate flag */
>  #define BQ27000_FLAG_FC		BIT(5)
>  #define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
>  
> -#define BQ27500_REG_SOC		0x2C
> -#define BQ27500_REG_DCAP	0x3C /* Design capacity */
> -#define BQ27500_FLAG_DSC	BIT(0)
> -#define BQ27500_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
> -#define BQ27500_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
> -#define BQ27500_FLAG_FC		BIT(9)
> -#define BQ27500_FLAG_OTC	BIT(15)
> -
> -#define BQ27742_POWER_AVG	0x76
> -
> -#define BQ27510_REG_SOC		0x20
> -#define BQ27510_REG_DCAP	0x2E /* Design capacity */
> -#define BQ27510_REG_CYCT	0x1E /* Cycle count total */
> -
> -/* bq27425 register addresses are same as bq27x00 addresses minus 4 */
> -#define BQ27425_REG_OFFSET	0x04
> -#define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
> -#define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
> -
> -#define BQ27XXX_RS			20 /* Resistor sense */
> -#define BQ27XXX_POWER_CONSTANT		(256 * 29200 / 1000)
> +#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 */
>  
>  struct bq27xxx_device_info;
>  struct bq27xxx_access_methods {
>  	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
>  };
>  
> -enum bq27xxx_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
> +#define INVALID_REG_ADDR	0xff
> +
> +enum bq27xxx_chip {
> +	BQ27000, /* bq27000, bq27200 */
> +	BQ27010, /* bq27010, bq27210 */
> +	BQ27500, /* bq27500, bq27510, bq27520 */
> +	BQ27530, /* bq27530, bq27531 */
> +	BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
> +	BQ27545, /* bq27545 */
> +	BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
> +};
> +
> +/*
> + * bq27xxx_reg_index - Register names
> + *
> + * These are indexes into a device's register mapping array.
> + */
> +enum bq27xxx_reg_index {
> +	BQ27XXX_REG_CTRL = 0,	/* Control */
> +	BQ27XXX_REG_TEMP,	/* Temperature */
> +	BQ27XXX_REG_INT_TEMP,	/* Internal Temperature */
> +	BQ27XXX_REG_VOLT,	/* Voltage */
> +	BQ27XXX_REG_AI,		/* Average Current */
> +	BQ27XXX_REG_FLAGS,	/* Flags */
> +	BQ27XXX_REG_TTE,	/* Time-to-Empty */
> +	BQ27XXX_REG_TTF,	/* Time-to-Full */
> +	BQ27XXX_REG_TTES,	/* Time-to-Empty Standby */
> +	BQ27XXX_REG_TTECP,	/* Time-to-Empty at Constant Power */
> +	BQ27XXX_REG_NAC,	/* Nominal Available Capacity */
> +	BQ27XXX_REG_FCC,	/* Full Charge Capacity */
> +	BQ27XXX_REG_CYCT,	/* Cycle Count */
> +	BQ27XXX_REG_AE,		/* Available Energy */
> +	BQ27XXX_REG_SOC,	/* State-of-Charge */
> +	BQ27XXX_REG_DCAP,	/* Design Capacity */
> +	BQ27XXX_REG_AP,		/* Average Power */
> +};
>  
>  struct bq27xxx_reg_cache {
>  	int temperature;
> @@ -123,9 +138,152 @@ struct bq27xxx_device_info {
>  	struct bq27xxx_access_methods bus;
>  
>  	struct mutex lock;
> +
> +	u8 *regs;
>  };
>  
> -static enum power_supply_property bq27x00_battery_props[] = {
> +/* Register mappings */
> +static u8 bq27000_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x06,	/* TEMP		*/
> +	0xff,	/* INT TEMP - NA*/
> +	0x08,	/* VOLT		*/
> +	0x14,	/* AVG CURR	*/
> +	0x0a,	/* FLAGS	*/
> +	0x16,	/* TTE		*/
> +	0x18,	/* TTF		*/
> +	0x1c,	/* TTES		*/
> +	0x26,	/* TTECP	*/
> +	0x0c,	/* NAC		*/
> +	0x12,	/* LMD(FCC)	*/
> +	0x2a,	/* CYCT		*/
> +	0x22,	/* AE		*/
> +	0x0b,	/* SOC(RSOC)	*/
> +	0x76,	/* DCAP(ILMD)	*/
> +	0x24,	/* AP		*/
> +};
> +
> +static u8 bq27010_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x06,	/* TEMP		*/
> +	0xff,	/* INT TEMP - NA*/
> +	0x08,	/* VOLT		*/
> +	0x14,	/* AVG CURR	*/
> +	0x0a,	/* FLAGS	*/
> +	0x16,	/* TTE		*/
> +	0x18,	/* TTF		*/
> +	0x1c,	/* TTES		*/
> +	0x26,	/* TTECP	*/
> +	0x0c,	/* NAC		*/
> +	0x12,	/* LMD(FCC)	*/
> +	0x2a,	/* CYCT		*/
> +	0xff,	/* AE - NA	*/
> +	0x0b,	/* SOC(RSOC)	*/
> +	0x76,	/* DCAP(ILMD)	*/
> +	0xff,	/* AP - NA	*/
> +};
> +
> +static u8 bq27500_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x06,	/* TEMP		*/
> +	0x28,	/* INT TEMP	*/
> +	0x08,	/* VOLT		*/
> +	0x14,	/* AVG CURR	*/
> +	0x0a,	/* FLAGS	*/
> +	0x16,	/* TTE		*/
> +	0xff,	/* TTF - NA	*/
> +	0x1a,	/* TTES		*/
> +	0xff,	/* TTECP - NA	*/
> +	0x0c,	/* NAC		*/
> +	0x12,	/* LMD(FCC)	*/
> +	0x1e,	/* CYCT		*/
> +	0xff,	/* AE - NA	*/
> +	0x20,	/* SOC(RSOC)	*/
> +	0x2e,	/* DCAP(ILMD)	*/
> +	0xff,	/* AP - NA	*/
> +};
> +
> +static u8 bq27530_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x06,	/* TEMP		*/
> +	0x32,	/* INT TEMP	*/
> +	0x08,	/* VOLT		*/
> +	0x14,	/* AVG CURR	*/
> +	0x0a,	/* FLAGS	*/
> +	0x16,	/* TTE		*/
> +	0xff,	/* TTF - NA	*/
> +	0xff,	/* TTES - NA	*/
> +	0xff,	/* TTECP - NA	*/
> +	0x0c,	/* NAC		*/
> +	0x12,	/* LMD(FCC)	*/
> +	0x2a,	/* CYCT		*/
> +	0xff,	/* AE - NA	*/
> +	0x2c,	/* SOC(RSOC)	*/
> +	0xff,	/* DCAP - NA	*/
> +	0x24,	/* AP		*/
> +};
> +
> +static u8 bq27541_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x06,	/* TEMP		*/
> +	0x28,	/* INT TEMP	*/
> +	0x08,	/* VOLT		*/
> +	0x14,	/* AVG CURR	*/
> +	0x0a,	/* FLAGS	*/
> +	0x16,	/* TTE		*/
> +	0xff,	/* TTF - NA	*/
> +	0xff,	/* TTES - NA	*/
> +	0xff,	/* TTECP - NA	*/
> +	0x0c,	/* NAC		*/
> +	0x12,	/* LMD(FCC)	*/
> +	0x2a,	/* CYCT		*/
> +	0xff,	/* AE - NA	*/
> +	0x2c,	/* SOC(RSOC)	*/
> +	0x3c,	/* DCAP		*/
> +	0x76,	/* AP		*/
> +};
> +
> +static u8 bq27545_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x06,	/* TEMP		*/
> +	0x28,	/* INT TEMP	*/
> +	0x08,	/* VOLT		*/
> +	0x14,	/* AVG CURR	*/
> +	0x0a,	/* FLAGS	*/
> +	0x16,	/* TTE		*/
> +	0xff,	/* TTF - NA	*/
> +	0xff,	/* TTES - NA	*/
> +	0xff,	/* TTECP - NA	*/
> +	0x0c,	/* NAC		*/
> +	0x12,	/* LMD(FCC)	*/
> +	0x2a,	/* CYCT		*/
> +	0xff,	/* AE - NA	*/
> +	0x2c,	/* SOC(RSOC)	*/
> +	0xff,	/* DCAP - NA */
> +	0x24,	/* AP		*/
> +};
> +
> +static u8 bq27421_regs[] = {
> +	0x00,	/* CONTROL	*/
> +	0x02,	/* TEMP		*/
> +	0x1e,	/* INT TEMP	*/
> +	0x04,	/* VOLT		*/
> +	0x10,	/* AVG CURR	*/
> +	0x06,	/* FLAGS	*/
> +	0xff,	/* TTE - NA	*/
> +	0xff,	/* TTF - NA	*/
> +	0xff,	/* TTES - NA	*/
> +	0xff,	/* TTECP - NA	*/
> +	0x08,	/* NAC		*/
> +	0x0e,	/* FCC		*/
> +	0xff,	/* CYCT - NA	*/
> +	0xff,	/* AE - NA	*/
> +	0x1c,	/* SOC		*/
> +	0x3c,	/* DCAP		*/
> +	0x18,	/* AP		*/
> +};
> +
> +static enum power_supply_property bq27000_battery_props[] = {
>  	POWER_SUPPLY_PROP_STATUS,
>  	POWER_SUPPLY_PROP_PRESENT,
>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> @@ -147,7 +305,7 @@ static enum power_supply_property bq27x00_battery_props[] = {
>  	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
> -static enum power_supply_property bq27425_battery_props[] = {
> +static enum power_supply_property bq27010_battery_props[] = {
>  	POWER_SUPPLY_PROP_STATUS,
>  	POWER_SUPPLY_PROP_PRESENT,
>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> @@ -155,14 +313,19 @@ static enum power_supply_property bq27425_battery_props[] = {
>  	POWER_SUPPLY_PROP_CAPACITY,
>  	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
>  	POWER_SUPPLY_PROP_TEMP,
> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
> +	POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
>  	POWER_SUPPLY_PROP_TECHNOLOGY,
>  	POWER_SUPPLY_PROP_CHARGE_FULL,
>  	POWER_SUPPLY_PROP_CHARGE_NOW,
>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
> +	POWER_SUPPLY_PROP_HEALTH,
>  	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
> -static enum power_supply_property bq27742_battery_props[] = {
> +static enum power_supply_property bq27500_battery_props[] = {
>  	POWER_SUPPLY_PROP_STATUS,
>  	POWER_SUPPLY_PROP_PRESENT,
>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> @@ -176,12 +339,29 @@ static enum power_supply_property bq27742_battery_props[] = {
>  	POWER_SUPPLY_PROP_CHARGE_NOW,
>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
>  	POWER_SUPPLY_PROP_CYCLE_COUNT,
> +	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
> +};
> +
> +static enum power_supply_property bq27530_battery_props[] = {
> +	POWER_SUPPLY_PROP_STATUS,
> +	POWER_SUPPLY_PROP_PRESENT,
> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> +	POWER_SUPPLY_PROP_CAPACITY,
> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> +	POWER_SUPPLY_PROP_TEMP,
> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
> +	POWER_SUPPLY_PROP_TECHNOLOGY,
> +	POWER_SUPPLY_PROP_CHARGE_FULL,
> +	POWER_SUPPLY_PROP_CHARGE_NOW,
>  	POWER_SUPPLY_PROP_POWER_AVG,
>  	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
>  	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
> -static enum power_supply_property bq27510_battery_props[] = {
> +static enum power_supply_property bq27541_battery_props[] = {
>  	POWER_SUPPLY_PROP_STATUS,
>  	POWER_SUPPLY_PROP_PRESENT,
>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> @@ -200,6 +380,39 @@ static enum power_supply_property bq27510_battery_props[] = {
>  	POWER_SUPPLY_PROP_MANUFACTURER,
>  };
>  
> +static enum power_supply_property bq27545_battery_props[] = {
> +	POWER_SUPPLY_PROP_STATUS,
> +	POWER_SUPPLY_PROP_PRESENT,
> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> +	POWER_SUPPLY_PROP_CAPACITY,
> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> +	POWER_SUPPLY_PROP_TEMP,
> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
> +	POWER_SUPPLY_PROP_TECHNOLOGY,
> +	POWER_SUPPLY_PROP_CHARGE_FULL,
> +	POWER_SUPPLY_PROP_CHARGE_NOW,
> +	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
> +	POWER_SUPPLY_PROP_POWER_AVG,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
> +};
> +
> +static enum power_supply_property bq27421_battery_props[] = {
> +	POWER_SUPPLY_PROP_STATUS,
> +	POWER_SUPPLY_PROP_PRESENT,
> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> +	POWER_SUPPLY_PROP_CAPACITY,
> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> +	POWER_SUPPLY_PROP_TEMP,
> +	POWER_SUPPLY_PROP_TECHNOLOGY,
> +	POWER_SUPPLY_PROP_CHARGE_FULL,
> +	POWER_SUPPLY_PROP_CHARGE_NOW,
> +	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
> +};
> +
>  static unsigned int poll_interval = 360;
>  module_param(poll_interval, uint, 0644);
>  MODULE_PARM_DESC(poll_interval,
> @@ -209,25 +422,14 @@ MODULE_PARM_DESC(poll_interval,
>   * Common code for BQ27xxx devices
>   */
>  
> -static inline int bq27xxx_read(struct bq27xxx_device_info *di, u8 reg,
> +static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
>  			       bool single)
>  {
> -	if (di->chip == BQ27425)
> -		return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
> -	return di->bus.read(di, reg, single);
> -}
> +	/* Reports EINVAL for invalid/missing registers */
> +	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
> +		return -EINVAL;
>  
> -/*
> - * Higher versions of the chip like BQ27425 and BQ27500
> - * differ from BQ27000 and BQ27200 in calculation of certain
> - * parameters. Hence we need to check for the chip type.
> - */
> -static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
> -{
> -	if (di->chip == BQ27425 || di->chip == BQ27500 || di->chip == BQ27742
> -	    || di->chip == BQ27510)
> -		return true;
> -	return false;
> +	return di->bus.read(di, di->regs[reg_index], single);
>  }
>  
>  /*
> @@ -238,14 +440,7 @@ static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
>  {
>  	int soc;
>  
> -	if (di->chip == BQ27500 || di->chip == BQ27742)
> -		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
> -	else if (di->chip == BQ27510)
> -		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
> -	else if (di->chip == BQ27425)
> -		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
> -	else
> -		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
> +	soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
>  
>  	if (soc < 0)
>  		dev_dbg(di->dev, "error reading State-of-Charge\n");
> @@ -268,10 +463,10 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>  		return charge;
>  	}
>  
> -	if (bq27xxx_is_chip_version_higher(di))
> -		charge *= 1000;
> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> +		charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
>  	else
> -		charge = charge * 3570 / BQ27XXX_RS;
> +		charge *= 1000;
>  
>  	return charge;
>  }
> @@ -283,57 +478,46 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>  static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
>  {
>  	int flags;
> -	bool is_bq27500 = di->chip == BQ27500;
> -	bool is_bq27742 = di->chip == BQ27742;
> -	bool is_higher = bq27xxx_is_chip_version_higher(di);
> -	bool flags_1b = !(is_bq27500 || is_bq27742);
>  
> -	flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
> -	if (flags >= 0 && !is_higher && (flags & BQ27000_FLAG_CI))
> -		return -ENODATA;
> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> +		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
> +		if (flags >= 0 && (flags & BQ27000_FLAG_CI))
> +			return -ENODATA;
> +	}
>  
> -	return bq27xxx_battery_read_charge(di, BQ27x00_REG_NAC);
> +	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
>  }
>  
>  /*
> - * Return the battery Last measured discharge in µAh
> + * Return the battery Full Charge Capacity in µAh
>   * Or < 0 if something fails.
>   */
> -static inline int bq27xxx_battery_read_lmd(struct bq27xxx_device_info *di)
> +static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
>  {
> -	return bq27xxx_battery_read_charge(di, BQ27x00_REG_LMD);
> +	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
>  }
>  
>  /*
> - * Return the battery Initial last measured discharge in µAh
> + * Return the Design Capacity in µAh
>   * Or < 0 if something fails.
>   */
> -static int bq27xxx_battery_read_ilmd(struct bq27xxx_device_info *di)
> +static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
>  {
> -	int ilmd;
> +	int dcap;
>  
> -	if (bq27xxx_is_chip_version_higher(di)) {
> -		if (di->chip == BQ27425)
> -			ilmd = bq27xxx_read(di, BQ27425_REG_DCAP, false);
> -		else if (di->chip == BQ27510)
> -			ilmd = bq27xxx_read(di, BQ27510_REG_DCAP, false);
> -		else
> -			ilmd = bq27xxx_read(di, BQ27500_REG_DCAP, false);
> -	} else {
> -		ilmd = bq27xxx_read(di, BQ27000_REG_ILMD, true);
> -	}
> +	dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
>  
> -	if (ilmd < 0) {
> +	if (dcap < 0) {
>  		dev_dbg(di->dev, "error reading initial last measured discharge\n");
> -		return ilmd;
> +		return dcap;
>  	}
>  
> -	if (bq27xxx_is_chip_version_higher(di))
> -		ilmd *= 1000;
> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> +		dcap *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
>  	else
> -		ilmd = ilmd * 256 * 3570 / BQ27XXX_RS;
> +		dcap *= 1000;
>  
> -	return ilmd;
> +	return dcap;
>  }
>  
>  /*
> @@ -344,16 +528,16 @@ static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
>  {
>  	int ae;
>  
> -	ae = bq27xxx_read(di, BQ27x00_REG_AE, false);
> +	ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
>  	if (ae < 0) {
>  		dev_dbg(di->dev, "error reading available energy\n");
>  		return ae;
>  	}
>  
> -	if (di->chip == BQ27500)
> -		ae *= 1000;
> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> +		ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS;
>  	else
> -		ae = ae * 29200 / BQ27XXX_RS;
> +		ae *= 1000;
>  
>  	return ae;
>  }
> @@ -366,13 +550,13 @@ static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
>  {
>  	int temp;
>  
> -	temp = bq27xxx_read(di, BQ27x00_REG_TEMP, false);
> +	temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
>  	if (temp < 0) {
>  		dev_err(di->dev, "error reading temperature\n");
>  		return temp;
>  	}
>  
> -	if (!bq27xxx_is_chip_version_higher(di))
> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>  		temp = 5 * temp / 2;
>  
>  	return temp;
> @@ -386,10 +570,7 @@ static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
>  {
>  	int cyct;
>  
> -	if (di->chip == BQ27510)
> -		cyct = bq27xxx_read(di, BQ27510_REG_CYCT, false);
> -	else
> -		cyct = bq27xxx_read(di, BQ27x00_REG_CYCT, false);
> +	cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
>  	if (cyct < 0)
>  		dev_err(di->dev, "error reading cycle count total\n");
>  
> @@ -421,21 +602,32 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
>   * Read an average power register.
>   * Return < 0 if something fails.
>   */
> -static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
> +static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
>  {
>  	int tval;
>  
> -	tval = bq27xxx_read(di, reg, false);
> +	tval = bq27xxx_read(di, BQ27XXX_REG_AP, false);
>  	if (tval < 0) {
> -		dev_err(di->dev, "error reading power avg rgister  %02x: %d\n",
> -			reg, tval);
> +		dev_err(di->dev, "error reading average power register  %02x: %d\n",
> +			BQ27XXX_REG_AP, tval);
>  		return tval;
>  	}
>  
> -	if (di->chip == BQ27500)
> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> +		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
> +	else
>  		return tval;
> +}
> +
> +/*
> + * Returns true if a battery over temperature condition is detected
> + */
> +static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
> +{
> +	if (di->chip == BQ27500 || di->chip == BQ27541)
> +		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
>  	else
> -		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
> +		return flags & BQ27XXX_FLAG_OTC;
>  }
>  
>  /*
> @@ -444,53 +636,43 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
>   */
>  static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
>  {
> -	int tval;
> +	u16 tval;
>  
> -	tval = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
> +	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
>  	if (tval < 0) {
>  		dev_err(di->dev, "error reading flag register:%d\n", tval);
>  		return tval;
>  	}
>  
> -	if (di->chip == BQ27500) {
> -		if (tval & BQ27500_FLAG_SOCF)
> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> +		if (tval & BQ27000_FLAG_EDV1)
>  			tval = POWER_SUPPLY_HEALTH_DEAD;
> -		else if (tval & BQ27500_FLAG_OTC)
> -			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
>  		else
>  			tval = POWER_SUPPLY_HEALTH_GOOD;
> -		return tval;
> -	} else if (di->chip == BQ27510) {
> -		if (tval & BQ27500_FLAG_OTC)
> -			return POWER_SUPPLY_HEALTH_OVERHEAT;
> -		return POWER_SUPPLY_HEALTH_GOOD;
>  	} else {
> -		if (tval & BQ27000_FLAG_EDV1)
> +		if (tval & BQ27XXX_FLAG_SOCF)
>  			tval = POWER_SUPPLY_HEALTH_DEAD;
> +		else if (bq27xxx_battery_overtemp(di, tval))
> +			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
>  		else
>  			tval = POWER_SUPPLY_HEALTH_GOOD;
> -		return tval;
>  	}
>  
> -	return -1;
> +	return tval;
>  }
>  
>  static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>  {
>  	struct bq27xxx_reg_cache cache = {0, };
> -	bool is_bq27500 = di->chip == BQ27500;
> -	bool is_bq27510 = di->chip == BQ27510;
> -	bool is_bq27425 = di->chip == BQ27425;
> -	bool is_bq27742 = di->chip == BQ27742;
> -	bool flags_1b = !(is_bq27500 || is_bq27742);
> +	bool has_ci_flag = di->chip == BQ27000 || di->chip == BQ27010;
> +	bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010;
>  
> -	cache.flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
> +	cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
>  	if ((cache.flags & 0xff) == 0xff)
> -		/* read error */
> -		cache.flags = -1;
> +		cache.flags = -1; /* read error */
>  	if (cache.flags >= 0) {
> -		if (!is_bq27500 && !is_bq27425 && !is_bq27742 && !is_bq27510
> -				&& (cache.flags & BQ27000_FLAG_CI)) {
> +		cache.temperature = bq27xxx_battery_read_temperature(di);
> +		if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) {
>  			dev_info(di->dev, "battery is not calibrated! ignoring capacity values\n");
>  			cache.capacity = -ENODATA;
>  			cache.energy = -ENODATA;
> @@ -500,41 +682,25 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>  			cache.charge_full = -ENODATA;
>  			cache.health = -ENODATA;
>  		} else {
> +			if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
> +				cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
> +			if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
> +				cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
> +			if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
> +				cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
> +			cache.charge_full = bq27xxx_battery_read_fcc(di);
>  			cache.capacity = bq27xxx_battery_read_soc(di);
> -			if (is_bq27742 || is_bq27510)
> -				cache.time_to_empty =
> -					bq27xxx_battery_read_time(di,
> -							BQ27x00_REG_TTE);
> -			else if (!is_bq27425) {
> +			if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
>  				cache.energy = bq27xxx_battery_read_energy(di);
> -				cache.time_to_empty =
> -					bq27xxx_battery_read_time(di,
> -							BQ27x00_REG_TTE);
> -				cache.time_to_empty_avg =
> -					bq27xxx_battery_read_time(di,
> -							BQ27x00_REG_TTECP);
> -				cache.time_to_full =
> -					bq27xxx_battery_read_time(di,
> -							BQ27x00_REG_TTF);
> -			}
> -			cache.charge_full = bq27xxx_battery_read_lmd(di);
>  			cache.health = bq27xxx_battery_read_health(di);
>  		}
> -		cache.temperature = bq27xxx_battery_read_temperature(di);
> -		if (!is_bq27425)
> +		if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
>  			cache.cycle_count = bq27xxx_battery_read_cyct(di);
> -		if (is_bq27742)
> -			cache.power_avg =
> -				bq27xxx_battery_read_pwr_avg(di,
> -						BQ27742_POWER_AVG);
> -		else
> -			cache.power_avg =
> -				bq27xxx_battery_read_pwr_avg(di,
> -						BQ27x00_POWER_AVG);
> +		cache.power_avg = bq27xxx_battery_read_pwr_avg(di);
>  
>  		/* We only have to read charge design full once */
>  		if (di->charge_design_full <= 0)
> -			di->charge_design_full = bq27xxx_battery_read_ilmd(di);
> +			di->charge_design_full = bq27xxx_battery_read_dcap(di);
>  	}
>  
>  	if (di->cache.capacity != cache.capacity)
> @@ -549,7 +715,8 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>  static void bq27xxx_battery_poll(struct work_struct *work)
>  {
>  	struct bq27xxx_device_info *di =
> -		container_of(work, struct bq27xxx_device_info, work.work);
> +			container_of(work, struct bq27xxx_device_info,
> +				     work.work);
>  
>  	bq27xxx_battery_update(di);
>  
> @@ -571,23 +738,23 @@ static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
>  	int curr;
>  	int flags;
>  
> -	curr = bq27xxx_read(di, BQ27x00_REG_AI, false);
> +	curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
>  	if (curr < 0) {
>  		dev_err(di->dev, "error reading current\n");
>  		return curr;
>  	}
>  
> -	if (bq27xxx_is_chip_version_higher(di)) {
> -		/* bq27500 returns signed value */
> -		val->intval = (int)((s16)curr) * 1000;
> -	} else {
> -		flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> +		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
>  		if (flags & BQ27000_FLAG_CHGS) {
>  			dev_dbg(di->dev, "negative current!\n");
>  			curr = -curr;
>  		}
>  
> -		val->intval = curr * 3570 / BQ27XXX_RS;
> +		val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
> +	} else {
> +		/* Other gauges return signed value */
> +		val->intval = (int)((s16)curr) * 1000;
>  	}
>  
>  	return 0;
> @@ -598,14 +765,7 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
>  {
>  	int status;
>  
> -	if (bq27xxx_is_chip_version_higher(di)) {
> -		if (di->cache.flags & BQ27500_FLAG_FC)
> -			status = POWER_SUPPLY_STATUS_FULL;
> -		else if (di->cache.flags & BQ27500_FLAG_DSC)
> -			status = POWER_SUPPLY_STATUS_DISCHARGING;
> -		else
> -			status = POWER_SUPPLY_STATUS_CHARGING;
> -	} else {
> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
>  		if (di->cache.flags & BQ27000_FLAG_FC)
>  			status = POWER_SUPPLY_STATUS_FULL;
>  		else if (di->cache.flags & BQ27000_FLAG_CHGS)
> @@ -614,6 +774,13 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
>  			status = POWER_SUPPLY_STATUS_NOT_CHARGING;
>  		else
>  			status = POWER_SUPPLY_STATUS_DISCHARGING;
> +	} else {
> +		if (di->cache.flags & BQ27XXX_FLAG_FC)
> +			status = POWER_SUPPLY_STATUS_FULL;
> +		else if (di->cache.flags & BQ27XXX_FLAG_DSC)
> +			status = POWER_SUPPLY_STATUS_DISCHARGING;
> +		else
> +			status = POWER_SUPPLY_STATUS_CHARGING;
>  	}
>  
>  	val->intval = status;
> @@ -626,21 +793,21 @@ static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
>  {
>  	int level;
>  
> -	if (bq27xxx_is_chip_version_higher(di)) {
> -		if (di->cache.flags & BQ27500_FLAG_FC)
> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> +		if (di->cache.flags & BQ27000_FLAG_FC)
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
> -		else if (di->cache.flags & BQ27500_FLAG_SOC1)
> +		else if (di->cache.flags & BQ27000_FLAG_EDV1)
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
> -		else if (di->cache.flags & BQ27500_FLAG_SOCF)
> +		else if (di->cache.flags & BQ27000_FLAG_EDVF)
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
>  		else
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
>  	} else {
> -		if (di->cache.flags & BQ27000_FLAG_FC)
> +		if (di->cache.flags & BQ27XXX_FLAG_FC)
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
> -		else if (di->cache.flags & BQ27000_FLAG_EDV1)
> +		else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
> -		else if (di->cache.flags & BQ27000_FLAG_EDVF)
> +		else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
>  		else
>  			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
> @@ -660,7 +827,7 @@ static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
>  {
>  	int volt;
>  
> -	volt = bq27xxx_read(di, BQ27x00_REG_VOLT, false);
> +	volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
>  	if (volt < 0) {
>  		dev_err(di->dev, "error reading voltage\n");
>  		return volt;
> @@ -721,7 +888,7 @@ static int bq27xxx_battery_get_property(struct power_supply *psy,
>  	case POWER_SUPPLY_PROP_TEMP:
>  		ret = bq27xxx_simple_value(di->cache.temperature, val);
>  		if (ret == 0)
> -			val->intval -= 2731;
> +			val->intval -= 2731; /* convert decidegree k to c */
>  		break;
>  	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
>  		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
> @@ -787,18 +954,27 @@ static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
>  
>  	psy_desc->name = name;
>  	psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
> -	if (di->chip == BQ27425) {
> -		psy_desc->properties = bq27425_battery_props;
> -		psy_desc->num_properties = ARRAY_SIZE(bq27425_battery_props);
> -	} else if (di->chip == BQ27742) {
> -		psy_desc->properties = bq27742_battery_props;
> -		psy_desc->num_properties = ARRAY_SIZE(bq27742_battery_props);
> -	} else if (di->chip == BQ27510) {
> -		psy_desc->properties = bq27510_battery_props;
> -		psy_desc->num_properties = ARRAY_SIZE(bq27510_battery_props);
> +	if (di->chip == BQ27000) {
> +		psy_desc->properties = bq27000_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27000_battery_props);
> +	} else if (di->chip == BQ27010) {
> +		psy_desc->properties = bq27010_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27010_battery_props);
> +	} else if (di->chip == BQ27500) {
> +		psy_desc->properties = bq27500_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27500_battery_props);
> +	} else if (di->chip == BQ27530) {
> +		psy_desc->properties = bq27530_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27530_battery_props);
> +	} else if (di->chip == BQ27541) {
> +		psy_desc->properties = bq27541_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27541_battery_props);
> +	} else if (di->chip == BQ27545) {
> +		psy_desc->properties = bq27545_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27545_battery_props);
>  	} else {
> -		psy_desc->properties = bq27x00_battery_props;
> -		psy_desc->num_properties = ARRAY_SIZE(bq27x00_battery_props);
> +		psy_desc->properties = bq27421_battery_props;
> +		psy_desc->num_properties = ARRAY_SIZE(bq27421_battery_props);
>  	}
>  	psy_desc->get_property = bq27xxx_battery_get_property;
>  	psy_desc->external_power_changed = bq27xxx_external_power_changed;
> @@ -913,10 +1089,32 @@ static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
>  	di->chip = id->driver_data;
>  	di->bus.read = &bq27xxx_battery_i2c_read;
>  
> +	if (di->chip == BQ27000) {
> +		di->regs = bq27000_regs;
> +	} else if (di->chip == BQ27010) {
> +		di->regs = bq27010_regs;
> +	} else if (di->chip == BQ27500) {
> +		di->regs = bq27500_regs;
> +	} else if (di->chip == BQ27530) {
> +		di->regs = bq27530_regs;
> +	} else if (di->chip == BQ27541) {
> +		di->regs = bq27541_regs;
> +	} else if (di->chip == BQ27545) {
> +		di->regs = bq27545_regs;
> +	} else if (di->chip == BQ27421) {
> +		di->regs = bq27421_regs;
> +	} else {
> +		dev_err(&client->dev, "Unexpected gas gauge: %d\n", di->chip);
> +		di->regs = bq27000_regs;
> +	}
> +
>  	retval = bq27xxx_powersupply_init(di, name);
>  	if (retval)
>  		goto batt_failed;
>  
> +	/* Schedule a polling after about 1 min */
> +	schedule_delayed_work(&di->work, 60 * HZ);
> +
>  	i2c_set_clientdata(client, di);
>  
>  	return 0;
> @@ -943,11 +1141,13 @@ static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
>  }
>  
>  static const struct i2c_device_id bq27xxx_id[] = {
> -	{ "bq27200", BQ27000 },	/* bq27200 is same as bq27000, but with i2c */
> +	{ "bq27000", BQ27000 },

I2C version is bq27200, HDQ is bq27000. So here in struct i2c_device_id
is needed bq27200.

Also existing kernel code depends on it (git grep bq27200).

> +	{ "bq27010", BQ27010 },
>  	{ "bq27500", BQ27500 },
> -	{ "bq27425", BQ27425 },
> -	{ "bq27742", BQ27742 },
> -	{ "bq27510", BQ27510 },
> +	{ "bq27530", BQ27530 },
> +	{ "bq27541", BQ27541 },
> +	{ "bq27545", BQ27545 },
> +	{ "bq27421", BQ27421 },

Why you removed support for bq27425, bq27742 and bq27510?

>  	{},
>  };
>  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 7/8] power: bq27xxx_battery: Add support for additional bq27xxx family devices

[Andrew F. Davis]

Pali,
On 07/23/2015 11:20 AM, Pali Rohár wrote:
> On Wednesday 22 July 2015 16:51:59 Andrew F. Davis wrote:
>> Add support for additional devices and register equivalent family devices
>> including the bq27010, bq27210, bq272500, bq27510, bq27520, bq27530,
>> bq27531, bq27541, bq27542, bq27546, bq27545, bq27441, bq27421, and the
>> bq27641.
>>
>> To facilitate this process the register mapings have been moved to tables
>> and other small cleanups have been made.
>>
>> Signed-off-by: Andrew F. Davis <afd@ti.com>
>> ---
>>  drivers/power/bq27xxx_battery.c | 618 ++++++++++++++++++++++++++--------------
>>  1 file changed, 409 insertions(+), 209 deletions(-)
>>
>> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
>> index 5686da6..f148222 100644
>> --- a/drivers/power/bq27xxx_battery.c
>> +++ b/drivers/power/bq27xxx_battery.c
>> @@ -17,11 +17,15 @@
>>   * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
>>   *
>>   * Datasheets:
>> - * http://focus.ti.com/docs/prod/folders/print/bq27000.html
>> - * http://focus.ti.com/docs/prod/folders/print/bq27500.html
>> + * http://www.ti.com/product/bq27000
>> + * http://www.ti.com/product/bq27010
>> + * http://www.ti.com/product/bq27510-g3
>> + * http://www.ti.com/product/bq27520-g4
>> + * http://www.ti.com/product/bq27411-g1
>> + * http://www.ti.com/product/bq27421-g1
>>   * http://www.ti.com/product/bq27425-g1
>> - * http://www.ti.com/product/BQ27742-G1
>> - * http://www.ti.com/product/BQ27510-G3
>> + * http://www.ti.com/product/bq27742-g1
>> + * http://www.ti.com/product/bq27621-g1
>>   */
> 
> Now, when you touching list of links to documentation, you can add also
> one for bq27200: http://www.ti.com/product/bq27200
> 

OK, good idea.

>>  
>>  #include <linux/device.h>
>> @@ -43,55 +47,66 @@
>>  
>>  #define BQ27XXX_MANUFACTURER	"Texas Instruments"
>>  
>> -#define BQ27x00_REG_TEMP	0x06
>> -#define BQ27x00_REG_VOLT	0x08
>> -#define BQ27x00_REG_AI		0x14
>> -#define BQ27x00_REG_FLAGS	0x0A
>> -#define BQ27x00_REG_TTE		0x16
>> -#define BQ27x00_REG_TTF		0x18
>> -#define BQ27x00_REG_TTECP	0x26
>> -#define BQ27x00_REG_NAC		0x0C /* Nominal available capacity */
>> -#define BQ27x00_REG_LMD		0x12 /* Last measured discharge */
>> -#define BQ27x00_REG_CYCT	0x2A /* Cycle count total */
>> -#define BQ27x00_REG_AE		0x22 /* Available energy */
>> -#define BQ27x00_POWER_AVG	0x24
>> -
>> -#define BQ27000_REG_RSOC	0x0B /* Relative State-of-Charge */
>> -#define BQ27000_REG_ILMD	0x76 /* Initial last measured discharge */
>> +/* BQ27XXX Flags */
>> +#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_FC		BIT(9)
>> +#define BQ27XXX_FLAG_OTD	BIT(14)
>> +#define BQ27XXX_FLAG_OTC	BIT(15)
>> +
>> +/* BQ27000 has different layout for Flags register */
>>  #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
>>  #define BQ27000_FLAG_EDV1	BIT(1) /* First End-of-Discharge-Voltage flag */
>>  #define BQ27000_FLAG_CI		BIT(4) /* Capacity Inaccurate flag */
>>  #define BQ27000_FLAG_FC		BIT(5)
>>  #define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
>>  
>> -#define BQ27500_REG_SOC		0x2C
>> -#define BQ27500_REG_DCAP	0x3C /* Design capacity */
>> -#define BQ27500_FLAG_DSC	BIT(0)
>> -#define BQ27500_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
>> -#define BQ27500_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
>> -#define BQ27500_FLAG_FC		BIT(9)
>> -#define BQ27500_FLAG_OTC	BIT(15)
>> -
>> -#define BQ27742_POWER_AVG	0x76
>> -
>> -#define BQ27510_REG_SOC		0x20
>> -#define BQ27510_REG_DCAP	0x2E /* Design capacity */
>> -#define BQ27510_REG_CYCT	0x1E /* Cycle count total */
>> -
>> -/* bq27425 register addresses are same as bq27x00 addresses minus 4 */
>> -#define BQ27425_REG_OFFSET	0x04
>> -#define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
>> -#define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
>> -
>> -#define BQ27XXX_RS			20 /* Resistor sense */
>> -#define BQ27XXX_POWER_CONSTANT		(256 * 29200 / 1000)
>> +#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 */
>>  
>>  struct bq27xxx_device_info;
>>  struct bq27xxx_access_methods {
>>  	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
>>  };
>>  
>> -enum bq27xxx_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
>> +#define INVALID_REG_ADDR	0xff
>> +
>> +enum bq27xxx_chip {
>> +	BQ27000, /* bq27000, bq27200 */
>> +	BQ27010, /* bq27010, bq27210 */
>> +	BQ27500, /* bq27500, bq27510, bq27520 */
>> +	BQ27530, /* bq27530, bq27531 */
>> +	BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
>> +	BQ27545, /* bq27545 */
>> +	BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
>> +};
>> +
>> +/*
>> + * bq27xxx_reg_index - Register names
>> + *
>> + * These are indexes into a device's register mapping array.
>> + */
>> +enum bq27xxx_reg_index {
>> +	BQ27XXX_REG_CTRL = 0,	/* Control */
>> +	BQ27XXX_REG_TEMP,	/* Temperature */
>> +	BQ27XXX_REG_INT_TEMP,	/* Internal Temperature */
>> +	BQ27XXX_REG_VOLT,	/* Voltage */
>> +	BQ27XXX_REG_AI,		/* Average Current */
>> +	BQ27XXX_REG_FLAGS,	/* Flags */
>> +	BQ27XXX_REG_TTE,	/* Time-to-Empty */
>> +	BQ27XXX_REG_TTF,	/* Time-to-Full */
>> +	BQ27XXX_REG_TTES,	/* Time-to-Empty Standby */
>> +	BQ27XXX_REG_TTECP,	/* Time-to-Empty at Constant Power */
>> +	BQ27XXX_REG_NAC,	/* Nominal Available Capacity */
>> +	BQ27XXX_REG_FCC,	/* Full Charge Capacity */
>> +	BQ27XXX_REG_CYCT,	/* Cycle Count */
>> +	BQ27XXX_REG_AE,		/* Available Energy */
>> +	BQ27XXX_REG_SOC,	/* State-of-Charge */
>> +	BQ27XXX_REG_DCAP,	/* Design Capacity */
>> +	BQ27XXX_REG_AP,		/* Average Power */
>> +};
>>  
>>  struct bq27xxx_reg_cache {
>>  	int temperature;
>> @@ -123,9 +138,152 @@ struct bq27xxx_device_info {
>>  	struct bq27xxx_access_methods bus;
>>  
>>  	struct mutex lock;
>> +
>> +	u8 *regs;
>>  };
>>  
>> -static enum power_supply_property bq27x00_battery_props[] = {
>> +/* Register mappings */
>> +static u8 bq27000_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x06,	/* TEMP		*/
>> +	0xff,	/* INT TEMP - NA*/
>> +	0x08,	/* VOLT		*/
>> +	0x14,	/* AVG CURR	*/
>> +	0x0a,	/* FLAGS	*/
>> +	0x16,	/* TTE		*/
>> +	0x18,	/* TTF		*/
>> +	0x1c,	/* TTES		*/
>> +	0x26,	/* TTECP	*/
>> +	0x0c,	/* NAC		*/
>> +	0x12,	/* LMD(FCC)	*/
>> +	0x2a,	/* CYCT		*/
>> +	0x22,	/* AE		*/
>> +	0x0b,	/* SOC(RSOC)	*/
>> +	0x76,	/* DCAP(ILMD)	*/
>> +	0x24,	/* AP		*/
>> +};
>> +
>> +static u8 bq27010_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x06,	/* TEMP		*/
>> +	0xff,	/* INT TEMP - NA*/
>> +	0x08,	/* VOLT		*/
>> +	0x14,	/* AVG CURR	*/
>> +	0x0a,	/* FLAGS	*/
>> +	0x16,	/* TTE		*/
>> +	0x18,	/* TTF		*/
>> +	0x1c,	/* TTES		*/
>> +	0x26,	/* TTECP	*/
>> +	0x0c,	/* NAC		*/
>> +	0x12,	/* LMD(FCC)	*/
>> +	0x2a,	/* CYCT		*/
>> +	0xff,	/* AE - NA	*/
>> +	0x0b,	/* SOC(RSOC)	*/
>> +	0x76,	/* DCAP(ILMD)	*/
>> +	0xff,	/* AP - NA	*/
>> +};
>> +
>> +static u8 bq27500_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x06,	/* TEMP		*/
>> +	0x28,	/* INT TEMP	*/
>> +	0x08,	/* VOLT		*/
>> +	0x14,	/* AVG CURR	*/
>> +	0x0a,	/* FLAGS	*/
>> +	0x16,	/* TTE		*/
>> +	0xff,	/* TTF - NA	*/
>> +	0x1a,	/* TTES		*/
>> +	0xff,	/* TTECP - NA	*/
>> +	0x0c,	/* NAC		*/
>> +	0x12,	/* LMD(FCC)	*/
>> +	0x1e,	/* CYCT		*/
>> +	0xff,	/* AE - NA	*/
>> +	0x20,	/* SOC(RSOC)	*/
>> +	0x2e,	/* DCAP(ILMD)	*/
>> +	0xff,	/* AP - NA	*/
>> +};
>> +
>> +static u8 bq27530_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x06,	/* TEMP		*/
>> +	0x32,	/* INT TEMP	*/
>> +	0x08,	/* VOLT		*/
>> +	0x14,	/* AVG CURR	*/
>> +	0x0a,	/* FLAGS	*/
>> +	0x16,	/* TTE		*/
>> +	0xff,	/* TTF - NA	*/
>> +	0xff,	/* TTES - NA	*/
>> +	0xff,	/* TTECP - NA	*/
>> +	0x0c,	/* NAC		*/
>> +	0x12,	/* LMD(FCC)	*/
>> +	0x2a,	/* CYCT		*/
>> +	0xff,	/* AE - NA	*/
>> +	0x2c,	/* SOC(RSOC)	*/
>> +	0xff,	/* DCAP - NA	*/
>> +	0x24,	/* AP		*/
>> +};
>> +
>> +static u8 bq27541_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x06,	/* TEMP		*/
>> +	0x28,	/* INT TEMP	*/
>> +	0x08,	/* VOLT		*/
>> +	0x14,	/* AVG CURR	*/
>> +	0x0a,	/* FLAGS	*/
>> +	0x16,	/* TTE		*/
>> +	0xff,	/* TTF - NA	*/
>> +	0xff,	/* TTES - NA	*/
>> +	0xff,	/* TTECP - NA	*/
>> +	0x0c,	/* NAC		*/
>> +	0x12,	/* LMD(FCC)	*/
>> +	0x2a,	/* CYCT		*/
>> +	0xff,	/* AE - NA	*/
>> +	0x2c,	/* SOC(RSOC)	*/
>> +	0x3c,	/* DCAP		*/
>> +	0x76,	/* AP		*/
>> +};
>> +
>> +static u8 bq27545_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x06,	/* TEMP		*/
>> +	0x28,	/* INT TEMP	*/
>> +	0x08,	/* VOLT		*/
>> +	0x14,	/* AVG CURR	*/
>> +	0x0a,	/* FLAGS	*/
>> +	0x16,	/* TTE		*/
>> +	0xff,	/* TTF - NA	*/
>> +	0xff,	/* TTES - NA	*/
>> +	0xff,	/* TTECP - NA	*/
>> +	0x0c,	/* NAC		*/
>> +	0x12,	/* LMD(FCC)	*/
>> +	0x2a,	/* CYCT		*/
>> +	0xff,	/* AE - NA	*/
>> +	0x2c,	/* SOC(RSOC)	*/
>> +	0xff,	/* DCAP - NA */
>> +	0x24,	/* AP		*/
>> +};
>> +
>> +static u8 bq27421_regs[] = {
>> +	0x00,	/* CONTROL	*/
>> +	0x02,	/* TEMP		*/
>> +	0x1e,	/* INT TEMP	*/
>> +	0x04,	/* VOLT		*/
>> +	0x10,	/* AVG CURR	*/
>> +	0x06,	/* FLAGS	*/
>> +	0xff,	/* TTE - NA	*/
>> +	0xff,	/* TTF - NA	*/
>> +	0xff,	/* TTES - NA	*/
>> +	0xff,	/* TTECP - NA	*/
>> +	0x08,	/* NAC		*/
>> +	0x0e,	/* FCC		*/
>> +	0xff,	/* CYCT - NA	*/
>> +	0xff,	/* AE - NA	*/
>> +	0x1c,	/* SOC		*/
>> +	0x3c,	/* DCAP		*/
>> +	0x18,	/* AP		*/
>> +};
>> +
>> +static enum power_supply_property bq27000_battery_props[] = {
>>  	POWER_SUPPLY_PROP_STATUS,
>>  	POWER_SUPPLY_PROP_PRESENT,
>>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> @@ -147,7 +305,7 @@ static enum power_supply_property bq27x00_battery_props[] = {
>>  	POWER_SUPPLY_PROP_MANUFACTURER,
>>  };
>>  
>> -static enum power_supply_property bq27425_battery_props[] = {
>> +static enum power_supply_property bq27010_battery_props[] = {
>>  	POWER_SUPPLY_PROP_STATUS,
>>  	POWER_SUPPLY_PROP_PRESENT,
>>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> @@ -155,14 +313,19 @@ static enum power_supply_property bq27425_battery_props[] = {
>>  	POWER_SUPPLY_PROP_CAPACITY,
>>  	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
>>  	POWER_SUPPLY_PROP_TEMP,
>> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
>> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
>> +	POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
>>  	POWER_SUPPLY_PROP_TECHNOLOGY,
>>  	POWER_SUPPLY_PROP_CHARGE_FULL,
>>  	POWER_SUPPLY_PROP_CHARGE_NOW,
>>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
>> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
>> +	POWER_SUPPLY_PROP_HEALTH,
>>  	POWER_SUPPLY_PROP_MANUFACTURER,
>>  };
>>  
>> -static enum power_supply_property bq27742_battery_props[] = {
>> +static enum power_supply_property bq27500_battery_props[] = {
>>  	POWER_SUPPLY_PROP_STATUS,
>>  	POWER_SUPPLY_PROP_PRESENT,
>>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> @@ -176,12 +339,29 @@ static enum power_supply_property bq27742_battery_props[] = {
>>  	POWER_SUPPLY_PROP_CHARGE_NOW,
>>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
>>  	POWER_SUPPLY_PROP_CYCLE_COUNT,
>> +	POWER_SUPPLY_PROP_HEALTH,
>> +	POWER_SUPPLY_PROP_MANUFACTURER,
>> +};
>> +
>> +static enum power_supply_property bq27530_battery_props[] = {
>> +	POWER_SUPPLY_PROP_STATUS,
>> +	POWER_SUPPLY_PROP_PRESENT,
>> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> +	POWER_SUPPLY_PROP_CURRENT_NOW,
>> +	POWER_SUPPLY_PROP_CAPACITY,
>> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
>> +	POWER_SUPPLY_PROP_TEMP,
>> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
>> +	POWER_SUPPLY_PROP_TECHNOLOGY,
>> +	POWER_SUPPLY_PROP_CHARGE_FULL,
>> +	POWER_SUPPLY_PROP_CHARGE_NOW,
>>  	POWER_SUPPLY_PROP_POWER_AVG,
>>  	POWER_SUPPLY_PROP_HEALTH,
>> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
>>  	POWER_SUPPLY_PROP_MANUFACTURER,
>>  };
>>  
>> -static enum power_supply_property bq27510_battery_props[] = {
>> +static enum power_supply_property bq27541_battery_props[] = {
>>  	POWER_SUPPLY_PROP_STATUS,
>>  	POWER_SUPPLY_PROP_PRESENT,
>>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> @@ -200,6 +380,39 @@ static enum power_supply_property bq27510_battery_props[] = {
>>  	POWER_SUPPLY_PROP_MANUFACTURER,
>>  };
>>  
>> +static enum power_supply_property bq27545_battery_props[] = {
>> +	POWER_SUPPLY_PROP_STATUS,
>> +	POWER_SUPPLY_PROP_PRESENT,
>> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> +	POWER_SUPPLY_PROP_CURRENT_NOW,
>> +	POWER_SUPPLY_PROP_CAPACITY,
>> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
>> +	POWER_SUPPLY_PROP_TEMP,
>> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
>> +	POWER_SUPPLY_PROP_TECHNOLOGY,
>> +	POWER_SUPPLY_PROP_CHARGE_FULL,
>> +	POWER_SUPPLY_PROP_CHARGE_NOW,
>> +	POWER_SUPPLY_PROP_HEALTH,
>> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
>> +	POWER_SUPPLY_PROP_POWER_AVG,
>> +	POWER_SUPPLY_PROP_MANUFACTURER,
>> +};
>> +
>> +static enum power_supply_property bq27421_battery_props[] = {
>> +	POWER_SUPPLY_PROP_STATUS,
>> +	POWER_SUPPLY_PROP_PRESENT,
>> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
>> +	POWER_SUPPLY_PROP_CURRENT_NOW,
>> +	POWER_SUPPLY_PROP_CAPACITY,
>> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
>> +	POWER_SUPPLY_PROP_TEMP,
>> +	POWER_SUPPLY_PROP_TECHNOLOGY,
>> +	POWER_SUPPLY_PROP_CHARGE_FULL,
>> +	POWER_SUPPLY_PROP_CHARGE_NOW,
>> +	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
>> +	POWER_SUPPLY_PROP_MANUFACTURER,
>> +};
>> +
>>  static unsigned int poll_interval = 360;
>>  module_param(poll_interval, uint, 0644);
>>  MODULE_PARM_DESC(poll_interval,
>> @@ -209,25 +422,14 @@ MODULE_PARM_DESC(poll_interval,
>>   * Common code for BQ27xxx devices
>>   */
>>  
>> -static inline int bq27xxx_read(struct bq27xxx_device_info *di, u8 reg,
>> +static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
>>  			       bool single)
>>  {
>> -	if (di->chip == BQ27425)
>> -		return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
>> -	return di->bus.read(di, reg, single);
>> -}
>> +	/* Reports EINVAL for invalid/missing registers */
>> +	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
>> +		return -EINVAL;
>>  
>> -/*
>> - * Higher versions of the chip like BQ27425 and BQ27500
>> - * differ from BQ27000 and BQ27200 in calculation of certain
>> - * parameters. Hence we need to check for the chip type.
>> - */
>> -static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
>> -{
>> -	if (di->chip == BQ27425 || di->chip == BQ27500 || di->chip == BQ27742
>> -	    || di->chip == BQ27510)
>> -		return true;
>> -	return false;
>> +	return di->bus.read(di, di->regs[reg_index], single);
>>  }
>>  
>>  /*
>> @@ -238,14 +440,7 @@ static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
>>  {
>>  	int soc;
>>  
>> -	if (di->chip == BQ27500 || di->chip == BQ27742)
>> -		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
>> -	else if (di->chip == BQ27510)
>> -		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
>> -	else if (di->chip == BQ27425)
>> -		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
>> -	else
>> -		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
>> +	soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
>>  
>>  	if (soc < 0)
>>  		dev_dbg(di->dev, "error reading State-of-Charge\n");
>> @@ -268,10 +463,10 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>>  		return charge;
>>  	}
>>  
>> -	if (bq27xxx_is_chip_version_higher(di))
>> -		charge *= 1000;
>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>> +		charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
>>  	else
>> -		charge = charge * 3570 / BQ27XXX_RS;
>> +		charge *= 1000;
>>  
>>  	return charge;
>>  }
>> @@ -283,57 +478,46 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
>>  static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
>>  {
>>  	int flags;
>> -	bool is_bq27500 = di->chip == BQ27500;
>> -	bool is_bq27742 = di->chip == BQ27742;
>> -	bool is_higher = bq27xxx_is_chip_version_higher(di);
>> -	bool flags_1b = !(is_bq27500 || is_bq27742);
>>  
>> -	flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
>> -	if (flags >= 0 && !is_higher && (flags & BQ27000_FLAG_CI))
>> -		return -ENODATA;
>> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
>> +		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
>> +		if (flags >= 0 && (flags & BQ27000_FLAG_CI))
>> +			return -ENODATA;
>> +	}
>>  
>> -	return bq27xxx_battery_read_charge(di, BQ27x00_REG_NAC);
>> +	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
>>  }
>>  
>>  /*
>> - * Return the battery Last measured discharge in µAh
>> + * Return the battery Full Charge Capacity in µAh
>>   * Or < 0 if something fails.
>>   */
>> -static inline int bq27xxx_battery_read_lmd(struct bq27xxx_device_info *di)
>> +static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
>>  {
>> -	return bq27xxx_battery_read_charge(di, BQ27x00_REG_LMD);
>> +	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
>>  }
>>  
>>  /*
>> - * Return the battery Initial last measured discharge in µAh
>> + * Return the Design Capacity in µAh
>>   * Or < 0 if something fails.
>>   */
>> -static int bq27xxx_battery_read_ilmd(struct bq27xxx_device_info *di)
>> +static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
>>  {
>> -	int ilmd;
>> +	int dcap;
>>  
>> -	if (bq27xxx_is_chip_version_higher(di)) {
>> -		if (di->chip == BQ27425)
>> -			ilmd = bq27xxx_read(di, BQ27425_REG_DCAP, false);
>> -		else if (di->chip == BQ27510)
>> -			ilmd = bq27xxx_read(di, BQ27510_REG_DCAP, false);
>> -		else
>> -			ilmd = bq27xxx_read(di, BQ27500_REG_DCAP, false);
>> -	} else {
>> -		ilmd = bq27xxx_read(di, BQ27000_REG_ILMD, true);
>> -	}
>> +	dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
>>  
>> -	if (ilmd < 0) {
>> +	if (dcap < 0) {
>>  		dev_dbg(di->dev, "error reading initial last measured discharge\n");
>> -		return ilmd;
>> +		return dcap;
>>  	}
>>  
>> -	if (bq27xxx_is_chip_version_higher(di))
>> -		ilmd *= 1000;
>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>> +		dcap *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
>>  	else
>> -		ilmd = ilmd * 256 * 3570 / BQ27XXX_RS;
>> +		dcap *= 1000;
>>  
>> -	return ilmd;
>> +	return dcap;
>>  }
>>  
>>  /*
>> @@ -344,16 +528,16 @@ static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
>>  {
>>  	int ae;
>>  
>> -	ae = bq27xxx_read(di, BQ27x00_REG_AE, false);
>> +	ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
>>  	if (ae < 0) {
>>  		dev_dbg(di->dev, "error reading available energy\n");
>>  		return ae;
>>  	}
>>  
>> -	if (di->chip == BQ27500)
>> -		ae *= 1000;
>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>> +		ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS;
>>  	else
>> -		ae = ae * 29200 / BQ27XXX_RS;
>> +		ae *= 1000;
>>  
>>  	return ae;
>>  }
>> @@ -366,13 +550,13 @@ static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
>>  {
>>  	int temp;
>>  
>> -	temp = bq27xxx_read(di, BQ27x00_REG_TEMP, false);
>> +	temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
>>  	if (temp < 0) {
>>  		dev_err(di->dev, "error reading temperature\n");
>>  		return temp;
>>  	}
>>  
>> -	if (!bq27xxx_is_chip_version_higher(di))
>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>>  		temp = 5 * temp / 2;
>>  
>>  	return temp;
>> @@ -386,10 +570,7 @@ static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
>>  {
>>  	int cyct;
>>  
>> -	if (di->chip == BQ27510)
>> -		cyct = bq27xxx_read(di, BQ27510_REG_CYCT, false);
>> -	else
>> -		cyct = bq27xxx_read(di, BQ27x00_REG_CYCT, false);
>> +	cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
>>  	if (cyct < 0)
>>  		dev_err(di->dev, "error reading cycle count total\n");
>>  
>> @@ -421,21 +602,32 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
>>   * Read an average power register.
>>   * Return < 0 if something fails.
>>   */
>> -static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
>> +static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
>>  {
>>  	int tval;
>>  
>> -	tval = bq27xxx_read(di, reg, false);
>> +	tval = bq27xxx_read(di, BQ27XXX_REG_AP, false);
>>  	if (tval < 0) {
>> -		dev_err(di->dev, "error reading power avg rgister  %02x: %d\n",
>> -			reg, tval);
>> +		dev_err(di->dev, "error reading average power register  %02x: %d\n",
>> +			BQ27XXX_REG_AP, tval);
>>  		return tval;
>>  	}
>>  
>> -	if (di->chip == BQ27500)
>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>> +		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
>> +	else
>>  		return tval;
>> +}
>> +
>> +/*
>> + * Returns true if a battery over temperature condition is detected
>> + */
>> +static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
>> +{
>> +	if (di->chip == BQ27500 || di->chip == BQ27541)
>> +		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
>>  	else
>> -		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
>> +		return flags & BQ27XXX_FLAG_OTC;
>>  }
>>  
>>  /*
>> @@ -444,53 +636,43 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
>>   */
>>  static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
>>  {
>> -	int tval;
>> +	u16 tval;
>>  
>> -	tval = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
>> +	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
>>  	if (tval < 0) {
>>  		dev_err(di->dev, "error reading flag register:%d\n", tval);
>>  		return tval;
>>  	}
>>  
>> -	if (di->chip == BQ27500) {
>> -		if (tval & BQ27500_FLAG_SOCF)
>> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
>> +		if (tval & BQ27000_FLAG_EDV1)
>>  			tval = POWER_SUPPLY_HEALTH_DEAD;
>> -		else if (tval & BQ27500_FLAG_OTC)
>> -			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
>>  		else
>>  			tval = POWER_SUPPLY_HEALTH_GOOD;
>> -		return tval;
>> -	} else if (di->chip == BQ27510) {
>> -		if (tval & BQ27500_FLAG_OTC)
>> -			return POWER_SUPPLY_HEALTH_OVERHEAT;
>> -		return POWER_SUPPLY_HEALTH_GOOD;
>>  	} else {
>> -		if (tval & BQ27000_FLAG_EDV1)
>> +		if (tval & BQ27XXX_FLAG_SOCF)
>>  			tval = POWER_SUPPLY_HEALTH_DEAD;
>> +		else if (bq27xxx_battery_overtemp(di, tval))
>> +			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
>>  		else
>>  			tval = POWER_SUPPLY_HEALTH_GOOD;
>> -		return tval;
>>  	}
>>  
>> -	return -1;
>> +	return tval;
>>  }
>>  
>>  static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>>  {
>>  	struct bq27xxx_reg_cache cache = {0, };
>> -	bool is_bq27500 = di->chip == BQ27500;
>> -	bool is_bq27510 = di->chip == BQ27510;
>> -	bool is_bq27425 = di->chip == BQ27425;
>> -	bool is_bq27742 = di->chip == BQ27742;
>> -	bool flags_1b = !(is_bq27500 || is_bq27742);
>> +	bool has_ci_flag = di->chip == BQ27000 || di->chip == BQ27010;
>> +	bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010;
>>  
>> -	cache.flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
>> +	cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
>>  	if ((cache.flags & 0xff) == 0xff)
>> -		/* read error */
>> -		cache.flags = -1;
>> +		cache.flags = -1; /* read error */
>>  	if (cache.flags >= 0) {
>> -		if (!is_bq27500 && !is_bq27425 && !is_bq27742 && !is_bq27510
>> -				&& (cache.flags & BQ27000_FLAG_CI)) {
>> +		cache.temperature = bq27xxx_battery_read_temperature(di);
>> +		if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) {
>>  			dev_info(di->dev, "battery is not calibrated! ignoring capacity values\n");
>>  			cache.capacity = -ENODATA;
>>  			cache.energy = -ENODATA;
>> @@ -500,41 +682,25 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>>  			cache.charge_full = -ENODATA;
>>  			cache.health = -ENODATA;
>>  		} else {
>> +			if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
>> +				cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
>> +			if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
>> +				cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
>> +			if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
>> +				cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
>> +			cache.charge_full = bq27xxx_battery_read_fcc(di);
>>  			cache.capacity = bq27xxx_battery_read_soc(di);
>> -			if (is_bq27742 || is_bq27510)
>> -				cache.time_to_empty =
>> -					bq27xxx_battery_read_time(di,
>> -							BQ27x00_REG_TTE);
>> -			else if (!is_bq27425) {
>> +			if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
>>  				cache.energy = bq27xxx_battery_read_energy(di);
>> -				cache.time_to_empty =
>> -					bq27xxx_battery_read_time(di,
>> -							BQ27x00_REG_TTE);
>> -				cache.time_to_empty_avg =
>> -					bq27xxx_battery_read_time(di,
>> -							BQ27x00_REG_TTECP);
>> -				cache.time_to_full =
>> -					bq27xxx_battery_read_time(di,
>> -							BQ27x00_REG_TTF);
>> -			}
>> -			cache.charge_full = bq27xxx_battery_read_lmd(di);
>>  			cache.health = bq27xxx_battery_read_health(di);
>>  		}
>> -		cache.temperature = bq27xxx_battery_read_temperature(di);
>> -		if (!is_bq27425)
>> +		if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
>>  			cache.cycle_count = bq27xxx_battery_read_cyct(di);
>> -		if (is_bq27742)
>> -			cache.power_avg =
>> -				bq27xxx_battery_read_pwr_avg(di,
>> -						BQ27742_POWER_AVG);
>> -		else
>> -			cache.power_avg =
>> -				bq27xxx_battery_read_pwr_avg(di,
>> -						BQ27x00_POWER_AVG);
>> +		cache.power_avg = bq27xxx_battery_read_pwr_avg(di);
>>  
>>  		/* We only have to read charge design full once */
>>  		if (di->charge_design_full <= 0)
>> -			di->charge_design_full = bq27xxx_battery_read_ilmd(di);
>> +			di->charge_design_full = bq27xxx_battery_read_dcap(di);
>>  	}
>>  
>>  	if (di->cache.capacity != cache.capacity)
>> @@ -549,7 +715,8 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
>>  static void bq27xxx_battery_poll(struct work_struct *work)
>>  {
>>  	struct bq27xxx_device_info *di =
>> -		container_of(work, struct bq27xxx_device_info, work.work);
>> +			container_of(work, struct bq27xxx_device_info,
>> +				     work.work);
>>  
>>  	bq27xxx_battery_update(di);
>>  
>> @@ -571,23 +738,23 @@ static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
>>  	int curr;
>>  	int flags;
>>  
>> -	curr = bq27xxx_read(di, BQ27x00_REG_AI, false);
>> +	curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
>>  	if (curr < 0) {
>>  		dev_err(di->dev, "error reading current\n");
>>  		return curr;
>>  	}
>>  
>> -	if (bq27xxx_is_chip_version_higher(di)) {
>> -		/* bq27500 returns signed value */
>> -		val->intval = (int)((s16)curr) * 1000;
>> -	} else {
>> -		flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
>> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
>> +		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
>>  		if (flags & BQ27000_FLAG_CHGS) {
>>  			dev_dbg(di->dev, "negative current!\n");
>>  			curr = -curr;
>>  		}
>>  
>> -		val->intval = curr * 3570 / BQ27XXX_RS;
>> +		val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
>> +	} else {
>> +		/* Other gauges return signed value */
>> +		val->intval = (int)((s16)curr) * 1000;
>>  	}
>>  
>>  	return 0;
>> @@ -598,14 +765,7 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
>>  {
>>  	int status;
>>  
>> -	if (bq27xxx_is_chip_version_higher(di)) {
>> -		if (di->cache.flags & BQ27500_FLAG_FC)
>> -			status = POWER_SUPPLY_STATUS_FULL;
>> -		else if (di->cache.flags & BQ27500_FLAG_DSC)
>> -			status = POWER_SUPPLY_STATUS_DISCHARGING;
>> -		else
>> -			status = POWER_SUPPLY_STATUS_CHARGING;
>> -	} else {
>> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
>>  		if (di->cache.flags & BQ27000_FLAG_FC)
>>  			status = POWER_SUPPLY_STATUS_FULL;
>>  		else if (di->cache.flags & BQ27000_FLAG_CHGS)
>> @@ -614,6 +774,13 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
>>  			status = POWER_SUPPLY_STATUS_NOT_CHARGING;
>>  		else
>>  			status = POWER_SUPPLY_STATUS_DISCHARGING;
>> +	} else {
>> +		if (di->cache.flags & BQ27XXX_FLAG_FC)
>> +			status = POWER_SUPPLY_STATUS_FULL;
>> +		else if (di->cache.flags & BQ27XXX_FLAG_DSC)
>> +			status = POWER_SUPPLY_STATUS_DISCHARGING;
>> +		else
>> +			status = POWER_SUPPLY_STATUS_CHARGING;
>>  	}
>>  
>>  	val->intval = status;
>> @@ -626,21 +793,21 @@ static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
>>  {
>>  	int level;
>>  
>> -	if (bq27xxx_is_chip_version_higher(di)) {
>> -		if (di->cache.flags & BQ27500_FLAG_FC)
>> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
>> +		if (di->cache.flags & BQ27000_FLAG_FC)
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
>> -		else if (di->cache.flags & BQ27500_FLAG_SOC1)
>> +		else if (di->cache.flags & BQ27000_FLAG_EDV1)
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
>> -		else if (di->cache.flags & BQ27500_FLAG_SOCF)
>> +		else if (di->cache.flags & BQ27000_FLAG_EDVF)
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
>>  		else
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
>>  	} else {
>> -		if (di->cache.flags & BQ27000_FLAG_FC)
>> +		if (di->cache.flags & BQ27XXX_FLAG_FC)
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
>> -		else if (di->cache.flags & BQ27000_FLAG_EDV1)
>> +		else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
>> -		else if (di->cache.flags & BQ27000_FLAG_EDVF)
>> +		else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
>>  		else
>>  			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
>> @@ -660,7 +827,7 @@ static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
>>  {
>>  	int volt;
>>  
>> -	volt = bq27xxx_read(di, BQ27x00_REG_VOLT, false);
>> +	volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
>>  	if (volt < 0) {
>>  		dev_err(di->dev, "error reading voltage\n");
>>  		return volt;
>> @@ -721,7 +888,7 @@ static int bq27xxx_battery_get_property(struct power_supply *psy,
>>  	case POWER_SUPPLY_PROP_TEMP:
>>  		ret = bq27xxx_simple_value(di->cache.temperature, val);
>>  		if (ret == 0)
>> -			val->intval -= 2731;
>> +			val->intval -= 2731; /* convert decidegree k to c */
>>  		break;
>>  	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
>>  		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
>> @@ -787,18 +954,27 @@ static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
>>  
>>  	psy_desc->name = name;
>>  	psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
>> -	if (di->chip == BQ27425) {
>> -		psy_desc->properties = bq27425_battery_props;
>> -		psy_desc->num_properties = ARRAY_SIZE(bq27425_battery_props);
>> -	} else if (di->chip == BQ27742) {
>> -		psy_desc->properties = bq27742_battery_props;
>> -		psy_desc->num_properties = ARRAY_SIZE(bq27742_battery_props);
>> -	} else if (di->chip == BQ27510) {
>> -		psy_desc->properties = bq27510_battery_props;
>> -		psy_desc->num_properties = ARRAY_SIZE(bq27510_battery_props);
>> +	if (di->chip == BQ27000) {
>> +		psy_desc->properties = bq27000_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27000_battery_props);
>> +	} else if (di->chip == BQ27010) {
>> +		psy_desc->properties = bq27010_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27010_battery_props);
>> +	} else if (di->chip == BQ27500) {
>> +		psy_desc->properties = bq27500_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27500_battery_props);
>> +	} else if (di->chip == BQ27530) {
>> +		psy_desc->properties = bq27530_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27530_battery_props);
>> +	} else if (di->chip == BQ27541) {
>> +		psy_desc->properties = bq27541_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27541_battery_props);
>> +	} else if (di->chip == BQ27545) {
>> +		psy_desc->properties = bq27545_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27545_battery_props);
>>  	} else {
>> -		psy_desc->properties = bq27x00_battery_props;
>> -		psy_desc->num_properties = ARRAY_SIZE(bq27x00_battery_props);
>> +		psy_desc->properties = bq27421_battery_props;
>> +		psy_desc->num_properties = ARRAY_SIZE(bq27421_battery_props);
>>  	}
>>  	psy_desc->get_property = bq27xxx_battery_get_property;
>>  	psy_desc->external_power_changed = bq27xxx_external_power_changed;
>> @@ -913,10 +1089,32 @@ static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
>>  	di->chip = id->driver_data;
>>  	di->bus.read = &bq27xxx_battery_i2c_read;
>>  
>> +	if (di->chip == BQ27000) {
>> +		di->regs = bq27000_regs;
>> +	} else if (di->chip == BQ27010) {
>> +		di->regs = bq27010_regs;
>> +	} else if (di->chip == BQ27500) {
>> +		di->regs = bq27500_regs;
>> +	} else if (di->chip == BQ27530) {
>> +		di->regs = bq27530_regs;
>> +	} else if (di->chip == BQ27541) {
>> +		di->regs = bq27541_regs;
>> +	} else if (di->chip == BQ27545) {
>> +		di->regs = bq27545_regs;
>> +	} else if (di->chip == BQ27421) {
>> +		di->regs = bq27421_regs;
>> +	} else {
>> +		dev_err(&client->dev, "Unexpected gas gauge: %d\n", di->chip);
>> +		di->regs = bq27000_regs;
>> +	}
>> +
>>  	retval = bq27xxx_powersupply_init(di, name);
>>  	if (retval)
>>  		goto batt_failed;
>>  
>> +	/* Schedule a polling after about 1 min */
>> +	schedule_delayed_work(&di->work, 60 * HZ);
>> +
>>  	i2c_set_clientdata(client, di);
>>  
>>  	return 0;
>> @@ -943,11 +1141,13 @@ static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
>>  }
>>  
>>  static const struct i2c_device_id bq27xxx_id[] = {
>> -	{ "bq27200", BQ27000 },	/* bq27200 is same as bq27000, but with i2c */
>> +	{ "bq27000", BQ27000 },
> 
> I2C version is bq27200, HDQ is bq27000. So here in struct i2c_device_id
> is needed bq27200.
> 
> Also existing kernel code depends on it (git grep bq27200).
> 

My bad, I'll fix it.

>> +	{ "bq27010", BQ27010 },
>>  	{ "bq27500", BQ27500 },
>> -	{ "bq27425", BQ27425 },
>> -	{ "bq27742", BQ27742 },
>> -	{ "bq27510", BQ27510 },
>> +	{ "bq27530", BQ27530 },
>> +	{ "bq27541", BQ27541 },
>> +	{ "bq27545", BQ27545 },
>> +	{ "bq27421", BQ27421 },
> 
> Why you removed support for bq27425, bq27742 and bq27510?
> 

I merged devices into families so they are still supported under the more
generic family ID, so I'll re-add the devices here.

Thanks,
Andrew F. Davis

>>  	{},
>>  };
>>  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
> 

Re: [PATCH 7/8] power: bq27xxx_battery: Add support for additional bq27xxx family devices

[Pali Rohár]

On Thursday 23 July 2015 12:42:34 Andrew F. Davis wrote:
> Pali,
> On 07/23/2015 11:20 AM, Pali Rohár wrote:
> > On Wednesday 22 July 2015 16:51:59 Andrew F. Davis wrote:
> >> Add support for additional devices and register equivalent family devices
> >> including the bq27010, bq27210, bq272500, bq27510, bq27520, bq27530,
> >> bq27531, bq27541, bq27542, bq27546, bq27545, bq27441, bq27421, and the
> >> bq27641.
> >>
> >> To facilitate this process the register mapings have been moved to tables
> >> and other small cleanups have been made.
> >>
> >> Signed-off-by: Andrew F. Davis <afd@ti.com>
> >> ---
> >>  drivers/power/bq27xxx_battery.c | 618 ++++++++++++++++++++++++++--------------
> >>  1 file changed, 409 insertions(+), 209 deletions(-)
> >>
> >> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
> >> index 5686da6..f148222 100644
> >> --- a/drivers/power/bq27xxx_battery.c
> >> +++ b/drivers/power/bq27xxx_battery.c
> >> @@ -17,11 +17,15 @@
> >>   * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
> >>   *
> >>   * Datasheets:
> >> - * http://focus.ti.com/docs/prod/folders/print/bq27000.html
> >> - * http://focus.ti.com/docs/prod/folders/print/bq27500.html
> >> + * http://www.ti.com/product/bq27000
> >> + * http://www.ti.com/product/bq27010
> >> + * http://www.ti.com/product/bq27510-g3
> >> + * http://www.ti.com/product/bq27520-g4
> >> + * http://www.ti.com/product/bq27411-g1
> >> + * http://www.ti.com/product/bq27421-g1
> >>   * http://www.ti.com/product/bq27425-g1
> >> - * http://www.ti.com/product/BQ27742-G1
> >> - * http://www.ti.com/product/BQ27510-G3
> >> + * http://www.ti.com/product/bq27742-g1
> >> + * http://www.ti.com/product/bq27621-g1
> >>   */
> > 
> > Now, when you touching list of links to documentation, you can add also
> > one for bq27200: http://www.ti.com/product/bq27200
> > 
> 
> OK, good idea.
> 
> >>  
> >>  #include <linux/device.h>
> >> @@ -43,55 +47,66 @@
> >>  
> >>  #define BQ27XXX_MANUFACTURER	"Texas Instruments"
> >>  
> >> -#define BQ27x00_REG_TEMP	0x06
> >> -#define BQ27x00_REG_VOLT	0x08
> >> -#define BQ27x00_REG_AI		0x14
> >> -#define BQ27x00_REG_FLAGS	0x0A
> >> -#define BQ27x00_REG_TTE		0x16
> >> -#define BQ27x00_REG_TTF		0x18
> >> -#define BQ27x00_REG_TTECP	0x26
> >> -#define BQ27x00_REG_NAC		0x0C /* Nominal available capacity */
> >> -#define BQ27x00_REG_LMD		0x12 /* Last measured discharge */
> >> -#define BQ27x00_REG_CYCT	0x2A /* Cycle count total */
> >> -#define BQ27x00_REG_AE		0x22 /* Available energy */
> >> -#define BQ27x00_POWER_AVG	0x24
> >> -
> >> -#define BQ27000_REG_RSOC	0x0B /* Relative State-of-Charge */
> >> -#define BQ27000_REG_ILMD	0x76 /* Initial last measured discharge */
> >> +/* BQ27XXX Flags */
> >> +#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_FC		BIT(9)
> >> +#define BQ27XXX_FLAG_OTD	BIT(14)
> >> +#define BQ27XXX_FLAG_OTC	BIT(15)
> >> +
> >> +/* BQ27000 has different layout for Flags register */
> >>  #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
> >>  #define BQ27000_FLAG_EDV1	BIT(1) /* First End-of-Discharge-Voltage flag */
> >>  #define BQ27000_FLAG_CI		BIT(4) /* Capacity Inaccurate flag */
> >>  #define BQ27000_FLAG_FC		BIT(5)
> >>  #define BQ27000_FLAG_CHGS	BIT(7) /* Charge state flag */
> >>  
> >> -#define BQ27500_REG_SOC		0x2C
> >> -#define BQ27500_REG_DCAP	0x3C /* Design capacity */
> >> -#define BQ27500_FLAG_DSC	BIT(0)
> >> -#define BQ27500_FLAG_SOCF	BIT(1) /* State-of-Charge threshold final */
> >> -#define BQ27500_FLAG_SOC1	BIT(2) /* State-of-Charge threshold 1 */
> >> -#define BQ27500_FLAG_FC		BIT(9)
> >> -#define BQ27500_FLAG_OTC	BIT(15)
> >> -
> >> -#define BQ27742_POWER_AVG	0x76
> >> -
> >> -#define BQ27510_REG_SOC		0x20
> >> -#define BQ27510_REG_DCAP	0x2E /* Design capacity */
> >> -#define BQ27510_REG_CYCT	0x1E /* Cycle count total */
> >> -
> >> -/* bq27425 register addresses are same as bq27x00 addresses minus 4 */
> >> -#define BQ27425_REG_OFFSET	0x04
> >> -#define BQ27425_REG_SOC		(0x1C + BQ27425_REG_OFFSET)
> >> -#define BQ27425_REG_DCAP	(0x3C + BQ27425_REG_OFFSET)
> >> -
> >> -#define BQ27XXX_RS			20 /* Resistor sense */
> >> -#define BQ27XXX_POWER_CONSTANT		(256 * 29200 / 1000)
> >> +#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 */
> >>  
> >>  struct bq27xxx_device_info;
> >>  struct bq27xxx_access_methods {
> >>  	int (*read)(struct bq27xxx_device_info *di, u8 reg, bool single);
> >>  };
> >>  
> >> -enum bq27xxx_chip { BQ27000, BQ27500, BQ27425, BQ27742, BQ27510};
> >> +#define INVALID_REG_ADDR	0xff
> >> +
> >> +enum bq27xxx_chip {
> >> +	BQ27000, /* bq27000, bq27200 */
> >> +	BQ27010, /* bq27010, bq27210 */
> >> +	BQ27500, /* bq27500, bq27510, bq27520 */
> >> +	BQ27530, /* bq27530, bq27531 */
> >> +	BQ27541, /* bq27541, bq27542, bq27546, bq27742 */
> >> +	BQ27545, /* bq27545 */
> >> +	BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
> >> +};
> >> +
> >> +/*
> >> + * bq27xxx_reg_index - Register names
> >> + *
> >> + * These are indexes into a device's register mapping array.
> >> + */
> >> +enum bq27xxx_reg_index {
> >> +	BQ27XXX_REG_CTRL = 0,	/* Control */
> >> +	BQ27XXX_REG_TEMP,	/* Temperature */
> >> +	BQ27XXX_REG_INT_TEMP,	/* Internal Temperature */
> >> +	BQ27XXX_REG_VOLT,	/* Voltage */
> >> +	BQ27XXX_REG_AI,		/* Average Current */
> >> +	BQ27XXX_REG_FLAGS,	/* Flags */
> >> +	BQ27XXX_REG_TTE,	/* Time-to-Empty */
> >> +	BQ27XXX_REG_TTF,	/* Time-to-Full */
> >> +	BQ27XXX_REG_TTES,	/* Time-to-Empty Standby */
> >> +	BQ27XXX_REG_TTECP,	/* Time-to-Empty at Constant Power */
> >> +	BQ27XXX_REG_NAC,	/* Nominal Available Capacity */
> >> +	BQ27XXX_REG_FCC,	/* Full Charge Capacity */
> >> +	BQ27XXX_REG_CYCT,	/* Cycle Count */
> >> +	BQ27XXX_REG_AE,		/* Available Energy */
> >> +	BQ27XXX_REG_SOC,	/* State-of-Charge */
> >> +	BQ27XXX_REG_DCAP,	/* Design Capacity */
> >> +	BQ27XXX_REG_AP,		/* Average Power */
> >> +};
> >>  
> >>  struct bq27xxx_reg_cache {
> >>  	int temperature;
> >> @@ -123,9 +138,152 @@ struct bq27xxx_device_info {
> >>  	struct bq27xxx_access_methods bus;
> >>  
> >>  	struct mutex lock;
> >> +
> >> +	u8 *regs;
> >>  };
> >>  
> >> -static enum power_supply_property bq27x00_battery_props[] = {
> >> +/* Register mappings */
> >> +static u8 bq27000_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x06,	/* TEMP		*/
> >> +	0xff,	/* INT TEMP - NA*/
> >> +	0x08,	/* VOLT		*/
> >> +	0x14,	/* AVG CURR	*/
> >> +	0x0a,	/* FLAGS	*/
> >> +	0x16,	/* TTE		*/
> >> +	0x18,	/* TTF		*/
> >> +	0x1c,	/* TTES		*/
> >> +	0x26,	/* TTECP	*/
> >> +	0x0c,	/* NAC		*/
> >> +	0x12,	/* LMD(FCC)	*/
> >> +	0x2a,	/* CYCT		*/
> >> +	0x22,	/* AE		*/
> >> +	0x0b,	/* SOC(RSOC)	*/
> >> +	0x76,	/* DCAP(ILMD)	*/
> >> +	0x24,	/* AP		*/
> >> +};
> >> +
> >> +static u8 bq27010_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x06,	/* TEMP		*/
> >> +	0xff,	/* INT TEMP - NA*/
> >> +	0x08,	/* VOLT		*/
> >> +	0x14,	/* AVG CURR	*/
> >> +	0x0a,	/* FLAGS	*/
> >> +	0x16,	/* TTE		*/
> >> +	0x18,	/* TTF		*/
> >> +	0x1c,	/* TTES		*/
> >> +	0x26,	/* TTECP	*/
> >> +	0x0c,	/* NAC		*/
> >> +	0x12,	/* LMD(FCC)	*/
> >> +	0x2a,	/* CYCT		*/
> >> +	0xff,	/* AE - NA	*/
> >> +	0x0b,	/* SOC(RSOC)	*/
> >> +	0x76,	/* DCAP(ILMD)	*/
> >> +	0xff,	/* AP - NA	*/
> >> +};
> >> +
> >> +static u8 bq27500_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x06,	/* TEMP		*/
> >> +	0x28,	/* INT TEMP	*/
> >> +	0x08,	/* VOLT		*/
> >> +	0x14,	/* AVG CURR	*/
> >> +	0x0a,	/* FLAGS	*/
> >> +	0x16,	/* TTE		*/
> >> +	0xff,	/* TTF - NA	*/
> >> +	0x1a,	/* TTES		*/
> >> +	0xff,	/* TTECP - NA	*/
> >> +	0x0c,	/* NAC		*/
> >> +	0x12,	/* LMD(FCC)	*/
> >> +	0x1e,	/* CYCT		*/
> >> +	0xff,	/* AE - NA	*/
> >> +	0x20,	/* SOC(RSOC)	*/
> >> +	0x2e,	/* DCAP(ILMD)	*/
> >> +	0xff,	/* AP - NA	*/
> >> +};
> >> +
> >> +static u8 bq27530_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x06,	/* TEMP		*/
> >> +	0x32,	/* INT TEMP	*/
> >> +	0x08,	/* VOLT		*/
> >> +	0x14,	/* AVG CURR	*/
> >> +	0x0a,	/* FLAGS	*/
> >> +	0x16,	/* TTE		*/
> >> +	0xff,	/* TTF - NA	*/
> >> +	0xff,	/* TTES - NA	*/
> >> +	0xff,	/* TTECP - NA	*/
> >> +	0x0c,	/* NAC		*/
> >> +	0x12,	/* LMD(FCC)	*/
> >> +	0x2a,	/* CYCT		*/
> >> +	0xff,	/* AE - NA	*/
> >> +	0x2c,	/* SOC(RSOC)	*/
> >> +	0xff,	/* DCAP - NA	*/
> >> +	0x24,	/* AP		*/
> >> +};
> >> +
> >> +static u8 bq27541_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x06,	/* TEMP		*/
> >> +	0x28,	/* INT TEMP	*/
> >> +	0x08,	/* VOLT		*/
> >> +	0x14,	/* AVG CURR	*/
> >> +	0x0a,	/* FLAGS	*/
> >> +	0x16,	/* TTE		*/
> >> +	0xff,	/* TTF - NA	*/
> >> +	0xff,	/* TTES - NA	*/
> >> +	0xff,	/* TTECP - NA	*/
> >> +	0x0c,	/* NAC		*/
> >> +	0x12,	/* LMD(FCC)	*/
> >> +	0x2a,	/* CYCT		*/
> >> +	0xff,	/* AE - NA	*/
> >> +	0x2c,	/* SOC(RSOC)	*/
> >> +	0x3c,	/* DCAP		*/
> >> +	0x76,	/* AP		*/
> >> +};
> >> +
> >> +static u8 bq27545_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x06,	/* TEMP		*/
> >> +	0x28,	/* INT TEMP	*/
> >> +	0x08,	/* VOLT		*/
> >> +	0x14,	/* AVG CURR	*/
> >> +	0x0a,	/* FLAGS	*/
> >> +	0x16,	/* TTE		*/
> >> +	0xff,	/* TTF - NA	*/
> >> +	0xff,	/* TTES - NA	*/
> >> +	0xff,	/* TTECP - NA	*/
> >> +	0x0c,	/* NAC		*/
> >> +	0x12,	/* LMD(FCC)	*/
> >> +	0x2a,	/* CYCT		*/
> >> +	0xff,	/* AE - NA	*/
> >> +	0x2c,	/* SOC(RSOC)	*/
> >> +	0xff,	/* DCAP - NA */
> >> +	0x24,	/* AP		*/
> >> +};
> >> +
> >> +static u8 bq27421_regs[] = {
> >> +	0x00,	/* CONTROL	*/
> >> +	0x02,	/* TEMP		*/
> >> +	0x1e,	/* INT TEMP	*/
> >> +	0x04,	/* VOLT		*/
> >> +	0x10,	/* AVG CURR	*/
> >> +	0x06,	/* FLAGS	*/
> >> +	0xff,	/* TTE - NA	*/
> >> +	0xff,	/* TTF - NA	*/
> >> +	0xff,	/* TTES - NA	*/
> >> +	0xff,	/* TTECP - NA	*/
> >> +	0x08,	/* NAC		*/
> >> +	0x0e,	/* FCC		*/
> >> +	0xff,	/* CYCT - NA	*/
> >> +	0xff,	/* AE - NA	*/
> >> +	0x1c,	/* SOC		*/
> >> +	0x3c,	/* DCAP		*/
> >> +	0x18,	/* AP		*/
> >> +};
> >> +
> >> +static enum power_supply_property bq27000_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_STATUS,
> >>  	POWER_SUPPLY_PROP_PRESENT,
> >>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> @@ -147,7 +305,7 @@ static enum power_supply_property bq27x00_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_MANUFACTURER,
> >>  };
> >>  
> >> -static enum power_supply_property bq27425_battery_props[] = {
> >> +static enum power_supply_property bq27010_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_STATUS,
> >>  	POWER_SUPPLY_PROP_PRESENT,
> >>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> @@ -155,14 +313,19 @@ static enum power_supply_property bq27425_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_CAPACITY,
> >>  	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> >>  	POWER_SUPPLY_PROP_TEMP,
> >> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
> >> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
> >> +	POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
> >>  	POWER_SUPPLY_PROP_TECHNOLOGY,
> >>  	POWER_SUPPLY_PROP_CHARGE_FULL,
> >>  	POWER_SUPPLY_PROP_CHARGE_NOW,
> >>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
> >> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
> >> +	POWER_SUPPLY_PROP_HEALTH,
> >>  	POWER_SUPPLY_PROP_MANUFACTURER,
> >>  };
> >>  
> >> -static enum power_supply_property bq27742_battery_props[] = {
> >> +static enum power_supply_property bq27500_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_STATUS,
> >>  	POWER_SUPPLY_PROP_PRESENT,
> >>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> @@ -176,12 +339,29 @@ static enum power_supply_property bq27742_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_CHARGE_NOW,
> >>  	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
> >>  	POWER_SUPPLY_PROP_CYCLE_COUNT,
> >> +	POWER_SUPPLY_PROP_HEALTH,
> >> +	POWER_SUPPLY_PROP_MANUFACTURER,
> >> +};
> >> +
> >> +static enum power_supply_property bq27530_battery_props[] = {
> >> +	POWER_SUPPLY_PROP_STATUS,
> >> +	POWER_SUPPLY_PROP_PRESENT,
> >> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> >> +	POWER_SUPPLY_PROP_CAPACITY,
> >> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> >> +	POWER_SUPPLY_PROP_TEMP,
> >> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
> >> +	POWER_SUPPLY_PROP_TECHNOLOGY,
> >> +	POWER_SUPPLY_PROP_CHARGE_FULL,
> >> +	POWER_SUPPLY_PROP_CHARGE_NOW,
> >>  	POWER_SUPPLY_PROP_POWER_AVG,
> >>  	POWER_SUPPLY_PROP_HEALTH,
> >> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
> >>  	POWER_SUPPLY_PROP_MANUFACTURER,
> >>  };
> >>  
> >> -static enum power_supply_property bq27510_battery_props[] = {
> >> +static enum power_supply_property bq27541_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_STATUS,
> >>  	POWER_SUPPLY_PROP_PRESENT,
> >>  	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> @@ -200,6 +380,39 @@ static enum power_supply_property bq27510_battery_props[] = {
> >>  	POWER_SUPPLY_PROP_MANUFACTURER,
> >>  };
> >>  
> >> +static enum power_supply_property bq27545_battery_props[] = {
> >> +	POWER_SUPPLY_PROP_STATUS,
> >> +	POWER_SUPPLY_PROP_PRESENT,
> >> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> >> +	POWER_SUPPLY_PROP_CAPACITY,
> >> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> >> +	POWER_SUPPLY_PROP_TEMP,
> >> +	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
> >> +	POWER_SUPPLY_PROP_TECHNOLOGY,
> >> +	POWER_SUPPLY_PROP_CHARGE_FULL,
> >> +	POWER_SUPPLY_PROP_CHARGE_NOW,
> >> +	POWER_SUPPLY_PROP_HEALTH,
> >> +	POWER_SUPPLY_PROP_CYCLE_COUNT,
> >> +	POWER_SUPPLY_PROP_POWER_AVG,
> >> +	POWER_SUPPLY_PROP_MANUFACTURER,
> >> +};
> >> +
> >> +static enum power_supply_property bq27421_battery_props[] = {
> >> +	POWER_SUPPLY_PROP_STATUS,
> >> +	POWER_SUPPLY_PROP_PRESENT,
> >> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> >> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> >> +	POWER_SUPPLY_PROP_CAPACITY,
> >> +	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
> >> +	POWER_SUPPLY_PROP_TEMP,
> >> +	POWER_SUPPLY_PROP_TECHNOLOGY,
> >> +	POWER_SUPPLY_PROP_CHARGE_FULL,
> >> +	POWER_SUPPLY_PROP_CHARGE_NOW,
> >> +	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
> >> +	POWER_SUPPLY_PROP_MANUFACTURER,
> >> +};
> >> +
> >>  static unsigned int poll_interval = 360;
> >>  module_param(poll_interval, uint, 0644);
> >>  MODULE_PARM_DESC(poll_interval,
> >> @@ -209,25 +422,14 @@ MODULE_PARM_DESC(poll_interval,
> >>   * Common code for BQ27xxx devices
> >>   */
> >>  
> >> -static inline int bq27xxx_read(struct bq27xxx_device_info *di, u8 reg,
> >> +static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index,
> >>  			       bool single)
> >>  {
> >> -	if (di->chip == BQ27425)
> >> -		return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
> >> -	return di->bus.read(di, reg, single);
> >> -}
> >> +	/* Reports EINVAL for invalid/missing registers */
> >> +	if (!di || di->regs[reg_index] == INVALID_REG_ADDR)
> >> +		return -EINVAL;
> >>  
> >> -/*
> >> - * Higher versions of the chip like BQ27425 and BQ27500
> >> - * differ from BQ27000 and BQ27200 in calculation of certain
> >> - * parameters. Hence we need to check for the chip type.
> >> - */
> >> -static bool bq27xxx_is_chip_version_higher(struct bq27xxx_device_info *di)
> >> -{
> >> -	if (di->chip == BQ27425 || di->chip == BQ27500 || di->chip == BQ27742
> >> -	    || di->chip == BQ27510)
> >> -		return true;
> >> -	return false;
> >> +	return di->bus.read(di, di->regs[reg_index], single);
> >>  }
> >>  
> >>  /*
> >> @@ -238,14 +440,7 @@ static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di)
> >>  {
> >>  	int soc;
> >>  
> >> -	if (di->chip == BQ27500 || di->chip == BQ27742)
> >> -		soc = bq27xxx_read(di, BQ27500_REG_SOC, false);
> >> -	else if (di->chip == BQ27510)
> >> -		soc = bq27xxx_read(di, BQ27510_REG_SOC, false);
> >> -	else if (di->chip == BQ27425)
> >> -		soc = bq27xxx_read(di, BQ27425_REG_SOC, false);
> >> -	else
> >> -		soc = bq27xxx_read(di, BQ27000_REG_RSOC, true);
> >> +	soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false);
> >>  
> >>  	if (soc < 0)
> >>  		dev_dbg(di->dev, "error reading State-of-Charge\n");
> >> @@ -268,10 +463,10 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
> >>  		return charge;
> >>  	}
> >>  
> >> -	if (bq27xxx_is_chip_version_higher(di))
> >> -		charge *= 1000;
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> >> +		charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
> >>  	else
> >> -		charge = charge * 3570 / BQ27XXX_RS;
> >> +		charge *= 1000;
> >>  
> >>  	return charge;
> >>  }
> >> @@ -283,57 +478,46 @@ static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg)
> >>  static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di)
> >>  {
> >>  	int flags;
> >> -	bool is_bq27500 = di->chip == BQ27500;
> >> -	bool is_bq27742 = di->chip == BQ27742;
> >> -	bool is_higher = bq27xxx_is_chip_version_higher(di);
> >> -	bool flags_1b = !(is_bq27500 || is_bq27742);
> >>  
> >> -	flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
> >> -	if (flags >= 0 && !is_higher && (flags & BQ27000_FLAG_CI))
> >> -		return -ENODATA;
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> >> +		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true);
> >> +		if (flags >= 0 && (flags & BQ27000_FLAG_CI))
> >> +			return -ENODATA;
> >> +	}
> >>  
> >> -	return bq27xxx_battery_read_charge(di, BQ27x00_REG_NAC);
> >> +	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC);
> >>  }
> >>  
> >>  /*
> >> - * Return the battery Last measured discharge in µAh
> >> + * Return the battery Full Charge Capacity in µAh
> >>   * Or < 0 if something fails.
> >>   */
> >> -static inline int bq27xxx_battery_read_lmd(struct bq27xxx_device_info *di)
> >> +static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di)
> >>  {
> >> -	return bq27xxx_battery_read_charge(di, BQ27x00_REG_LMD);
> >> +	return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC);
> >>  }
> >>  
> >>  /*
> >> - * Return the battery Initial last measured discharge in µAh
> >> + * Return the Design Capacity in µAh
> >>   * Or < 0 if something fails.
> >>   */
> >> -static int bq27xxx_battery_read_ilmd(struct bq27xxx_device_info *di)
> >> +static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di)
> >>  {
> >> -	int ilmd;
> >> +	int dcap;
> >>  
> >> -	if (bq27xxx_is_chip_version_higher(di)) {
> >> -		if (di->chip == BQ27425)
> >> -			ilmd = bq27xxx_read(di, BQ27425_REG_DCAP, false);
> >> -		else if (di->chip == BQ27510)
> >> -			ilmd = bq27xxx_read(di, BQ27510_REG_DCAP, false);
> >> -		else
> >> -			ilmd = bq27xxx_read(di, BQ27500_REG_DCAP, false);
> >> -	} else {
> >> -		ilmd = bq27xxx_read(di, BQ27000_REG_ILMD, true);
> >> -	}
> >> +	dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false);
> >>  
> >> -	if (ilmd < 0) {
> >> +	if (dcap < 0) {
> >>  		dev_dbg(di->dev, "error reading initial last measured discharge\n");
> >> -		return ilmd;
> >> +		return dcap;
> >>  	}
> >>  
> >> -	if (bq27xxx_is_chip_version_higher(di))
> >> -		ilmd *= 1000;
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> >> +		dcap *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
> >>  	else
> >> -		ilmd = ilmd * 256 * 3570 / BQ27XXX_RS;
> >> +		dcap *= 1000;
> >>  
> >> -	return ilmd;
> >> +	return dcap;
> >>  }
> >>  
> >>  /*
> >> @@ -344,16 +528,16 @@ static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di)
> >>  {
> >>  	int ae;
> >>  
> >> -	ae = bq27xxx_read(di, BQ27x00_REG_AE, false);
> >> +	ae = bq27xxx_read(di, BQ27XXX_REG_AE, false);
> >>  	if (ae < 0) {
> >>  		dev_dbg(di->dev, "error reading available energy\n");
> >>  		return ae;
> >>  	}
> >>  
> >> -	if (di->chip == BQ27500)
> >> -		ae *= 1000;
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> >> +		ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS;
> >>  	else
> >> -		ae = ae * 29200 / BQ27XXX_RS;
> >> +		ae *= 1000;
> >>  
> >>  	return ae;
> >>  }
> >> @@ -366,13 +550,13 @@ static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di)
> >>  {
> >>  	int temp;
> >>  
> >> -	temp = bq27xxx_read(di, BQ27x00_REG_TEMP, false);
> >> +	temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false);
> >>  	if (temp < 0) {
> >>  		dev_err(di->dev, "error reading temperature\n");
> >>  		return temp;
> >>  	}
> >>  
> >> -	if (!bq27xxx_is_chip_version_higher(di))
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> >>  		temp = 5 * temp / 2;
> >>  
> >>  	return temp;
> >> @@ -386,10 +570,7 @@ static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di)
> >>  {
> >>  	int cyct;
> >>  
> >> -	if (di->chip == BQ27510)
> >> -		cyct = bq27xxx_read(di, BQ27510_REG_CYCT, false);
> >> -	else
> >> -		cyct = bq27xxx_read(di, BQ27x00_REG_CYCT, false);
> >> +	cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false);
> >>  	if (cyct < 0)
> >>  		dev_err(di->dev, "error reading cycle count total\n");
> >>  
> >> @@ -421,21 +602,32 @@ static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg)
> >>   * Read an average power register.
> >>   * Return < 0 if something fails.
> >>   */
> >> -static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
> >> +static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
> >>  {
> >>  	int tval;
> >>  
> >> -	tval = bq27xxx_read(di, reg, false);
> >> +	tval = bq27xxx_read(di, BQ27XXX_REG_AP, false);
> >>  	if (tval < 0) {
> >> -		dev_err(di->dev, "error reading power avg rgister  %02x: %d\n",
> >> -			reg, tval);
> >> +		dev_err(di->dev, "error reading average power register  %02x: %d\n",
> >> +			BQ27XXX_REG_AP, tval);
> >>  		return tval;
> >>  	}
> >>  
> >> -	if (di->chip == BQ27500)
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> >> +		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
> >> +	else
> >>  		return tval;
> >> +}
> >> +
> >> +/*
> >> + * Returns true if a battery over temperature condition is detected
> >> + */
> >> +static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
> >> +{
> >> +	if (di->chip == BQ27500 || di->chip == BQ27541)
> >> +		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
> >>  	else
> >> -		return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS;
> >> +		return flags & BQ27XXX_FLAG_OTC;
> >>  }
> >>  
> >>  /*
> >> @@ -444,53 +636,43 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di, u8 reg)
> >>   */
> >>  static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
> >>  {
> >> -	int tval;
> >> +	u16 tval;
> >>  
> >> -	tval = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
> >> +	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
> >>  	if (tval < 0) {
> >>  		dev_err(di->dev, "error reading flag register:%d\n", tval);
> >>  		return tval;
> >>  	}
> >>  
> >> -	if (di->chip == BQ27500) {
> >> -		if (tval & BQ27500_FLAG_SOCF)
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> >> +		if (tval & BQ27000_FLAG_EDV1)
> >>  			tval = POWER_SUPPLY_HEALTH_DEAD;
> >> -		else if (tval & BQ27500_FLAG_OTC)
> >> -			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
> >>  		else
> >>  			tval = POWER_SUPPLY_HEALTH_GOOD;
> >> -		return tval;
> >> -	} else if (di->chip == BQ27510) {
> >> -		if (tval & BQ27500_FLAG_OTC)
> >> -			return POWER_SUPPLY_HEALTH_OVERHEAT;
> >> -		return POWER_SUPPLY_HEALTH_GOOD;
> >>  	} else {
> >> -		if (tval & BQ27000_FLAG_EDV1)
> >> +		if (tval & BQ27XXX_FLAG_SOCF)
> >>  			tval = POWER_SUPPLY_HEALTH_DEAD;
> >> +		else if (bq27xxx_battery_overtemp(di, tval))
> >> +			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
> >>  		else
> >>  			tval = POWER_SUPPLY_HEALTH_GOOD;
> >> -		return tval;
> >>  	}
> >>  
> >> -	return -1;
> >> +	return tval;
> >>  }
> >>  
> >>  static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
> >>  {
> >>  	struct bq27xxx_reg_cache cache = {0, };
> >> -	bool is_bq27500 = di->chip == BQ27500;
> >> -	bool is_bq27510 = di->chip == BQ27510;
> >> -	bool is_bq27425 = di->chip == BQ27425;
> >> -	bool is_bq27742 = di->chip == BQ27742;
> >> -	bool flags_1b = !(is_bq27500 || is_bq27742);
> >> +	bool has_ci_flag = di->chip == BQ27000 || di->chip == BQ27010;
> >> +	bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010;
> >>  
> >> -	cache.flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, flags_1b);
> >> +	cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag);
> >>  	if ((cache.flags & 0xff) == 0xff)
> >> -		/* read error */
> >> -		cache.flags = -1;
> >> +		cache.flags = -1; /* read error */
> >>  	if (cache.flags >= 0) {
> >> -		if (!is_bq27500 && !is_bq27425 && !is_bq27742 && !is_bq27510
> >> -				&& (cache.flags & BQ27000_FLAG_CI)) {
> >> +		cache.temperature = bq27xxx_battery_read_temperature(di);
> >> +		if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) {
> >>  			dev_info(di->dev, "battery is not calibrated! ignoring capacity values\n");
> >>  			cache.capacity = -ENODATA;
> >>  			cache.energy = -ENODATA;
> >> @@ -500,41 +682,25 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
> >>  			cache.charge_full = -ENODATA;
> >>  			cache.health = -ENODATA;
> >>  		} else {
> >> +			if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR)
> >> +				cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE);
> >> +			if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR)
> >> +				cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP);
> >> +			if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR)
> >> +				cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF);
> >> +			cache.charge_full = bq27xxx_battery_read_fcc(di);
> >>  			cache.capacity = bq27xxx_battery_read_soc(di);
> >> -			if (is_bq27742 || is_bq27510)
> >> -				cache.time_to_empty =
> >> -					bq27xxx_battery_read_time(di,
> >> -							BQ27x00_REG_TTE);
> >> -			else if (!is_bq27425) {
> >> +			if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR)
> >>  				cache.energy = bq27xxx_battery_read_energy(di);
> >> -				cache.time_to_empty =
> >> -					bq27xxx_battery_read_time(di,
> >> -							BQ27x00_REG_TTE);
> >> -				cache.time_to_empty_avg =
> >> -					bq27xxx_battery_read_time(di,
> >> -							BQ27x00_REG_TTECP);
> >> -				cache.time_to_full =
> >> -					bq27xxx_battery_read_time(di,
> >> -							BQ27x00_REG_TTF);
> >> -			}
> >> -			cache.charge_full = bq27xxx_battery_read_lmd(di);
> >>  			cache.health = bq27xxx_battery_read_health(di);
> >>  		}
> >> -		cache.temperature = bq27xxx_battery_read_temperature(di);
> >> -		if (!is_bq27425)
> >> +		if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR)
> >>  			cache.cycle_count = bq27xxx_battery_read_cyct(di);
> >> -		if (is_bq27742)
> >> -			cache.power_avg =
> >> -				bq27xxx_battery_read_pwr_avg(di,
> >> -						BQ27742_POWER_AVG);
> >> -		else
> >> -			cache.power_avg =
> >> -				bq27xxx_battery_read_pwr_avg(di,
> >> -						BQ27x00_POWER_AVG);
> >> +		cache.power_avg = bq27xxx_battery_read_pwr_avg(di);
> >>  
> >>  		/* We only have to read charge design full once */
> >>  		if (di->charge_design_full <= 0)
> >> -			di->charge_design_full = bq27xxx_battery_read_ilmd(di);
> >> +			di->charge_design_full = bq27xxx_battery_read_dcap(di);
> >>  	}
> >>  
> >>  	if (di->cache.capacity != cache.capacity)
> >> @@ -549,7 +715,8 @@ static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
> >>  static void bq27xxx_battery_poll(struct work_struct *work)
> >>  {
> >>  	struct bq27xxx_device_info *di =
> >> -		container_of(work, struct bq27xxx_device_info, work.work);
> >> +			container_of(work, struct bq27xxx_device_info,
> >> +				     work.work);
> >>  
> >>  	bq27xxx_battery_update(di);
> >>  
> >> @@ -571,23 +738,23 @@ static int bq27xxx_battery_current(struct bq27xxx_device_info *di,
> >>  	int curr;
> >>  	int flags;
> >>  
> >> -	curr = bq27xxx_read(di, BQ27x00_REG_AI, false);
> >> +	curr = bq27xxx_read(di, BQ27XXX_REG_AI, false);
> >>  	if (curr < 0) {
> >>  		dev_err(di->dev, "error reading current\n");
> >>  		return curr;
> >>  	}
> >>  
> >> -	if (bq27xxx_is_chip_version_higher(di)) {
> >> -		/* bq27500 returns signed value */
> >> -		val->intval = (int)((s16)curr) * 1000;
> >> -	} else {
> >> -		flags = bq27xxx_read(di, BQ27x00_REG_FLAGS, false);
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> >> +		flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
> >>  		if (flags & BQ27000_FLAG_CHGS) {
> >>  			dev_dbg(di->dev, "negative current!\n");
> >>  			curr = -curr;
> >>  		}
> >>  
> >> -		val->intval = curr * 3570 / BQ27XXX_RS;
> >> +		val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS;
> >> +	} else {
> >> +		/* Other gauges return signed value */
> >> +		val->intval = (int)((s16)curr) * 1000;
> >>  	}
> >>  
> >>  	return 0;
> >> @@ -598,14 +765,7 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
> >>  {
> >>  	int status;
> >>  
> >> -	if (bq27xxx_is_chip_version_higher(di)) {
> >> -		if (di->cache.flags & BQ27500_FLAG_FC)
> >> -			status = POWER_SUPPLY_STATUS_FULL;
> >> -		else if (di->cache.flags & BQ27500_FLAG_DSC)
> >> -			status = POWER_SUPPLY_STATUS_DISCHARGING;
> >> -		else
> >> -			status = POWER_SUPPLY_STATUS_CHARGING;
> >> -	} else {
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> >>  		if (di->cache.flags & BQ27000_FLAG_FC)
> >>  			status = POWER_SUPPLY_STATUS_FULL;
> >>  		else if (di->cache.flags & BQ27000_FLAG_CHGS)
> >> @@ -614,6 +774,13 @@ static int bq27xxx_battery_status(struct bq27xxx_device_info *di,
> >>  			status = POWER_SUPPLY_STATUS_NOT_CHARGING;
> >>  		else
> >>  			status = POWER_SUPPLY_STATUS_DISCHARGING;
> >> +	} else {
> >> +		if (di->cache.flags & BQ27XXX_FLAG_FC)
> >> +			status = POWER_SUPPLY_STATUS_FULL;
> >> +		else if (di->cache.flags & BQ27XXX_FLAG_DSC)
> >> +			status = POWER_SUPPLY_STATUS_DISCHARGING;
> >> +		else
> >> +			status = POWER_SUPPLY_STATUS_CHARGING;
> >>  	}
> >>  
> >>  	val->intval = status;
> >> @@ -626,21 +793,21 @@ static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di,
> >>  {
> >>  	int level;
> >>  
> >> -	if (bq27xxx_is_chip_version_higher(di)) {
> >> -		if (di->cache.flags & BQ27500_FLAG_FC)
> >> +	if (di->chip == BQ27000 || di->chip == BQ27010) {
> >> +		if (di->cache.flags & BQ27000_FLAG_FC)
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
> >> -		else if (di->cache.flags & BQ27500_FLAG_SOC1)
> >> +		else if (di->cache.flags & BQ27000_FLAG_EDV1)
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
> >> -		else if (di->cache.flags & BQ27500_FLAG_SOCF)
> >> +		else if (di->cache.flags & BQ27000_FLAG_EDVF)
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
> >>  		else
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
> >>  	} else {
> >> -		if (di->cache.flags & BQ27000_FLAG_FC)
> >> +		if (di->cache.flags & BQ27XXX_FLAG_FC)
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
> >> -		else if (di->cache.flags & BQ27000_FLAG_EDV1)
> >> +		else if (di->cache.flags & BQ27XXX_FLAG_SOC1)
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
> >> -		else if (di->cache.flags & BQ27000_FLAG_EDVF)
> >> +		else if (di->cache.flags & BQ27XXX_FLAG_SOCF)
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
> >>  		else
> >>  			level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
> >> @@ -660,7 +827,7 @@ static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di,
> >>  {
> >>  	int volt;
> >>  
> >> -	volt = bq27xxx_read(di, BQ27x00_REG_VOLT, false);
> >> +	volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false);
> >>  	if (volt < 0) {
> >>  		dev_err(di->dev, "error reading voltage\n");
> >>  		return volt;
> >> @@ -721,7 +888,7 @@ static int bq27xxx_battery_get_property(struct power_supply *psy,
> >>  	case POWER_SUPPLY_PROP_TEMP:
> >>  		ret = bq27xxx_simple_value(di->cache.temperature, val);
> >>  		if (ret == 0)
> >> -			val->intval -= 2731;
> >> +			val->intval -= 2731; /* convert decidegree k to c */
> >>  		break;
> >>  	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
> >>  		ret = bq27xxx_simple_value(di->cache.time_to_empty, val);
> >> @@ -787,18 +954,27 @@ static int bq27xxx_powersupply_init(struct bq27xxx_device_info *di,
> >>  
> >>  	psy_desc->name = name;
> >>  	psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
> >> -	if (di->chip == BQ27425) {
> >> -		psy_desc->properties = bq27425_battery_props;
> >> -		psy_desc->num_properties = ARRAY_SIZE(bq27425_battery_props);
> >> -	} else if (di->chip == BQ27742) {
> >> -		psy_desc->properties = bq27742_battery_props;
> >> -		psy_desc->num_properties = ARRAY_SIZE(bq27742_battery_props);
> >> -	} else if (di->chip == BQ27510) {
> >> -		psy_desc->properties = bq27510_battery_props;
> >> -		psy_desc->num_properties = ARRAY_SIZE(bq27510_battery_props);
> >> +	if (di->chip == BQ27000) {
> >> +		psy_desc->properties = bq27000_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27000_battery_props);
> >> +	} else if (di->chip == BQ27010) {
> >> +		psy_desc->properties = bq27010_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27010_battery_props);
> >> +	} else if (di->chip == BQ27500) {
> >> +		psy_desc->properties = bq27500_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27500_battery_props);
> >> +	} else if (di->chip == BQ27530) {
> >> +		psy_desc->properties = bq27530_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27530_battery_props);
> >> +	} else if (di->chip == BQ27541) {
> >> +		psy_desc->properties = bq27541_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27541_battery_props);
> >> +	} else if (di->chip == BQ27545) {
> >> +		psy_desc->properties = bq27545_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27545_battery_props);
> >>  	} else {
> >> -		psy_desc->properties = bq27x00_battery_props;
> >> -		psy_desc->num_properties = ARRAY_SIZE(bq27x00_battery_props);
> >> +		psy_desc->properties = bq27421_battery_props;
> >> +		psy_desc->num_properties = ARRAY_SIZE(bq27421_battery_props);
> >>  	}
> >>  	psy_desc->get_property = bq27xxx_battery_get_property;
> >>  	psy_desc->external_power_changed = bq27xxx_external_power_changed;
> >> @@ -913,10 +1089,32 @@ static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
> >>  	di->chip = id->driver_data;
> >>  	di->bus.read = &bq27xxx_battery_i2c_read;
> >>  
> >> +	if (di->chip == BQ27000) {
> >> +		di->regs = bq27000_regs;
> >> +	} else if (di->chip == BQ27010) {
> >> +		di->regs = bq27010_regs;
> >> +	} else if (di->chip == BQ27500) {
> >> +		di->regs = bq27500_regs;
> >> +	} else if (di->chip == BQ27530) {
> >> +		di->regs = bq27530_regs;
> >> +	} else if (di->chip == BQ27541) {
> >> +		di->regs = bq27541_regs;
> >> +	} else if (di->chip == BQ27545) {
> >> +		di->regs = bq27545_regs;
> >> +	} else if (di->chip == BQ27421) {
> >> +		di->regs = bq27421_regs;
> >> +	} else {
> >> +		dev_err(&client->dev, "Unexpected gas gauge: %d\n", di->chip);
> >> +		di->regs = bq27000_regs;
> >> +	}
> >> +
> >>  	retval = bq27xxx_powersupply_init(di, name);
> >>  	if (retval)
> >>  		goto batt_failed;
> >>  
> >> +	/* Schedule a polling after about 1 min */
> >> +	schedule_delayed_work(&di->work, 60 * HZ);
> >> +
> >>  	i2c_set_clientdata(client, di);
> >>  
> >>  	return 0;
> >> @@ -943,11 +1141,13 @@ static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
> >>  }
> >>  
> >>  static const struct i2c_device_id bq27xxx_id[] = {
> >> -	{ "bq27200", BQ27000 },	/* bq27200 is same as bq27000, but with i2c */
> >> +	{ "bq27000", BQ27000 },
> > 
> > I2C version is bq27200, HDQ is bq27000. So here in struct i2c_device_id
> > is needed bq27200.
> > 
> > Also existing kernel code depends on it (git grep bq27200).
> > 
> 
> My bad, I'll fix it.
> 
> >> +	{ "bq27010", BQ27010 },
> >>  	{ "bq27500", BQ27500 },
> >> -	{ "bq27425", BQ27425 },
> >> -	{ "bq27742", BQ27742 },
> >> -	{ "bq27510", BQ27510 },
> >> +	{ "bq27530", BQ27530 },
> >> +	{ "bq27541", BQ27541 },
> >> +	{ "bq27545", BQ27545 },
> >> +	{ "bq27421", BQ27421 },
> > 
> > Why you removed support for bq27425, bq27742 and bq27510?
> > 
> 
> I merged devices into families so they are still supported under the more
> generic family ID, so I'll re-add the devices here.
> 

Yes, devices are needed to be in this table.

> Thanks,
> Andrew F. Davis
> 
> >>  	{},
> >>  };
> >>  MODULE_DEVICE_TABLE(i2c, bq27xxx_id);
> > 
> 

-- 
Pali Rohár
pali.rohar@gmail.com

[PATCH 8/8] power: bq27xxx_battery: Cleanup health checking

[Andrew F. Davis]

Reorganize the logic checking battery health and under temperature
condition checking.

Signed-off-by: Andrew F. Davis <afd@ti.com>
---
 drivers/power/bq27xxx_battery.c | 62 +++++++++++++++++++++++++++--------------
 1 file changed, 41 insertions(+), 21 deletions(-)

diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
index f148222..6775f65 100644
--- a/drivers/power/bq27xxx_battery.c
+++ b/drivers/power/bq27xxx_battery.c
@@ -54,6 +54,8 @@
 #define BQ27XXX_FLAG_FC		BIT(9)
 #define BQ27XXX_FLAG_OTD	BIT(14)
 #define BQ27XXX_FLAG_OTC	BIT(15)
+#define BQ27XXX_FLAG_UT		BIT(14)
+#define BQ27XXX_FLAG_OT		BIT(15)
 
 /* BQ27000 has different layout for Flags register */
 #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
@@ -624,10 +626,34 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
  */
 static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
 {
-	if (di->chip == BQ27500 || di->chip == BQ27541)
+	if (di->chip == BQ27500 || di->chip == BQ27541 || di->chip == BQ27545)
 		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
+	if (di->chip == BQ27530 || di->chip == BQ27421)
+		return flags & BQ27XXX_FLAG_OT;
+
+	return false;
+}
+
+/*
+ * Returns true if a battery under temperature condition is detected
+ */
+static int bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
+{
+	if (di->chip == BQ27530 || di->chip == BQ27421)
+			return flags & BQ27XXX_FLAG_UT;
+
+	return false;
+}
+
+/*
+ * Returns true if a low state of charge condition is detected
+ */
+static int bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
+{
+	if (di->chip == BQ27000 || di->chip == BQ27010)
+		return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
 	else
-		return flags & BQ27XXX_FLAG_OTC;
+		return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
 }
 
 /*
@@ -636,29 +662,23 @@ static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
  */
 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
 {
-	u16 tval;
+	u16 flags;
 
-	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
-	if (tval < 0) {
-		dev_err(di->dev, "error reading flag register:%d\n", tval);
-		return tval;
+	flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
+	if (flags < 0) {
+		dev_err(di->dev, "error reading flag register:%d\n", flags);
+		return flags;
 	}
 
-	if (di->chip == BQ27000 || di->chip == BQ27010) {
-		if (tval & BQ27000_FLAG_EDV1)
-			tval = POWER_SUPPLY_HEALTH_DEAD;
-		else
-			tval = POWER_SUPPLY_HEALTH_GOOD;
-	} else {
-		if (tval & BQ27XXX_FLAG_SOCF)
-			tval = POWER_SUPPLY_HEALTH_DEAD;
-		else if (bq27xxx_battery_overtemp(di, tval))
-			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
-		else
-			tval = POWER_SUPPLY_HEALTH_GOOD;
-	}
+	/* Unlikely but important to return first */
+	if (bq27xxx_battery_overtemp(di, flags))
+		return POWER_SUPPLY_HEALTH_OVERHEAT;
+	if (bq27xxx_battery_undertemp(di, flags))
+		return POWER_SUPPLY_HEALTH_COLD;
+	if (bq27xxx_battery_dead(di, flags))
+		return POWER_SUPPLY_HEALTH_DEAD;
 
-	return tval;
+	return POWER_SUPPLY_HEALTH_GOOD;
 }
 
 static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
-- 
1.9.1

Re: [PATCH 8/8] power: bq27xxx_battery: Cleanup health checking

[Pali Rohár]

On Wednesday 22 July 2015 16:52:00 Andrew F. Davis wrote:
> Reorganize the logic checking battery health and under temperature
> condition checking.
> 
> Signed-off-by: Andrew F. Davis <afd@ti.com>
> ---
>  drivers/power/bq27xxx_battery.c | 62 +++++++++++++++++++++++++++--------------
>  1 file changed, 41 insertions(+), 21 deletions(-)
> 
> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
> index f148222..6775f65 100644
> --- a/drivers/power/bq27xxx_battery.c
> +++ b/drivers/power/bq27xxx_battery.c
> @@ -54,6 +54,8 @@
>  #define BQ27XXX_FLAG_FC		BIT(9)
>  #define BQ27XXX_FLAG_OTD	BIT(14)
>  #define BQ27XXX_FLAG_OTC	BIT(15)
> +#define BQ27XXX_FLAG_UT		BIT(14)
> +#define BQ27XXX_FLAG_OT		BIT(15)
>  
>  /* BQ27000 has different layout for Flags register */
>  #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
> @@ -624,10 +626,34 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
>   */
>  static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
>  {
> -	if (di->chip == BQ27500 || di->chip == BQ27541)
> +	if (di->chip == BQ27500 || di->chip == BQ27541 || di->chip == BQ27545)
>  		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
> +	if (di->chip == BQ27530 || di->chip == BQ27421)
> +		return flags & BQ27XXX_FLAG_OT;
> +
> +	return false;
> +}
> +
> +/*
> + * Returns true if a battery under temperature condition is detected
> + */
> +static int bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
> +{
> +	if (di->chip == BQ27530 || di->chip == BQ27421)
> +			return flags & BQ27XXX_FLAG_UT;
> +
> +	return false;
> +}
> +
> +/*
> + * Returns true if a low state of charge condition is detected
> + */
> +static int bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
> +{
> +	if (di->chip == BQ27000 || di->chip == BQ27010)
> +		return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
>  	else
> -		return flags & BQ27XXX_FLAG_OTC;
> +		return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
>  }
>  
>  /*
> @@ -636,29 +662,23 @@ static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
>   */
>  static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
>  {
> -	u16 tval;
> +	u16 flags;
>  
> -	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
> -	if (tval < 0) {
> -		dev_err(di->dev, "error reading flag register:%d\n", tval);
> -		return tval;
> +	flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
> +	if (flags < 0) {
> +		dev_err(di->dev, "error reading flag register:%d\n", flags);
> +		return flags;
>  	}
>  
> -	if (di->chip == BQ27000 || di->chip == BQ27010) {
> -		if (tval & BQ27000_FLAG_EDV1)
> -			tval = POWER_SUPPLY_HEALTH_DEAD;
> -		else
> -			tval = POWER_SUPPLY_HEALTH_GOOD;
> -	} else {
> -		if (tval & BQ27XXX_FLAG_SOCF)
> -			tval = POWER_SUPPLY_HEALTH_DEAD;
> -		else if (bq27xxx_battery_overtemp(di, tval))
> -			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
> -		else
> -			tval = POWER_SUPPLY_HEALTH_GOOD;
> -	}
> +	/* Unlikely but important to return first */
> +	if (bq27xxx_battery_overtemp(di, flags))
> +		return POWER_SUPPLY_HEALTH_OVERHEAT;
> +	if (bq27xxx_battery_undertemp(di, flags))
> +		return POWER_SUPPLY_HEALTH_COLD;
> +	if (bq27xxx_battery_dead(di, flags))
> +		return POWER_SUPPLY_HEALTH_DEAD;

Good candidates for "if (unlikely(...))" ?

>  
> -	return tval;
> +	return POWER_SUPPLY_HEALTH_GOOD;
>  }
>  
>  static void bq27xxx_battery_update(struct bq27xxx_device_info *di)

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 8/8] power: bq27xxx_battery: Cleanup health checking

[Joe Perches]

On Thu, 2015-07-23 at 18:22 +0200, Pali Rohár wrote:
> On Wednesday 22 July 2015 16:52:00 Andrew F. Davis wrote:
> > Reorganize the logic checking battery health and under temperature
> > condition checking.
[]
> > diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
[]
> > @@ -624,10 +626,34 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
> >   */
> >  static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
> >  {
> > -	if (di->chip == BQ27500 || di->chip == BQ27541)
> > +	if (di->chip == BQ27500 || di->chip == BQ27541 || di->chip == BQ27545)
> >  		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
> > +	if (di->chip == BQ27530 || di->chip == BQ27421)
> > +		return flags & BQ27XXX_FLAG_OT;
> > +
> > +	return false;

Maybe this int function should be bool or return 0
instead of false.

> > +static int bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
> > +{
> > +	if (di->chip == BQ27530 || di->chip == BQ27421)
> > +			return flags & BQ27XXX_FLAG_UT;
> > +
> > +	return false;
> > +}

Here too

> > +
> > +/*
> > + * Returns true if a low state of charge condition is detected
> > + */
> > +static int bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
> > +{
> > +	if (di->chip == BQ27000 || di->chip == BQ27010)
> > +		return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
> >  	else
> > -		return flags & BQ27XXX_FLAG_OTC;
> > +		return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
> >  }

and here

Re: [PATCH 8/8] power: bq27xxx_battery: Cleanup health checking

[Andrew F. Davis]

On 07/23/2015 12:06 PM, Joe Perches wrote:
> On Thu, 2015-07-23 at 18:22 +0200, Pali Rohár wrote:
>> On Wednesday 22 July 2015 16:52:00 Andrew F. Davis wrote:
>>> Reorganize the logic checking battery health and under temperature
>>> condition checking.
> []
>>> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
> []
>>> @@ -624,10 +626,34 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
>>>   */
>>>  static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
>>>  {
>>> -	if (di->chip == BQ27500 || di->chip == BQ27541)
>>> +	if (di->chip == BQ27500 || di->chip == BQ27541 || di->chip == BQ27545)
>>>  		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
>>> +	if (di->chip == BQ27530 || di->chip == BQ27421)
>>> +		return flags & BQ27XXX_FLAG_OT;
>>> +
>>> +	return false;
> 
> Maybe this int function should be bool or return 0
> instead of false.
> 
>>> +static int bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
>>> +{
>>> +	if (di->chip == BQ27530 || di->chip == BQ27421)
>>> +			return flags & BQ27XXX_FLAG_UT;
>>> +
>>> +	return false;
>>> +}
> 
> Here too
> 
>>> +
>>> +/*
>>> + * Returns true if a low state of charge condition is detected
>>> + */
>>> +static int bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
>>> +{
>>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>>> +		return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
>>>  	else
>>> -		return flags & BQ27XXX_FLAG_OTC;
>>> +		return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
>>>  }
> 
> and here
> 
> 

I think I'll change the return to bool as these functions are only used in an if
statement checking for true/false.

Thanks,
Andrew

Re: [PATCH 8/8] power: bq27xxx_battery: Cleanup health checking

[Andrew F. Davis]

On 07/23/2015 11:22 AM, Pali Rohár wrote:
> On Wednesday 22 July 2015 16:52:00 Andrew F. Davis wrote:
>> Reorganize the logic checking battery health and under temperature
>> condition checking.
>>
>> Signed-off-by: Andrew F. Davis <afd@ti.com>
>> ---
>>  drivers/power/bq27xxx_battery.c | 62 +++++++++++++++++++++++++++--------------
>>  1 file changed, 41 insertions(+), 21 deletions(-)
>>
>> diff --git a/drivers/power/bq27xxx_battery.c b/drivers/power/bq27xxx_battery.c
>> index f148222..6775f65 100644
>> --- a/drivers/power/bq27xxx_battery.c
>> +++ b/drivers/power/bq27xxx_battery.c
>> @@ -54,6 +54,8 @@
>>  #define BQ27XXX_FLAG_FC		BIT(9)
>>  #define BQ27XXX_FLAG_OTD	BIT(14)
>>  #define BQ27XXX_FLAG_OTC	BIT(15)
>> +#define BQ27XXX_FLAG_UT		BIT(14)
>> +#define BQ27XXX_FLAG_OT		BIT(15)
>>  
>>  /* BQ27000 has different layout for Flags register */
>>  #define BQ27000_FLAG_EDVF	BIT(0) /* Final End-of-Discharge-Voltage flag */
>> @@ -624,10 +626,34 @@ static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di)
>>   */
>>  static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
>>  {
>> -	if (di->chip == BQ27500 || di->chip == BQ27541)
>> +	if (di->chip == BQ27500 || di->chip == BQ27541 || di->chip == BQ27545)
>>  		return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD);
>> +	if (di->chip == BQ27530 || di->chip == BQ27421)
>> +		return flags & BQ27XXX_FLAG_OT;
>> +
>> +	return false;
>> +}
>> +
>> +/*
>> + * Returns true if a battery under temperature condition is detected
>> + */
>> +static int bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags)
>> +{
>> +	if (di->chip == BQ27530 || di->chip == BQ27421)
>> +			return flags & BQ27XXX_FLAG_UT;
>> +
>> +	return false;
>> +}
>> +
>> +/*
>> + * Returns true if a low state of charge condition is detected
>> + */
>> +static int bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags)
>> +{
>> +	if (di->chip == BQ27000 || di->chip == BQ27010)
>> +		return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF);
>>  	else
>> -		return flags & BQ27XXX_FLAG_OTC;
>> +		return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF);
>>  }
>>  
>>  /*
>> @@ -636,29 +662,23 @@ static int bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags)
>>   */
>>  static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di)
>>  {
>> -	u16 tval;
>> +	u16 flags;
>>  
>> -	tval = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
>> -	if (tval < 0) {
>> -		dev_err(di->dev, "error reading flag register:%d\n", tval);
>> -		return tval;
>> +	flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, false);
>> +	if (flags < 0) {
>> +		dev_err(di->dev, "error reading flag register:%d\n", flags);
>> +		return flags;
>>  	}
>>  
>> -	if (di->chip == BQ27000 || di->chip == BQ27010) {
>> -		if (tval & BQ27000_FLAG_EDV1)
>> -			tval = POWER_SUPPLY_HEALTH_DEAD;
>> -		else
>> -			tval = POWER_SUPPLY_HEALTH_GOOD;
>> -	} else {
>> -		if (tval & BQ27XXX_FLAG_SOCF)
>> -			tval = POWER_SUPPLY_HEALTH_DEAD;
>> -		else if (bq27xxx_battery_overtemp(di, tval))
>> -			tval = POWER_SUPPLY_HEALTH_OVERHEAT;
>> -		else
>> -			tval = POWER_SUPPLY_HEALTH_GOOD;
>> -	}
>> +	/* Unlikely but important to return first */
>> +	if (bq27xxx_battery_overtemp(di, flags))
>> +		return POWER_SUPPLY_HEALTH_OVERHEAT;
>> +	if (bq27xxx_battery_undertemp(di, flags))
>> +		return POWER_SUPPLY_HEALTH_COLD;
>> +	if (bq27xxx_battery_dead(di, flags))
>> +		return POWER_SUPPLY_HEALTH_DEAD;
> 
> Good candidates for "if (unlikely(...))" ?
> 

I wasn't sure, but I don't see why not. Added.

Thanks,
Andrew

>>  
>> -	return tval;
>> +	return POWER_SUPPLY_HEALTH_GOOD;
>>  }
>>  
>>  static void bq27xxx_battery_update(struct bq27xxx_device_info *di)
> 

Re: [PATCH 8/8] power: bq27xxx_battery: Cleanup health checking

[Pali Rohár]

[-- Attachment #1: Type: Text/Plain, Size: 743 bytes --]

On Friday 24 July 2015 22:27:39 Andrew F. Davis wrote:
> On 07/23/2015 11:22 AM, Pali Rohár wrote:
> > On Wednesday 22 July 2015 16:52:00 Andrew F. Davis wrote:
> >> +	/* Unlikely but important to return first */
> >> +	if (bq27xxx_battery_overtemp(di, flags))
> >> +		return POWER_SUPPLY_HEALTH_OVERHEAT;
> >> +	if (bq27xxx_battery_undertemp(di, flags))
> >> +		return POWER_SUPPLY_HEALTH_COLD;
> >> +	if (bq27xxx_battery_dead(di, flags))
> >> +		return POWER_SUPPLY_HEALTH_DEAD;
> > 
> > Good candidates for "if (unlikely(...))" ?
> 
> I wasn't sure, but I don't see why not. Added.
> 

You wrote "Unlikely" in comment, so I thought that unlikely macro sounds 
reasonable here...

-- 
Pali Rohár
pali.rohar@gmail.com

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: [PATCH 0/8] Add support for additional bq27xxx devices

[Pali Rohár]

On Wednesday 22 July 2015 16:51:52 Andrew F. Davis wrote:
> This series adds support for several additional bq27xxx devices and 
> makes a few related fixes.
> 

Thanks for some cleanup of bq27xxx battery driver! Did you tested your
patches? On which devices (with which bq chips)?

And I have another question for you: I see that there are now more
bq24*_charger.c drivers for TI BQ charger chips. Do you think if it is
possible to do some cleanup & merge? Or all those charger chips
different and every one should live in own kernel module?

-- 
Pali Rohár
pali.rohar@gmail.com

Re: [PATCH 0/8] Add support for additional bq27xxx devices

[Andreas Dannenberg]

On 07/23/2015 11:27 AM, Pali Rohár wrote:
> On Wednesday 22 July 2015 16:51:52 Andrew F. Davis wrote:

<snip>

> And I have another question for you: I see that there are now more
> bq24*_charger.c drivers for TI BQ charger chips. Do you think if it is
> possible to do some cleanup & merge? Or all those charger chips
> different and every one should live in own kernel module?
 
Pali,
on a related note I recently started working on a new driver named
bq242xx_charger.c that will add support for the following devices:

bq24250
bq24251
bq24261M
bq24262

These are TI's key devices in the bq2425x and bq2426x sub-families. I was
actually also thinking about some larger consolidation but was
concerned about touching/breaking existing stuff and decided to do one
step at a time. And yes while there is some system-level overlap between
most bq24xxx I'm also worried that providing good coverage of all
important device features for all different bq24xxx devices would yield
a very large and hard to understand driver.

As part of the bq242xx_charger.c development I'm keeping a close eye on
the existing bq24xxx drivers. If there seems an elegant way to do some
consolidation after all I might be able to broaden the scope of my work.

This being said I welcome additional ideas/suggestions here but for this
we should probably start a new thread.

Regards,

-- 
Andreas Dannenberg
Texas Instruments Inc.

Re: [PATCH 0/8] Add support for additional bq27xxx devices

[Andrew F. Davis]

On 07/23/2015 11:27 AM, Pali Rohár wrote:
> On Wednesday 22 July 2015 16:51:52 Andrew F. Davis wrote:
>> This series adds support for several additional bq27xxx devices and 
>> makes a few related fixes.
>>
> 
> Thanks for some cleanup of bq27xxx battery driver! Did you tested your
> patches? On which devices (with which bq chips)?
> 

I have verified basic functionality on the bq27421, bq27425, bq27441,
bq27520, bq27530, and the bq27531.

Thanks,
Andrew