diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index fa9b1d1..07112b1 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -395,7 +395,7 @@ config CHARGER_BQ24190
 	help
 	  Say Y to enable support for the TI BQ24190 battery charger.
 
-config CHARGER_BQ24257
+config CHARGER_BQ2425X
 	tristate "TI BQ2425x battery charger driver"
 	depends on I2C && GPIOLIB
 	depends on REGMAP_I2C
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 5752ce8..4aa9048 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -59,7 +59,7 @@ obj-$(CONFIG_CHARGER_MAX8997)	+= max8997_charger.o
 obj-$(CONFIG_CHARGER_MAX8998)	+= max8998_charger.o
 obj-$(CONFIG_CHARGER_BQ2415X)	+= bq2415x_charger.o
 obj-$(CONFIG_CHARGER_BQ24190)	+= bq24190_charger.o
-obj-$(CONFIG_CHARGER_BQ24257)	+= bq24257_charger.o
+obj-$(CONFIG_CHARGER_BQ2425X)	+= bq2425x_charger.o
 obj-$(CONFIG_CHARGER_BQ24735)	+= bq24735-charger.o
 obj-$(CONFIG_CHARGER_BQ25890)	+= bq25890_charger.o
 obj-$(CONFIG_POWER_AVS)		+= avs/
diff --git a/drivers/power/bq24257_charger.c b/drivers/power/bq2425x_charger.c
similarity index 64%
rename from drivers/power/bq24257_charger.c
rename to drivers/power/bq2425x_charger.c
index b5e82ed..3bf30d4 100644
--- a/drivers/power/bq24257_charger.c
+++ b/drivers/power/bq2425x_charger.c
@@ -1,5 +1,5 @@
 /*
- * TI BQ24257 charger driver
+ * TI BQ2425x charger driver
  *
  * Copyright (C) 2015 Intel Corporation
  *
@@ -32,21 +32,21 @@
 #include <linux/acpi.h>
 #include <linux/of.h>
 
-#include <linux/power/bq24257_charger.h>
+#include <linux/power/bq2425x_charger.h>
 
-#define BQ24257_REG_1			0x00
-#define BQ24257_REG_2			0x01
-#define BQ24257_REG_3			0x02
-#define BQ24257_REG_4			0x03
-#define BQ24257_REG_5			0x04
-#define BQ24257_REG_6			0x05
-#define BQ24257_REG_7			0x06
+#define BQ2425X_REG_1			0x00
+#define BQ2425X_REG_2			0x01
+#define BQ2425X_REG_3			0x02
+#define BQ2425X_REG_4			0x03
+#define BQ2425X_REG_5			0x04
+#define BQ2425X_REG_6			0x05
+#define BQ2425X_REG_7			0x06
 
-#define BQ24257_MANUFACTURER		"Texas Instruments"
-#define BQ24257_STAT_IRQ		"stat"
-#define BQ24257_PG_GPIO			"pg"
+#define BQ2425X_MANUFACTURER		"Texas Instruments"
+#define BQ2425X_STAT_IRQ		"stat"
+#define BQ2425X_PG_GPIO			"pg"
 
-#define BQ24257_ILIM_SET_DELAY		1000	/* msec */
+#define BQ2425X_ILIM_SET_DELAY		1000	/* msec */
 
 enum bq2425x_chip {
 	BQ24250,
@@ -60,7 +60,7 @@ static const char *bq2425x_chip_name[] = {
 	"bq24257",
 };
 
-enum bq24257_fields {
+enum bq2425x_fields {
 	F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT,			    /* REG 1 */
 	F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE,  /* REG 2 */
 	F_VBAT, F_USB_DET,					    /* REG 3 */
@@ -73,7 +73,7 @@ enum bq24257_fields {
 };
 
 /* initial field values, converted from uV/uA */
-struct bq24257_init_data {
+struct bq2425x_init_data {
 	u8 ichg;	/* charge current      */
 	u8 vbat;	/* regulation voltage  */
 	u8 iterm;	/* termination current */
@@ -83,13 +83,13 @@ struct bq24257_init_data {
 	bool timer2x_enable;	/* slow down safety timer by 2x */
 };
 
-struct bq24257_state {
+struct bq2425x_state {
 	u8 status;
 	u8 fault;
 	bool power_good;
 };
 
-struct bq24257_device {
+struct bq2425x_device {
 	struct i2c_client *client;
 	struct device *dev;
 	struct power_supply *charger;
@@ -103,8 +103,8 @@ struct bq24257_device {
 
 	struct delayed_work iilimit_setup_work;
 
-	struct bq24257_init_data init_data;
-	struct bq24257_state state;
+	struct bq2425x_init_data init_data;
+	struct bq2425x_state state;
 
 	struct mutex lock; /* protect device access and state data */
 
@@ -112,11 +112,11 @@ struct bq24257_device {
 	bool pg_gpio_disable;
 };
 
-static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg)
+static bool bq2425x_is_volatile_reg(struct device *dev, unsigned int reg)
 {
 	switch (reg) {
-	case BQ24257_REG_2:
-	case BQ24257_REG_4:
+	case BQ2425X_REG_2:
+	case BQ2425X_REG_4:
 		return false;
 
 	default:
@@ -124,55 +124,55 @@ static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg)
 	}
 }
 
-static const struct regmap_config bq24257_regmap_config = {
+static const struct regmap_config bq2425x_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
 
-	.max_register = BQ24257_REG_7,
+	.max_register = BQ2425X_REG_7,
 	.cache_type = REGCACHE_RBTREE,
 
-	.volatile_reg = bq24257_is_volatile_reg,
+	.volatile_reg = bq2425x_is_volatile_reg,
 };
 
-static const struct reg_field bq24257_reg_fields[] = {
+static const struct reg_field bq2425x_reg_fields[] = {
 	/* REG 1 */
-	[F_WD_FAULT]		= REG_FIELD(BQ24257_REG_1, 7, 7),
-	[F_WD_EN]		= REG_FIELD(BQ24257_REG_1, 6, 6),
-	[F_STAT]		= REG_FIELD(BQ24257_REG_1, 4, 5),
-	[F_FAULT]		= REG_FIELD(BQ24257_REG_1, 0, 3),
+	[F_WD_FAULT]		= REG_FIELD(BQ2425X_REG_1, 7, 7),
+	[F_WD_EN]		= REG_FIELD(BQ2425X_REG_1, 6, 6),
+	[F_STAT]		= REG_FIELD(BQ2425X_REG_1, 4, 5),
+	[F_FAULT]		= REG_FIELD(BQ2425X_REG_1, 0, 3),
 	/* REG 2 */
-	[F_RESET]		= REG_FIELD(BQ24257_REG_2, 7, 7),
-	[F_IILIMIT]		= REG_FIELD(BQ24257_REG_2, 4, 6),
-	[F_EN_STAT]		= REG_FIELD(BQ24257_REG_2, 3, 3),
-	[F_EN_TERM]		= REG_FIELD(BQ24257_REG_2, 2, 2),
-	[F_CE]			= REG_FIELD(BQ24257_REG_2, 1, 1),
-	[F_HZ_MODE]		= REG_FIELD(BQ24257_REG_2, 0, 0),
+	[F_RESET]		= REG_FIELD(BQ2425X_REG_2, 7, 7),
+	[F_IILIMIT]		= REG_FIELD(BQ2425X_REG_2, 4, 6),
+	[F_EN_STAT]		= REG_FIELD(BQ2425X_REG_2, 3, 3),
+	[F_EN_TERM]		= REG_FIELD(BQ2425X_REG_2, 2, 2),
+	[F_CE]			= REG_FIELD(BQ2425X_REG_2, 1, 1),
+	[F_HZ_MODE]		= REG_FIELD(BQ2425X_REG_2, 0, 0),
 	/* REG 3 */
-	[F_VBAT]		= REG_FIELD(BQ24257_REG_3, 2, 7),
-	[F_USB_DET]		= REG_FIELD(BQ24257_REG_3, 0, 1),
+	[F_VBAT]		= REG_FIELD(BQ2425X_REG_3, 2, 7),
+	[F_USB_DET]		= REG_FIELD(BQ2425X_REG_3, 0, 1),
 	/* REG 4 */
-	[F_ICHG]		= REG_FIELD(BQ24257_REG_4, 3, 7),
-	[F_ITERM]		= REG_FIELD(BQ24257_REG_4, 0, 2),
+	[F_ICHG]		= REG_FIELD(BQ2425X_REG_4, 3, 7),
+	[F_ITERM]		= REG_FIELD(BQ2425X_REG_4, 0, 2),
 	/* REG 5 */
-	[F_LOOP_STATUS]		= REG_FIELD(BQ24257_REG_5, 6, 7),
-	[F_LOW_CHG]		= REG_FIELD(BQ24257_REG_5, 5, 5),
-	[F_DPDM_EN]		= REG_FIELD(BQ24257_REG_5, 4, 4),
-	[F_CE_STATUS]		= REG_FIELD(BQ24257_REG_5, 3, 3),
-	[F_VINDPM]		= REG_FIELD(BQ24257_REG_5, 0, 2),
+	[F_LOOP_STATUS]		= REG_FIELD(BQ2425X_REG_5, 6, 7),
+	[F_LOW_CHG]		= REG_FIELD(BQ2425X_REG_5, 5, 5),
+	[F_DPDM_EN]		= REG_FIELD(BQ2425X_REG_5, 4, 4),
+	[F_CE_STATUS]		= REG_FIELD(BQ2425X_REG_5, 3, 3),
+	[F_VINDPM]		= REG_FIELD(BQ2425X_REG_5, 0, 2),
 	/* REG 6 */
-	[F_X2_TMR_EN]		= REG_FIELD(BQ24257_REG_6, 7, 7),
-	[F_TMR]			= REG_FIELD(BQ24257_REG_6, 5, 6),
-	[F_SYSOFF]		= REG_FIELD(BQ24257_REG_6, 4, 4),
-	[F_TS_EN]		= REG_FIELD(BQ24257_REG_6, 3, 3),
-	[F_TS_STAT]		= REG_FIELD(BQ24257_REG_6, 0, 2),
+	[F_X2_TMR_EN]		= REG_FIELD(BQ2425X_REG_6, 7, 7),
+	[F_TMR]			= REG_FIELD(BQ2425X_REG_6, 5, 6),
+	[F_SYSOFF]		= REG_FIELD(BQ2425X_REG_6, 4, 4),
+	[F_TS_EN]		= REG_FIELD(BQ2425X_REG_6, 3, 3),
+	[F_TS_STAT]		= REG_FIELD(BQ2425X_REG_6, 0, 2),
 	/* REG 7 */
-	[F_VOVP]		= REG_FIELD(BQ24257_REG_7, 5, 7),
-	[F_CLR_VDP]		= REG_FIELD(BQ24257_REG_7, 4, 4),
-	[F_FORCE_BATDET]	= REG_FIELD(BQ24257_REG_7, 3, 3),
-	[F_FORCE_PTM]		= REG_FIELD(BQ24257_REG_7, 2, 2)
+	[F_VOVP]		= REG_FIELD(BQ2425X_REG_7, 5, 7),
+	[F_CLR_VDP]		= REG_FIELD(BQ2425X_REG_7, 4, 4),
+	[F_FORCE_BATDET]	= REG_FIELD(BQ2425X_REG_7, 3, 3),
+	[F_FORCE_PTM]		= REG_FIELD(BQ2425X_REG_7, 2, 2)
 };
 
-static const u32 bq24257_vbat_map[] = {
+static const u32 bq2425x_vbat_map[] = {
 	3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
 	3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
 	3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
@@ -181,45 +181,45 @@ static const u32 bq24257_vbat_map[] = {
 	4300000, 4320000, 4340000, 4360000, 4380000, 4400000, 4420000, 4440000
 };
 
-#define BQ24257_VBAT_MAP_SIZE		ARRAY_SIZE(bq24257_vbat_map)
+#define BQ2425X_VBAT_MAP_SIZE		ARRAY_SIZE(bq2425x_vbat_map)
 
-static const u32 bq24257_ichg_map[] = {
+static const u32 bq2425x_ichg_map[] = {
 	500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000,
 	950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000,
 	1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
 	1750000, 1800000, 1850000, 1900000, 1950000, 2000000
 };
 
-#define BQ24257_ICHG_MAP_SIZE		ARRAY_SIZE(bq24257_ichg_map)
+#define BQ2425X_ICHG_MAP_SIZE		ARRAY_SIZE(bq2425x_ichg_map)
 
-static const u32 bq24257_iterm_map[] = {
+static const u32 bq2425x_iterm_map[] = {
 	50000, 75000, 100000, 125000, 150000, 175000, 200000, 225000
 };
 
-#define BQ24257_ITERM_MAP_SIZE		ARRAY_SIZE(bq24257_iterm_map)
+#define BQ2425X_ITERM_MAP_SIZE		ARRAY_SIZE(bq2425x_iterm_map)
 
-static const u32 bq24257_iilimit_map[] = {
+static const u32 bq2425x_iilimit_map[] = {
 	100000, 150000, 500000, 900000, 1500000, 2000000
 };
 
-#define BQ24257_IILIMIT_MAP_SIZE	ARRAY_SIZE(bq24257_iilimit_map)
+#define BQ2425X_IILIMIT_MAP_SIZE	ARRAY_SIZE(bq2425x_iilimit_map)
 
-static const u32 bq24257_vovp_map[] = {
+static const u32 bq2425x_vovp_map[] = {
 	6000000, 6500000, 7000000, 8000000, 9000000, 9500000, 10000000,
 	10500000
 };
 
-#define BQ24257_VOVP_MAP_SIZE		ARRAY_SIZE(bq24257_vovp_map)
+#define BQ2425X_VOVP_MAP_SIZE		ARRAY_SIZE(bq2425x_vovp_map)
 
-static const u32 bq24257_vindpm_map[] = {
+static const u32 bq2425x_vindpm_map[] = {
 	4200000, 4280000, 4360000, 4440000, 4520000, 4600000, 4680000,
 	4760000
 };
 
-#define BQ24257_VINDPM_MAP_SIZE		ARRAY_SIZE(bq24257_vindpm_map)
+#define BQ2425X_VINDPM_MAP_SIZE		ARRAY_SIZE(bq2425x_vindpm_map)
 
-static int bq24257_field_read(struct bq24257_device *bq,
-			      enum bq24257_fields field_id)
+static int bq2425x_field_read(struct bq2425x_device *bq,
+			      enum bq2425x_fields field_id)
 {
 	int ret;
 	int val;
@@ -231,13 +231,13 @@ static int bq24257_field_read(struct bq24257_device *bq,
 	return val;
 }
 
-static int bq24257_field_write(struct bq24257_device *bq,
-			       enum bq24257_fields field_id, u8 val)
+static int bq2425x_field_write(struct bq2425x_device *bq,
+			       enum bq2425x_fields field_id, u8 val)
 {
 	return regmap_field_write(bq->rmap_fields[field_id], val);
 }
 
-static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size)
+static u8 bq2425x_find_idx(u32 value, const u32 *map, u8 map_size)
 {
 	u8 idx;
 
@@ -248,14 +248,14 @@ static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size)
 	return idx - 1;
 }
 
-enum bq24257_status {
+enum bq2425x_status {
 	STATUS_READY,
 	STATUS_CHARGE_IN_PROGRESS,
 	STATUS_CHARGE_DONE,
 	STATUS_FAULT,
 };
 
-enum bq24257_fault {
+enum bq2425x_fault {
 	FAULT_NORMAL,
 	FAULT_INPUT_OVP,
 	FAULT_INPUT_UVLO,
@@ -269,12 +269,12 @@ enum bq24257_fault {
 	FAULT_INPUT_LDO_LOW,
 };
 
-static int bq24257_get_charge_type(struct bq24257_device *bq,
+static int bq2425x_get_charge_type(struct bq2425x_device *bq,
 		union power_supply_propval *val)
 {
 	int ret;
 
-	ret = bq24257_field_read(bq, F_CE);
+	ret = bq2425x_field_read(bq, F_CE);
 	if (ret < 0)
 		return ret;
 
@@ -285,7 +285,7 @@ static int bq24257_get_charge_type(struct bq24257_device *bq,
 	}
 
 	/* Low Charge means a fixed low-current is used instead of i_chg */
-	ret = bq24257_field_read(bq, F_LOW_CHG);
+	ret = bq2425x_field_read(bq, F_LOW_CHG);
 	if (ret < 0)
 		return ret;
 
@@ -295,19 +295,19 @@ static int bq24257_get_charge_type(struct bq24257_device *bq,
 	return 0;
 }
 
-static int bq24257_set_charge_type(struct bq24257_device *bq,
+static int bq2425x_set_charge_type(struct bq2425x_device *bq,
 		const union power_supply_propval *val)
 {
 	int ret;
 
 	switch (val->intval) {
 	case POWER_SUPPLY_CHARGE_TYPE_NONE:
-		return bq24257_field_write(bq, F_CE, 1);
+		return bq2425x_field_write(bq, F_CE, 1);
 	case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
-		ret = bq24257_field_write(bq, F_LOW_CHG, 1);
+		ret = bq2425x_field_write(bq, F_LOW_CHG, 1);
 		break;
 	case POWER_SUPPLY_CHARGE_TYPE_FAST:
-		ret = bq24257_field_write(bq, F_LOW_CHG, 0);
+		ret = bq2425x_field_write(bq, F_LOW_CHG, 0);
 		break;
 	default:
 		return -EINVAL;
@@ -316,15 +316,15 @@ static int bq24257_set_charge_type(struct bq24257_device *bq,
 	if (ret < 0)
 		return ret;
 
-	return bq24257_field_write(bq, F_CE, 0);
+	return bq2425x_field_write(bq, F_CE, 0);
 }
 
-static int bq24257_get_input_current_limit(struct bq24257_device *bq,
+static int bq2425x_get_input_current_limit(struct bq2425x_device *bq,
 		union power_supply_propval *val)
 {
 	int ret;
 
-	ret = bq24257_field_read(bq, F_IILIMIT);
+	ret = bq2425x_field_read(bq, F_IILIMIT);
 	if (ret < 0)
 		return ret;
 
@@ -335,31 +335,31 @@ static int bq24257_get_input_current_limit(struct bq24257_device *bq,
 	 * than exceeding the bounds of the lookup table and returning
 	 * garbage.
 	 */
-	if (ret >= BQ24257_IILIMIT_MAP_SIZE)
+	if (ret >= BQ2425X_IILIMIT_MAP_SIZE)
 		return -ENODATA;
 
-	val->intval = bq24257_iilimit_map[ret];
+	val->intval = bq2425x_iilimit_map[ret];
 
 	return 0;
 }
 
-static int bq24257_set_input_current_limit(struct bq24257_device *bq,
+static int bq2425x_set_input_current_limit(struct bq2425x_device *bq,
 		const union power_supply_propval *val)
 {
 	if (!bq->in_ilimit_autoset_disable)
 		return -EPERM;
 
-	return bq24257_field_write(bq, F_IILIMIT, bq24257_find_idx(
-			val->intval, bq24257_iilimit_map,
-			BQ24257_IILIMIT_MAP_SIZE));
+	return bq2425x_field_write(bq, F_IILIMIT, bq2425x_find_idx(
+			val->intval, bq2425x_iilimit_map,
+			BQ2425X_IILIMIT_MAP_SIZE));
 }
 
-static int bq24257_power_supply_get_property(struct power_supply *psy,
+static int bq2425x_power_supply_get_property(struct power_supply *psy,
 					     enum power_supply_property psp,
 					     union power_supply_propval *val)
 {
-	struct bq24257_device *bq = power_supply_get_drvdata(psy);
-	struct bq24257_state state;
+	struct bq2425x_device *bq = power_supply_get_drvdata(psy);
+	struct bq2425x_state state;
 	int ret = 0;
 
 	mutex_lock(&bq->lock);
@@ -380,11 +380,11 @@ static int bq24257_power_supply_get_property(struct power_supply *psy,
 		break;
 
 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
-		ret = bq24257_get_charge_type(bq, val);
+		ret = bq2425x_get_charge_type(bq, val);
 		break;
 
 	case POWER_SUPPLY_PROP_MANUFACTURER:
-		val->strval = BQ24257_MANUFACTURER;
+		val->strval = BQ2425X_MANUFACTURER;
 		break;
 
 	case POWER_SUPPLY_PROP_MODEL_NAME:
@@ -423,27 +423,27 @@ static int bq24257_power_supply_get_property(struct power_supply *psy,
 		break;
 
 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
-		val->intval = bq24257_ichg_map[bq->init_data.ichg];
+		val->intval = bq2425x_ichg_map[bq->init_data.ichg];
 		break;
 
 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
-		val->intval = bq24257_ichg_map[BQ24257_ICHG_MAP_SIZE - 1];
+		val->intval = bq2425x_ichg_map[BQ2425X_ICHG_MAP_SIZE - 1];
 		break;
 
 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
-		val->intval = bq24257_vbat_map[bq->init_data.vbat];
+		val->intval = bq2425x_vbat_map[bq->init_data.vbat];
 		break;
 
 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
-		val->intval = bq24257_vbat_map[BQ24257_VBAT_MAP_SIZE - 1];
+		val->intval = bq2425x_vbat_map[BQ2425X_VBAT_MAP_SIZE - 1];
 		break;
 
 	case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
-		val->intval = bq24257_iterm_map[bq->init_data.iterm];
+		val->intval = bq2425x_iterm_map[bq->init_data.iterm];
 		break;
 
 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
-		ret = bq24257_get_input_current_limit(bq, val);
+		ret = bq2425x_get_input_current_limit(bq, val);
 		break;
 
 	default:
@@ -455,21 +455,21 @@ static int bq24257_power_supply_get_property(struct power_supply *psy,
 	return ret;
 }
 
-static int bq24257_power_supply_set_property(struct power_supply *psy,
+static int bq2425x_power_supply_set_property(struct power_supply *psy,
 		enum power_supply_property prop,
 		const union power_supply_propval *val)
 {
-	struct bq24257_device *bq = power_supply_get_drvdata(psy);
+	struct bq2425x_device *bq = power_supply_get_drvdata(psy);
 	int ret;
 
 	mutex_lock(&bq->lock);
 
 	switch (prop) {
 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
-		ret = bq24257_set_charge_type(bq, val);
+		ret = bq2425x_set_charge_type(bq, val);
 		break;
 	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
-		ret = bq24257_set_input_current_limit(bq, val);
+		ret = bq2425x_set_input_current_limit(bq, val);
 		break;
 	default:
 		ret = -EINVAL;
@@ -480,7 +480,7 @@ static int bq24257_power_supply_set_property(struct power_supply *psy,
 	return ret;
 }
 
-static int bq24257_power_supply_property_is_writeable(struct power_supply *psy,
+static int bq2425x_power_supply_property_is_writeable(struct power_supply *psy,
 		enum power_supply_property psp)
 {
 	switch (psp) {
@@ -492,18 +492,18 @@ static int bq24257_power_supply_property_is_writeable(struct power_supply *psy,
 	}
 }
 
-static int bq24257_get_chip_state(struct bq24257_device *bq,
-				  struct bq24257_state *state)
+static int bq2425x_get_chip_state(struct bq2425x_device *bq,
+				  struct bq2425x_state *state)
 {
 	int ret;
 
-	ret = bq24257_field_read(bq, F_STAT);
+	ret = bq2425x_field_read(bq, F_STAT);
 	if (ret < 0)
 		return ret;
 
 	state->status = ret;
 
-	ret = bq24257_field_read(bq, F_FAULT);
+	ret = bq2425x_field_read(bq, F_FAULT);
 	if (ret < 0)
 		return ret;
 
@@ -533,22 +533,22 @@ static int bq24257_get_chip_state(struct bq24257_device *bq,
 	return 0;
 }
 
-static bool bq24257_state_changed(struct bq24257_device *bq,
-				  struct bq24257_state *new_state)
+static bool bq2425x_state_changed(struct bq2425x_device *bq,
+				  struct bq2425x_state *new_state)
 {
 	return bq->state.status != new_state->status ||
 			bq->state.fault != new_state->fault ||
 			bq->state.power_good != new_state->power_good;
 }
 
-enum bq24257_loop_status {
+enum bq2425x_loop_status {
 	LOOP_STATUS_NONE,
 	LOOP_STATUS_IN_DPM,
 	LOOP_STATUS_IN_CURRENT_LIMIT,
 	LOOP_STATUS_THERMAL,
 };
 
-enum bq24257_in_ilimit {
+enum bq2425x_in_ilimit {
 	IILIMIT_100,
 	IILIMIT_150,
 	IILIMIT_500,
@@ -559,7 +559,7 @@ enum bq24257_in_ilimit {
 	IILIMIT_NONE,
 };
 
-enum bq24257_vovp {
+enum bq2425x_vovp {
 	VOVP_6000,
 	VOVP_6500,
 	VOVP_7000,
@@ -570,7 +570,7 @@ enum bq24257_vovp {
 	VOVP_10500
 };
 
-enum bq24257_vindpm {
+enum bq2425x_vindpm {
 	VINDPM_4200,
 	VINDPM_4280,
 	VINDPM_4360,
@@ -581,21 +581,21 @@ enum bq24257_vindpm {
 	VINDPM_4760
 };
 
-enum bq24257_port_type {
+enum bq2425x_port_type {
 	PORT_TYPE_DCP,		/* Dedicated Charging Port */
 	PORT_TYPE_CDP,		/* Charging Downstream Port */
 	PORT_TYPE_SDP,		/* Standard Downstream Port */
 	PORT_TYPE_NON_STANDARD,
 };
 
-enum bq24257_safety_timer {
+enum bq2425x_safety_timer {
 	SAFETY_TIMER_45,
 	SAFETY_TIMER_360,
 	SAFETY_TIMER_540,
 	SAFETY_TIMER_NONE,
 };
 
-static int bq24257_iilimit_autoset(struct bq24257_device *bq)
+static int bq2425x_iilimit_autoset(struct bq2425x_device *bq)
 {
 	int loop_status;
 	int iilimit;
@@ -608,13 +608,13 @@ static int bq24257_iilimit_autoset(struct bq24257_device *bq)
 		[PORT_TYPE_NON_STANDARD] = IILIMIT_500
 	};
 
-	ret = bq24257_field_read(bq, F_LOOP_STATUS);
+	ret = bq2425x_field_read(bq, F_LOOP_STATUS);
 	if (ret < 0)
 		goto error;
 
 	loop_status = ret;
 
-	ret = bq24257_field_read(bq, F_IILIMIT);
+	ret = bq2425x_field_read(bq, F_IILIMIT);
 	if (ret < 0)
 		goto error;
 
@@ -628,21 +628,21 @@ static int bq24257_iilimit_autoset(struct bq24257_device *bq)
 	if (loop_status == LOOP_STATUS_IN_DPM && iilimit == IILIMIT_500)
 		return 0;
 
-	ret = bq24257_field_read(bq, F_USB_DET);
+	ret = bq2425x_field_read(bq, F_USB_DET);
 	if (ret < 0)
 		goto error;
 
 	port_type = ret;
 
-	ret = bq24257_field_write(bq, F_IILIMIT, new_iilimit[port_type]);
+	ret = bq2425x_field_write(bq, F_IILIMIT, new_iilimit[port_type]);
 	if (ret < 0)
 		goto error;
 
-	ret = bq24257_field_write(bq, F_TMR, SAFETY_TIMER_360);
+	ret = bq2425x_field_write(bq, F_TMR, SAFETY_TIMER_360);
 	if (ret < 0)
 		goto error;
 
-	ret = bq24257_field_write(bq, F_CLR_VDP, 1);
+	ret = bq2425x_field_write(bq, F_CLR_VDP, 1);
 	if (ret < 0)
 		goto error;
 
@@ -656,21 +656,21 @@ error:
 	return ret;
 }
 
-static void bq24257_iilimit_setup_work(struct work_struct *work)
+static void bq2425x_iilimit_setup_work(struct work_struct *work)
 {
-	struct bq24257_device *bq = container_of(work, struct bq24257_device,
+	struct bq2425x_device *bq = container_of(work, struct bq2425x_device,
 						 iilimit_setup_work.work);
 
 	mutex_lock(&bq->lock);
-	bq24257_iilimit_autoset(bq);
+	bq2425x_iilimit_autoset(bq);
 	mutex_unlock(&bq->lock);
 }
 
-static void bq24257_handle_state_change(struct bq24257_device *bq,
-					struct bq24257_state *new_state)
+static void bq2425x_handle_state_change(struct bq2425x_device *bq,
+					struct bq2425x_state *new_state)
 {
 	int ret;
-	struct bq24257_state old_state;
+	struct bq2425x_state old_state;
 	bool reset_iilimit = false;
 	bool config_iilimit = false;
 
@@ -686,7 +686,7 @@ static void bq24257_handle_state_change(struct bq24257_device *bq,
 			cancel_delayed_work_sync(&bq->iilimit_setup_work);
 
 			/* activate D+/D- port detection algorithm */
-			ret = bq24257_field_write(bq, F_DPDM_EN, 1);
+			ret = bq2425x_field_write(bq, F_DPDM_EN, 1);
 			if (ret < 0)
 				goto error;
 
@@ -709,12 +709,12 @@ static void bq24257_handle_state_change(struct bq24257_device *bq,
 	}
 
 	if (reset_iilimit) {
-		ret = bq24257_field_write(bq, F_IILIMIT, IILIMIT_500);
+		ret = bq2425x_field_write(bq, F_IILIMIT, IILIMIT_500);
 		if (ret < 0)
 			goto error;
 	} else if (config_iilimit) {
 		schedule_delayed_work(&bq->iilimit_setup_work,
-				      msecs_to_jiffies(BQ24257_ILIM_SET_DELAY));
+				      msecs_to_jiffies(BQ2425X_ILIM_SET_DELAY));
 	}
 
 	return;
@@ -723,25 +723,25 @@ error:
 	dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
 }
 
-static irqreturn_t bq24257_irq_handler_thread(int irq, void *private)
+static irqreturn_t bq2425x_irq_handler_thread(int irq, void *private)
 {
 	int ret;
-	struct bq24257_device *bq = private;
-	struct bq24257_state state;
+	struct bq2425x_device *bq = private;
+	struct bq2425x_state state;
 
 	mutex_lock(&bq->lock);
 
-	ret = bq24257_get_chip_state(bq, &state);
+	ret = bq2425x_get_chip_state(bq, &state);
 	if (ret < 0)
 		goto out;
 
-	if (!bq24257_state_changed(bq, &state))
+	if (!bq2425x_state_changed(bq, &state))
 		goto out;
 
 	dev_dbg(bq->dev, "irq(state changed): status/fault/pg = %d/%d/%d\n",
 		state.status, state.fault, state.power_good);
 
-	bq24257_handle_state_change(bq, &state);
+	bq2425x_handle_state_change(bq, &state);
 	bq->state = state;
 
 	mutex_unlock(&bq->lock);
@@ -755,11 +755,11 @@ out:
 	return IRQ_HANDLED;
 }
 
-static int bq24257_hw_init(struct bq24257_device *bq)
+static int bq2425x_hw_init(struct bq2425x_device *bq)
 {
 	int ret;
 	int i;
-	struct bq24257_state state;
+	struct bq2425x_state state;
 
 	const struct {
 		int field;
@@ -777,19 +777,19 @@ static int bq24257_hw_init(struct bq24257_device *bq)
 	 * Disable the watchdog timer to prevent the IC from going back to
 	 * default settings after 50 seconds of I2C inactivity.
 	 */
-	ret = bq24257_field_write(bq, F_WD_EN, 0);
+	ret = bq2425x_field_write(bq, F_WD_EN, 0);
 	if (ret < 0)
 		return ret;
 
 	/* configure the charge currents and voltages */
 	for (i = 0; i < ARRAY_SIZE(init_data); i++) {
-		ret = bq24257_field_write(bq, init_data[i].field,
+		ret = bq2425x_field_write(bq, init_data[i].field,
 					  init_data[i].value);
 		if (ret < 0)
 			return ret;
 	}
 
-	ret = bq24257_get_chip_state(bq, &state);
+	ret = bq2425x_get_chip_state(bq, &state);
 	if (ret < 0)
 		return ret;
 
@@ -800,21 +800,21 @@ static int bq24257_hw_init(struct bq24257_device *bq)
 				bq->init_data.in_ilimit);
 
 		/* program fixed input current limit */
-		ret = bq24257_field_write(bq, F_IILIMIT,
+		ret = bq2425x_field_write(bq, F_IILIMIT,
 					  bq->init_data.in_ilimit);
 
 		if (ret < 0)
 			return ret;
 	} else if (!state.power_good)
 		/* activate D+/D- detection algorithm */
-		ret = bq24257_field_write(bq, F_DPDM_EN, 1);
+		ret = bq2425x_field_write(bq, F_DPDM_EN, 1);
 	else if (state.fault != FAULT_NO_BAT)
-		ret = bq24257_iilimit_autoset(bq);
+		ret = bq2425x_iilimit_autoset(bq);
 
 	return ret;
 }
 
-static enum power_supply_property bq24257_power_supply_props[] = {
+static enum power_supply_property bq2425x_power_supply_props[] = {
 	POWER_SUPPLY_PROP_MANUFACTURER,
 	POWER_SUPPLY_PROP_MODEL_NAME,
 	POWER_SUPPLY_PROP_STATUS,
@@ -829,56 +829,56 @@ static enum power_supply_property bq24257_power_supply_props[] = {
 	POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 };
 
-static char *bq24257_charger_supplied_to[] = {
+static char *bq2425x_charger_supplied_to[] = {
 	"main-battery",
 };
 
-static const struct power_supply_desc bq24257_power_supply_desc = {
-	.name = "bq24257-charger",
+static const struct power_supply_desc bq2425x_power_supply_desc = {
+	.name = "bq2425x-charger",
 	.type = POWER_SUPPLY_TYPE_USB,
-	.properties = bq24257_power_supply_props,
-	.num_properties = ARRAY_SIZE(bq24257_power_supply_props),
-	.get_property = bq24257_power_supply_get_property,
-	.set_property = bq24257_power_supply_set_property,
-	.property_is_writeable	= bq24257_power_supply_property_is_writeable
+	.properties = bq2425x_power_supply_props,
+	.num_properties = ARRAY_SIZE(bq2425x_power_supply_props),
+	.get_property = bq2425x_power_supply_get_property,
+	.set_property = bq2425x_power_supply_set_property,
+	.property_is_writeable	= bq2425x_power_supply_property_is_writeable
 };
 
-static ssize_t bq24257_show_ovp_voltage(struct device *dev,
+static ssize_t bq2425x_show_ovp_voltage(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
 	struct power_supply *psy = dev_get_drvdata(dev);
-	struct bq24257_device *bq = power_supply_get_drvdata(psy);
+	struct bq2425x_device *bq = power_supply_get_drvdata(psy);
 
 	return scnprintf(buf, PAGE_SIZE, "%d\n",
-			bq24257_vovp_map[bq->init_data.vovp]);
+			bq2425x_vovp_map[bq->init_data.vovp]);
 }
 
-static ssize_t bq24257_show_in_dpm_voltage(struct device *dev,
+static ssize_t bq2425x_show_in_dpm_voltage(struct device *dev,
 					   struct device_attribute *attr,
 					   char *buf)
 {
 	struct power_supply *psy = dev_get_drvdata(dev);
-	struct bq24257_device *bq = power_supply_get_drvdata(psy);
+	struct bq2425x_device *bq = power_supply_get_drvdata(psy);
 
 	return scnprintf(buf, PAGE_SIZE, "%d\n",
-			bq24257_vindpm_map[bq->init_data.vindpm]);
+			bq2425x_vindpm_map[bq->init_data.vindpm]);
 }
 
-static ssize_t bq24257_sysfs_show_enable(struct device *dev,
+static ssize_t bq2425x_sysfs_show_enable(struct device *dev,
 					 struct device_attribute *attr,
 					 char *buf)
 {
 	struct power_supply *psy = dev_get_drvdata(dev);
-	struct bq24257_device *bq = power_supply_get_drvdata(psy);
+	struct bq2425x_device *bq = power_supply_get_drvdata(psy);
 	int ret;
 
 	mutex_lock(&bq->lock);
 
 	if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
-		ret = bq24257_field_read(bq, F_HZ_MODE);
+		ret = bq2425x_field_read(bq, F_HZ_MODE);
 	else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
-		ret = bq24257_field_read(bq, F_SYSOFF);
+		ret = bq2425x_field_read(bq, F_SYSOFF);
 	else if (strcmp(attr->attr.name, "timer2x_enable") == 0)
 		ret = bq->init_data.timer2x_enable;
 	else
@@ -892,13 +892,13 @@ static ssize_t bq24257_sysfs_show_enable(struct device *dev,
 	return scnprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
-static ssize_t bq24257_sysfs_set_enable(struct device *dev,
+static ssize_t bq2425x_sysfs_set_enable(struct device *dev,
 					struct device_attribute *attr,
 					const char *buf,
 					size_t count)
 {
 	struct power_supply *psy = dev_get_drvdata(dev);
-	struct bq24257_device *bq = power_supply_get_drvdata(psy);
+	struct bq2425x_device *bq = power_supply_get_drvdata(psy);
 	long val;
 	int ret;
 
@@ -908,9 +908,9 @@ static ssize_t bq24257_sysfs_set_enable(struct device *dev,
 	mutex_lock(&bq->lock);
 
 	if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
-		ret = bq24257_field_write(bq, F_HZ_MODE, val);
+		ret = bq2425x_field_write(bq, F_HZ_MODE, val);
 	else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
-		ret = bq24257_field_write(bq, F_SYSOFF, val);
+		ret = bq2425x_field_write(bq, F_SYSOFF, val);
 	else
 		ret = -EINVAL;
 
@@ -922,16 +922,16 @@ static ssize_t bq24257_sysfs_set_enable(struct device *dev,
 	return count;
 }
 
-static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL);
-static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq24257_show_in_dpm_voltage, NULL);
+static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq2425x_show_ovp_voltage, NULL);
+static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq2425x_show_in_dpm_voltage, NULL);
 static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
-		bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
+		bq2425x_sysfs_show_enable, bq2425x_sysfs_set_enable);
 static DEVICE_ATTR(sysoff_enable, S_IWUSR | S_IRUGO,
-		bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
+		bq2425x_sysfs_show_enable, bq2425x_sysfs_set_enable);
 static DEVICE_ATTR(timer2x_enable, S_IRUGO,
-		bq24257_sysfs_show_enable, NULL);
+		bq2425x_sysfs_show_enable, NULL);
 
-static struct attribute *bq24257_charger_attr[] = {
+static struct attribute *bq2425x_charger_attr[] = {
 	&dev_attr_ovp_voltage.attr,
 	&dev_attr_in_dpm_voltage.attr,
 	&dev_attr_high_impedance_enable.attr,
@@ -940,18 +940,18 @@ static struct attribute *bq24257_charger_attr[] = {
 	NULL,
 };
 
-static const struct attribute_group bq24257_attr_group = {
-	.attrs = bq24257_charger_attr,
+static const struct attribute_group bq2425x_attr_group = {
+	.attrs = bq2425x_charger_attr,
 };
 
-static int bq24257_power_supply_init(struct bq24257_device *bq)
+static int bq2425x_power_supply_init(struct bq2425x_device *bq)
 {
 	struct power_supply_config psy_cfg = { .drv_data = bq, };
 
-	psy_cfg.supplied_to = bq24257_charger_supplied_to;
-	psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to);
+	psy_cfg.supplied_to = bq2425x_charger_supplied_to;
+	psy_cfg.num_supplicants = ARRAY_SIZE(bq2425x_charger_supplied_to);
 
-	bq->charger = power_supply_register(bq->dev, &bq24257_power_supply_desc,
+	bq->charger = power_supply_register(bq->dev, &bq2425x_power_supply_desc,
 					    &psy_cfg);
 	if (IS_ERR(bq->charger))
 		return PTR_ERR(bq->charger);
@@ -959,14 +959,14 @@ static int bq24257_power_supply_init(struct bq24257_device *bq)
 	return 0;
 }
 
-static int bq24257_irq_probe(struct bq24257_device *bq)
+static int bq2425x_irq_probe(struct bq2425x_device *bq)
 {
-	struct bq24257_platform_data *pdata = bq->client->dev.platform_data;
+	struct bq2425x_platform_data *pdata = bq->client->dev.platform_data;
 	struct gpio_desc *stat_irq;
 	int ret;
 
 	if (!pdata)
-		stat_irq = devm_gpiod_get_index(bq->dev, BQ24257_STAT_IRQ, 0,
+		stat_irq = devm_gpiod_get_index(bq->dev, BQ2425X_STAT_IRQ, 0,
 				GPIOD_IN);
 	else {
 		if (!gpio_is_valid(pdata->stat_gpio)) {
@@ -975,7 +975,7 @@ static int bq24257_irq_probe(struct bq24257_device *bq)
 		}
 
 		ret = devm_gpio_request_one(bq->dev, pdata->stat_gpio,
-				GPIOD_IN, BQ24257_STAT_IRQ);
+				GPIOD_IN, BQ2425X_STAT_IRQ);
 		if (ret) {
 			dev_err(bq->dev, "stat_irq pin request failed\n");
 			return ret;
@@ -994,13 +994,13 @@ static int bq24257_irq_probe(struct bq24257_device *bq)
 	return gpiod_to_irq(stat_irq);
 }
 
-static int bq24257_pg_gpio_probe(struct bq24257_device *bq)
+static int bq2425x_pg_gpio_probe(struct bq2425x_device *bq)
 {
-	struct bq24257_platform_data *pdata = bq->client->dev.platform_data;
+	struct bq2425x_platform_data *pdata = bq->client->dev.platform_data;
 	int ret;
 
 	if (!pdata)
-		bq->pg = devm_gpiod_get_index(bq->dev, BQ24257_PG_GPIO, 0,
+		bq->pg = devm_gpiod_get_index(bq->dev, BQ2425X_PG_GPIO, 0,
 				GPIOD_IN);
 	else {
 		if (!gpio_is_valid(pdata->pg_gpio)) {
@@ -1009,7 +1009,7 @@ static int bq24257_pg_gpio_probe(struct bq24257_device *bq)
 		}
 
 		ret = devm_gpio_request_one(bq->dev, pdata->pg_gpio,
-				GPIOD_IN, BQ24257_PG_GPIO);
+				GPIOD_IN, BQ2425X_PG_GPIO);
 
 		if (ret) {
 			dev_err(bq->dev, "PG pin request failed\n");
@@ -1029,26 +1029,26 @@ static int bq24257_pg_gpio_probe(struct bq24257_device *bq)
 	return 0;
 }
 
-static void bq24257_pdata_probe(struct bq24257_device *bq,
-		struct bq24257_platform_data *pdata)
+static void bq2425x_pdata_probe(struct bq2425x_device *bq,
+		struct bq2425x_platform_data *pdata)
 {
-	bq->init_data.ichg = bq24257_find_idx(pdata->ichg,
-			bq24257_ichg_map, BQ24257_ICHG_MAP_SIZE);
+	bq->init_data.ichg = bq2425x_find_idx(pdata->ichg,
+			bq2425x_ichg_map, BQ2425X_ICHG_MAP_SIZE);
 
-	bq->init_data.vbat = bq24257_find_idx(pdata->vbat,
-			bq24257_vbat_map, BQ24257_VBAT_MAP_SIZE);
+	bq->init_data.vbat = bq2425x_find_idx(pdata->vbat,
+			bq2425x_vbat_map, BQ2425X_VBAT_MAP_SIZE);
 
-	bq->init_data.iterm = bq24257_find_idx(pdata->iterm,
-			bq24257_iterm_map, BQ24257_ITERM_MAP_SIZE);
+	bq->init_data.iterm = bq2425x_find_idx(pdata->iterm,
+			bq2425x_iterm_map, BQ2425X_ITERM_MAP_SIZE);
 
-	bq->init_data.in_ilimit = bq24257_find_idx(pdata->in_ilimit,
-			bq24257_iilimit_map, BQ24257_IILIMIT_MAP_SIZE);
+	bq->init_data.in_ilimit = bq2425x_find_idx(pdata->in_ilimit,
+			bq2425x_iilimit_map, BQ2425X_IILIMIT_MAP_SIZE);
 
-	bq->init_data.vovp = bq24257_find_idx(pdata->vovp, bq24257_vovp_map,
-			BQ24257_VOVP_MAP_SIZE);
+	bq->init_data.vovp = bq2425x_find_idx(pdata->vovp, bq2425x_vovp_map,
+			BQ2425X_VOVP_MAP_SIZE);
 
-	bq->init_data.vindpm = bq24257_find_idx(pdata->vindpm,
-			bq24257_vindpm_map, BQ24257_VINDPM_MAP_SIZE);
+	bq->init_data.vindpm = bq2425x_find_idx(pdata->vindpm,
+			bq2425x_vindpm_map, BQ2425X_VINDPM_MAP_SIZE);
 
 	bq->init_data.timer2x_enable = pdata->timer2x_enable;
 
@@ -1057,7 +1057,7 @@ static void bq24257_pdata_probe(struct bq24257_device *bq,
 	bq->pg_gpio_disable = pdata->pg_gpio_disable;
 }
 
-static int bq24257_fw_probe(struct bq24257_device *bq)
+static int bq2425x_fw_probe(struct bq2425x_device *bq)
 {
 	int ret;
 	u32 property;
@@ -1067,24 +1067,24 @@ static int bq24257_fw_probe(struct bq24257_device *bq)
 	if (ret < 0)
 		return ret;
 
-	bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map,
-					      BQ24257_ICHG_MAP_SIZE);
+	bq->init_data.ichg = bq2425x_find_idx(property, bq2425x_ichg_map,
+					      BQ2425X_ICHG_MAP_SIZE);
 
 	ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage",
 				       &property);
 	if (ret < 0)
 		return ret;
 
-	bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map,
-					      BQ24257_VBAT_MAP_SIZE);
+	bq->init_data.vbat = bq2425x_find_idx(property, bq2425x_vbat_map,
+					      BQ2425X_VBAT_MAP_SIZE);
 
 	ret = device_property_read_u32(bq->dev, "ti,termination-current",
 				       &property);
 	if (ret < 0)
 		return ret;
 
-	bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map,
-					       BQ24257_ITERM_MAP_SIZE);
+	bq->init_data.iterm = bq2425x_find_idx(property, bq2425x_iterm_map,
+					       BQ2425X_ITERM_MAP_SIZE);
 
 	/* Optional properties. If not provided use reasonable default. */
 	ret = device_property_read_u32(bq->dev, "ti,current-limit",
@@ -1098,8 +1098,8 @@ static int bq24257_fw_probe(struct bq24257_device *bq)
 		bq->init_data.in_ilimit = IILIMIT_500;
 	else {
 		bq->in_ilimit_autoset_disable = true;
-		bq->init_data.in_ilimit = bq24257_find_idx(property,
-				bq24257_iilimit_map, BQ24257_IILIMIT_MAP_SIZE);
+		bq->init_data.in_ilimit = bq2425x_find_idx(property,
+				bq2425x_iilimit_map, BQ2425X_IILIMIT_MAP_SIZE);
 	}
 
 	ret = device_property_read_u32(bq->dev, "ti,ovp-voltage",
@@ -1107,16 +1107,16 @@ static int bq24257_fw_probe(struct bq24257_device *bq)
 	if (ret < 0)
 		bq->init_data.vovp = VOVP_6500;
 	else
-		bq->init_data.vovp = bq24257_find_idx(property,
-				bq24257_vovp_map, BQ24257_VOVP_MAP_SIZE);
+		bq->init_data.vovp = bq2425x_find_idx(property,
+				bq2425x_vovp_map, BQ2425X_VOVP_MAP_SIZE);
 
 	ret = device_property_read_u32(bq->dev, "ti,in-dpm-voltage",
 				       &property);
 	if (ret < 0)
 		bq->init_data.vindpm = VINDPM_4360;
 	else
-		bq->init_data.vindpm = bq24257_find_idx(property,
-				bq24257_vindpm_map, BQ24257_VINDPM_MAP_SIZE);
+		bq->init_data.vindpm = bq2425x_find_idx(property,
+				bq2425x_vindpm_map, BQ2425X_VINDPM_MAP_SIZE);
 
 	ret = device_property_read_u32(bq->dev, "ti,safety-timer-2x-enable",
 				       &property);
@@ -1128,14 +1128,14 @@ static int bq24257_fw_probe(struct bq24257_device *bq)
 	return 0;
 }
 
-static int bq24257_probe(struct i2c_client *client,
+static int bq2425x_probe(struct i2c_client *client,
 			 const struct i2c_device_id *id)
 {
 	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 	struct device *dev = &client->dev;
 	const struct acpi_device_id *acpi_id;
-	struct bq24257_platform_data *pdata = client->dev.platform_data;
-	struct bq24257_device *bq;
+	struct bq2425x_platform_data *pdata = client->dev.platform_data;
+	struct bq2425x_device *bq;
 	int ret;
 	int i;
 
@@ -1165,14 +1165,14 @@ static int bq24257_probe(struct i2c_client *client,
 
 	mutex_init(&bq->lock);
 
-	bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config);
+	bq->rmap = devm_regmap_init_i2c(client, &bq2425x_regmap_config);
 	if (IS_ERR(bq->rmap)) {
 		dev_err(dev, "failed to allocate register map\n");
 		return PTR_ERR(bq->rmap);
 	}
 
-	for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) {
-		const struct reg_field *reg_fields = bq24257_reg_fields;
+	for (i = 0; i < ARRAY_SIZE(bq2425x_reg_fields); i++) {
+		const struct reg_field *reg_fields = bq2425x_reg_fields;
 
 		bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap,
 							     reg_fields[i]);
@@ -1185,14 +1185,14 @@ static int bq24257_probe(struct i2c_client *client,
 	i2c_set_clientdata(client, bq);
 
 	if (!pdata) {
-		ret = bq24257_fw_probe(bq);
+		ret = bq2425x_fw_probe(bq);
 		if (ret < 0) {
 			dev_err(dev, "Cannot read device properties.\n");
 			return ret;
 		}
 	} else {
 		dev_dbg(dev, "init using platform data\n");
-		bq24257_pdata_probe(bq, pdata);
+		bq2425x_pdata_probe(bq, pdata);
 	}
 
 	/*
@@ -1205,7 +1205,7 @@ static int bq24257_probe(struct i2c_client *client,
 
 	if (!bq->in_ilimit_autoset_disable)
 		INIT_DELAYED_WORK(&bq->iilimit_setup_work,
-				bq24257_iilimit_setup_work);
+				bq2425x_iilimit_setup_work);
 
 	/*
 	 * The BQ24250 doesn't have a dedicated Power Good (PG) pin so we
@@ -1221,7 +1221,7 @@ static int bq24257_probe(struct i2c_client *client,
 	 * use of the dedicated pin is preferred.
 	 */
 	if (!bq->pg_gpio_disable) {
-		ret = bq24257_pg_gpio_probe(bq);
+		ret = bq2425x_pg_gpio_probe(bq);
 		if (ret < 0) {
 			dev_info(bq->dev,
 				"using SW-based power-good detection\n");
@@ -1230,7 +1230,7 @@ static int bq24257_probe(struct i2c_client *client,
 	}
 
 	/* reset all registers to defaults */
-	ret = bq24257_field_write(bq, F_RESET, 1);
+	ret = bq2425x_field_write(bq, F_RESET, 1);
 	if (ret < 0)
 		return ret;
 
@@ -1239,11 +1239,11 @@ static int bq24257_probe(struct i2c_client *client,
 	 * returns 1 on this bit, so this is the only way to avoid resetting the
 	 * chip every time we update another field in this register.
 	 */
-	ret = bq24257_field_write(bq, F_RESET, 0);
+	ret = bq2425x_field_write(bq, F_RESET, 0);
 	if (ret < 0)
 		return ret;
 
-	ret = bq24257_hw_init(bq);
+	ret = bq2425x_hw_init(bq);
 	if (ret < 0) {
 		dev_err(dev, "Cannot initialize the chip.\n");
 		return ret;
@@ -1251,12 +1251,12 @@ static int bq24257_probe(struct i2c_client *client,
 
 	/*
 	 * When using device firmware we either take the IRQ specified directly
-	 * or probe for a pin named BQ24257_STAT_IRQ. In case of using platform
+	 * or probe for a pin named BQ2425X_STAT_IRQ. In case of using platform
 	 * data always run the IRQ pin probe function to finish IRQ and GPIO
 	 * setup based on the stat pin specified in the platform data.
 	 */
 	if (client->irq <= 0 || pdata)
-		client->irq = bq24257_irq_probe(bq);
+		client->irq = bq2425x_irq_probe(bq);
 
 	if (client->irq < 0) {
 		dev_err(dev, "no irq resource found\n");
@@ -1264,20 +1264,20 @@ static int bq24257_probe(struct i2c_client *client,
 	}
 
 	ret = devm_request_threaded_irq(dev, client->irq, NULL,
-					bq24257_irq_handler_thread,
+					bq2425x_irq_handler_thread,
 					IRQF_TRIGGER_FALLING |
 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
-					BQ24257_STAT_IRQ, bq);
+					BQ2425X_STAT_IRQ, bq);
 	if (ret)
 		return ret;
 
-	ret = bq24257_power_supply_init(bq);
+	ret = bq2425x_power_supply_init(bq);
 	if (ret < 0) {
 		dev_err(dev, "Failed to register power supply\n");
 		return ret;
 	}
 
-	ret = sysfs_create_group(&bq->charger->dev.kobj, &bq24257_attr_group);
+	ret = sysfs_create_group(&bq->charger->dev.kobj, &bq2425x_attr_group);
 	if (ret < 0) {
 		dev_err(dev, "Can't create sysfs entries\n");
 		return ret;
@@ -1286,26 +1286,26 @@ static int bq24257_probe(struct i2c_client *client,
 	return 0;
 }
 
-static int bq24257_remove(struct i2c_client *client)
+static int bq2425x_remove(struct i2c_client *client)
 {
-	struct bq24257_device *bq = i2c_get_clientdata(client);
+	struct bq2425x_device *bq = i2c_get_clientdata(client);
 
 	if (!bq->in_ilimit_autoset_disable)
 		cancel_delayed_work_sync(&bq->iilimit_setup_work);
 
-	sysfs_remove_group(&bq->charger->dev.kobj, &bq24257_attr_group);
+	sysfs_remove_group(&bq->charger->dev.kobj, &bq2425x_attr_group);
 
 	power_supply_unregister(bq->charger);
 
-	bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */
+	bq2425x_field_write(bq, F_RESET, 1); /* reset to defaults */
 
 	return 0;
 }
 
 #ifdef CONFIG_PM_SLEEP
-static int bq24257_suspend(struct device *dev)
+static int bq2425x_suspend(struct device *dev)
 {
-	struct bq24257_device *bq = dev_get_drvdata(dev);
+	struct bq2425x_device *bq = dev_get_drvdata(dev);
 	int ret = 0;
 
 	if (!bq->in_ilimit_autoset_disable)
@@ -1314,7 +1314,7 @@ static int bq24257_suspend(struct device *dev)
 	mutex_lock(&bq->lock);
 
 	/* reset all registers to default (and activate standalone mode) */
-	ret = bq24257_field_write(bq, F_RESET, 1);
+	ret = bq2425x_field_write(bq, F_RESET, 1);
 	if (ret < 0)
 		dev_err(bq->dev, "Cannot reset chip to standalone mode.\n");
 
@@ -1323,22 +1323,22 @@ static int bq24257_suspend(struct device *dev)
 	return ret;
 }
 
-static int bq24257_resume(struct device *dev)
+static int bq2425x_resume(struct device *dev)
 {
 	int ret;
-	struct bq24257_device *bq = dev_get_drvdata(dev);
+	struct bq2425x_device *bq = dev_get_drvdata(dev);
 
 	mutex_lock(&bq->lock);
 
-	ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7);
+	ret = regcache_drop_region(bq->rmap, BQ2425X_REG_1, BQ2425X_REG_7);
 	if (ret < 0)
 		goto err;
 
-	ret = bq24257_field_write(bq, F_RESET, 0);
+	ret = bq2425x_field_write(bq, F_RESET, 0);
 	if (ret < 0)
 		goto err;
 
-	ret = bq24257_hw_init(bq);
+	ret = bq2425x_hw_init(bq);
 	if (ret < 0) {
 		dev_err(bq->dev, "Cannot init chip after resume.\n");
 		goto err;
@@ -1356,19 +1356,19 @@ err:
 }
 #endif
 
-static const struct dev_pm_ops bq24257_pm = {
-	SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume)
+static const struct dev_pm_ops bq2425x_pm = {
+	SET_SYSTEM_SLEEP_PM_OPS(bq2425x_suspend, bq2425x_resume)
 };
 
-static const struct i2c_device_id bq24257_i2c_ids[] = {
+static const struct i2c_device_id bq2425x_i2c_ids[] = {
 	{ "bq24250", BQ24250 },
 	{ "bq24251", BQ24251 },
 	{ "bq24257", BQ24257 },
 	{},
 };
-MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids);
+MODULE_DEVICE_TABLE(i2c, bq2425x_i2c_ids);
 
-static const struct of_device_id bq24257_of_match[] = {
+static const struct of_device_id bq2425x_of_match[] = {
 	{
 		.compatible = "ti,bq24250",
 		.compatible = "ti,bq24251",
@@ -1376,29 +1376,29 @@ static const struct of_device_id bq24257_of_match[] = {
 	},
 	{ },
 };
-MODULE_DEVICE_TABLE(of, bq24257_of_match);
+MODULE_DEVICE_TABLE(of, bq2425x_of_match);
 
-static const struct acpi_device_id bq24257_acpi_match[] = {
+static const struct acpi_device_id bq2425x_acpi_match[] = {
 	{ "BQ242500", BQ24250 },
 	{ "BQ242510", BQ24251 },
 	{ "BQ242570", BQ24257 },
 	{},
 };
-MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match);
+MODULE_DEVICE_TABLE(acpi, bq2425x_acpi_match);
 
-static struct i2c_driver bq24257_driver = {
+static struct i2c_driver bq2425x_driver = {
 	.driver = {
-		.name = "bq24257-charger",
-		.of_match_table = of_match_ptr(bq24257_of_match),
-		.acpi_match_table = ACPI_PTR(bq24257_acpi_match),
-		.pm = &bq24257_pm,
+		.name = "bq2425x-charger",
+		.of_match_table = of_match_ptr(bq2425x_of_match),
+		.acpi_match_table = ACPI_PTR(bq2425x_acpi_match),
+		.pm = &bq2425x_pm,
 	},
-	.probe = bq24257_probe,
-	.remove = bq24257_remove,
-	.id_table = bq24257_i2c_ids,
+	.probe = bq2425x_probe,
+	.remove = bq2425x_remove,
+	.id_table = bq2425x_i2c_ids,
 };
-module_i2c_driver(bq24257_driver);
+module_i2c_driver(bq2425x_driver);
 
 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
-MODULE_DESCRIPTION("bq24257 charger driver");
+MODULE_DESCRIPTION("bq2425x charger driver");
 MODULE_LICENSE("GPL");
diff --git a/include/linux/power/bq24257_charger.h b/include/linux/power/bq2425x_charger.h
similarity index 85%
rename from include/linux/power/bq24257_charger.h
rename to include/linux/power/bq2425x_charger.h
index 7fc505b..782667e 100644
--- a/include/linux/power/bq24257_charger.h
+++ b/include/linux/power/bq2425x_charger.h
@@ -1,18 +1,18 @@
 /*
- * Platform data for the TI bq24257 battery charger driver.
+ * Platform data for the TI bq2425x battery charger driver.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
-#ifndef _BQ24257_CHARGER_H_
-#define _BQ24257_CHARGER_H_
+#ifndef _BQ2425X_CHARGER_H_
+#define _BQ2425X_CHARGER_H_
 
 #include <asm/types.h>
 #include <linux/types.h>
 
-struct bq24257_platform_data {
+struct bq2425x_platform_data {
 	u32 ichg;				       /* charge current (uA) */
 	u32 vbat;				   /* regulation voltage (uV) */
 	u32 iterm;				  /* termination current (uA) */
