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