bq27x00_battery: Add support for BQ27425 chip

This patch adds support for BQ27425 (TI) chip. This chip is same as
BQ27500 with few registers removed and register address map changed.
The data sheet for this chip is publicly available at
 http://www.ti.com/product/bq27425-g1

Signed-off-by: Saranya Gopal <saranya.gopal@intel.com>
Reviewed-by: Lars-Peter Clausen <lars@metafoo.de>
Signed-off-by: Anton Vorontsov <anton.vorontsov@linaro.org>

1 files changed, 69 insertions, 15 deletions

diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c
index 5657990b7ace..181ddece5181 100644
--- a/drivers/power/bq27x00_battery.c
+++ b/drivers/power/bq27x00_battery.c
@@ -22,6 +22,7 @@
  * 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/bq27425-g1
  */
 
 #include <linux/module.h>
@@ -69,6 +70,10 @@
 #define BQ27500_FLAG_FC                 BIT(9)
 #define BQ27500_FLAG_OTC                BIT(15)
 
+/* bq27425 register addresses are same as bq27x00 addresses minus 4 */
+#define BQ27425_REG_OFFSET              0x04
+#define BQ27425_REG_SOC                 0x18 /* Register address plus offset */
+
 #define BQ27000_RS                      20 /* Resistor sense */
 #define BQ27x00_POWER_CONSTANT          (256 * 29200 / 1000)
 
@@ -77,7 +82,7 @@ struct bq27x00_access_methods {
         int (*read)(struct bq27x00_device_info *di, u8 reg, bool single);
 };
 
-enum bq27x00_chip { BQ27000, BQ27500 };
+enum bq27x00_chip { BQ27000, BQ27500, BQ27425};
 
 struct bq27x00_reg_cache {
         int temperature;
@@ -132,6 +137,20 @@ static enum power_supply_property bq27x00_battery_props[] = {
         POWER_SUPPLY_PROP_HEALTH,
 };
 
+static enum power_supply_property bq27425_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,
+};
+
 static unsigned int poll_interval = 360;
 module_param(poll_interval, uint, 0644);
 MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
@@ -144,10 +163,24 @@ MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \
 static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg,
                 bool single)
 {
+        if (di->chip == BQ27425)
+                return di->bus.read(di, reg - BQ27425_REG_OFFSET, single);
         return di->bus.read(di, reg, single);
 }
 
 /*
+ * 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 bq27x00_device_info *di)
+{
+        if (di->chip == BQ27425 || di->chip == BQ27500)
+                return true;
+        return false;
+}
+
+/*
  * Return the battery Relative State-of-Charge
  * Or < 0 if something fails.
  */
@@ -157,6 +190,8 @@ static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di)
 
         if (di->chip == BQ27500)
                 rsoc = bq27x00_read(di, BQ27500_REG_SOC, false);
+        else if (di->chip == BQ27425)
+                rsoc = bq27x00_read(di, BQ27425_REG_SOC, false);
         else
                 rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true);
 
@@ -181,7 +216,7 @@ static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg)
                 return charge;
         }
 
-        if (di->chip == BQ27500)
+        if (bq27xxx_is_chip_version_higher(di))
                 charge *= 1000;
         else
                 charge = charge * 3570 / BQ27000_RS;
@@ -215,7 +250,7 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
 {
         int ilmd;
 
-        if (di->chip == BQ27500)
+        if (bq27xxx_is_chip_version_higher(di))
                 ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false);
         else
                 ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true);
@@ -225,7 +260,7 @@ static int bq27x00_battery_read_ilmd(struct bq27x00_device_info *di)
                 return ilmd;
         }
 
-        if (di->chip == BQ27500)
+        if (bq27xxx_is_chip_version_higher(di))
                 ilmd *= 1000;
         else
                 ilmd = ilmd * 256 * 3570 / BQ27000_RS;
@@ -269,7 +304,7 @@ static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di)
                 return temp;
         }
 
-        if (di->chip == BQ27500)
+        if (bq27xxx_is_chip_version_higher(di))
                 temp -= 2731;
         else
                 temp = ((temp * 5) - 5463) / 2;
