Rename files and refactor definitions, function names, etc as well as the driver name itself to reflect that this driver supports multiple devices and not just the bq24257. Signed-off-by: Andreas Dannenberg <dannenberg@xxxxxx> --- drivers/power/Kconfig | 2 +- drivers/power/Makefile | 2 +- .../power/{bq24257_charger.c => bq2425x_charger.c} | 532 ++++++++++----------- .../power/{bq24257_charger.h => bq2425x_charger.h} | 8 +- 4 files changed, 272 insertions(+), 272 deletions(-) rename drivers/power/{bq24257_charger.c => bq2425x_charger.c} (64%) rename include/linux/power/{bq24257_charger.h => bq2425x_charger.h} (85%) 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@xxxxxxxxx>"); -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) */ -- 1.9.1 -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html