@@ -371,10 +406,12 @@ static void bq27x00_update(struct bq27x00_device_info *di)
 {
         struct bq27x00_reg_cache cache = {0, };
         bool is_bq27500 = di->chip == BQ27500;
+        bool is_bq27425 = di->chip == BQ27425;
 
         cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, !is_bq27500);
         if (cache.flags >= 0) {
-                if (!is_bq27500 && (cache.flags & BQ27000_FLAG_CI)) {
+                if (!is_bq27500 && !is_bq27425
+                                && (cache.flags & BQ27000_FLAG_CI)) {
                         dev_info(di->dev, "battery is not calibrated! ignoring capacity values\n");
                         cache.capacity = -ENODATA;
                         cache.energy = -ENODATA;
@@ -385,14 +422,24 @@ static void bq27x00_update(struct bq27x00_device_info *di)
                         cache.health = -ENODATA;
                 } else {
                         cache.capacity = bq27x00_battery_read_rsoc(di);
-                        cache.energy = bq27x00_battery_read_energy(di);
-                        cache.time_to_empty = bq27x00_battery_read_time(di, BQ27x00_REG_TTE);
-                        cache.time_to_empty_avg = bq27x00_battery_read_time(di, BQ27x00_REG_TTECP);
-                        cache.time_to_full = bq27x00_battery_read_time(di, BQ27x00_REG_TTF);
+                        if (!is_bq27425) {
+                                cache.energy = bq27x00_battery_read_energy(di);
+                                cache.time_to_empty =
+                                        bq27x00_battery_read_time(di,
+                                                        BQ27x00_REG_TTE);
+                                cache.time_to_empty_avg =
+                                        bq27x00_battery_read_time(di,
+                                                        BQ27x00_REG_TTECP);
+                                cache.time_to_full =
+                                        bq27x00_battery_read_time(di,
+                                                        BQ27x00_REG_TTF);
+                        }
                         cache.charge_full = bq27x00_battery_read_lmd(di);
                         cache.health = bq27x00_battery_read_health(di);
                 }
                 cache.temperature = bq27x00_battery_read_temperature(di);
+                if (!is_bq27425)
+                        cache.cycle_count = bq27x00_battery_read_cyct(di);
                 cache.cycle_count = bq27x00_battery_read_cyct(di);
                 cache.power_avg =
                         bq27x00_battery_read_pwr_avg(di, BQ27x00_POWER_AVG);
@@ -441,7 +488,7 @@ static int bq27x00_battery_current(struct bq27x00_device_info *di,
                 return curr;
         }
 
-        if (di->chip == BQ27500) {
+        if (bq27xxx_is_chip_version_higher(di)) {
                 /* bq27500 returns signed value */
                 val->intval = (int)((s16)curr) * 1000;
         } else {
@@ -462,7 +509,7 @@ static int bq27x00_battery_status(struct bq27x00_device_info *di,
 {
         int status;
 
-        if (di->chip == BQ27500) {
+        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)
@@ -490,7 +537,7 @@ static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di,
 {
         int level;
 
-        if (di->chip == BQ27500) {
+        if (bq27xxx_is_chip_version_higher(di)) {
                 if (di->cache.flags & BQ27500_FLAG_FC)
                         level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
                 else if (di->cache.flags & BQ27500_FLAG_SOC1)
@@ -641,8 +688,14 @@ static int bq27x00_powersupply_init(struct bq27x00_device_info *di)
         int ret;
 
         di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
-        di->bat.properties = bq27x00_battery_props;
-        di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
+        di->chip = BQ27425;
+        if (di->chip == BQ27425) {
+                di->bat.properties = bq27425_battery_props;
+                di->bat.num_properties = ARRAY_SIZE(bq27425_battery_props);
+        } else {
+                di->bat.properties = bq27x00_battery_props;
+                di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
+        }
         di->bat.get_property = bq27x00_battery_get_property;
         di->bat.external_power_changed = bq27x00_external_power_changed;
 
@@ -800,6 +853,7 @@ static int bq27x00_battery_remove(struct i2c_client *client)
 static const struct i2c_device_id bq27x00_id[] = {
         { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */
         { "bq27500", BQ27500 },
+        { "bq27425", BQ27425 },
         {},
 };
 MODULE_DEVICE_TABLE(i2c, bq27x00_id);