From bac1e954cf97153134efb2d54ba11c50306a136e Mon Sep 17 00:00:00 2001 From: =?utf8?q?Pali=20Roh=C3=A1r?= Date: Wed, 21 Sep 2011 21:19:16 +0200 Subject: [PATCH] Update bq27x00_battery module * upstream changes (patches bq27x00-upstream.diff power-supply-ignore-enodata.diff) * maemo changes (patch bq27x00-maemo.diff) * register access from user-space using ioctl (patch bq27x00-reg.diff) * rename board-rx51-peripherals.diff to bq27x00-rx51-board.diff --- .../debian/patches/board-rx51-peripherals.diff | 12 - .../debian/patches/bq27x00-maemo.diff | 90 ++ .../debian/patches/bq27x00-reg.diff | 205 ++++ .../debian/patches/bq27x00-rx51-board.diff | 12 + .../debian/patches/bq27x00-upstream.diff | 1027 ++++++++++++++++++++ .../debian/patches/bq27x00_battery.diff | 974 ------------------- .../patches/power-supply-ignore-enodata.diff | 37 + kernel-power-2.6.28/debian/patches/series | 7 +- 8 files changed, 1376 insertions(+), 988 deletions(-) delete mode 100644 kernel-power-2.6.28/debian/patches/board-rx51-peripherals.diff create mode 100644 kernel-power-2.6.28/debian/patches/bq27x00-maemo.diff create mode 100644 kernel-power-2.6.28/debian/patches/bq27x00-reg.diff create mode 100644 kernel-power-2.6.28/debian/patches/bq27x00-rx51-board.diff create mode 100644 kernel-power-2.6.28/debian/patches/bq27x00-upstream.diff delete mode 100644 kernel-power-2.6.28/debian/patches/bq27x00_battery.diff create mode 100644 kernel-power-2.6.28/debian/patches/power-supply-ignore-enodata.diff diff --git a/kernel-power-2.6.28/debian/patches/board-rx51-peripherals.diff b/kernel-power-2.6.28/debian/patches/board-rx51-peripherals.diff deleted file mode 100644 index 92e0619..0000000 --- a/kernel-power-2.6.28/debian/patches/board-rx51-peripherals.diff +++ /dev/null @@ -1,12 +0,0 @@ ---- kernel-power-2.6.28/arch/arm/mach-omap2/board-rx51-peripherals.c 2011-01-23 03:53:13.000000000 +0100 -+++ kernel-power-2.6.28/arch/arm/mach-omap2/board-rx51-peripherals.c 2011-01-23 04:02:21.000000000 +0100 -@@ -572,6 +580,9 @@ static struct i2c_board_info __initdata - I2C_BOARD_INFO("tsl2563", 0x29), - .platform_data = &rx51_tsl2563_platform_data, - }, -+ { -+ I2C_BOARD_INFO("bq27200", 0x55), -+ }, - }; - - static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_3[] = { diff --git a/kernel-power-2.6.28/debian/patches/bq27x00-maemo.diff b/kernel-power-2.6.28/debian/patches/bq27x00-maemo.diff new file mode 100644 index 0000000..5d6f5dc --- /dev/null +++ b/kernel-power-2.6.28/debian/patches/bq27x00-maemo.diff @@ -0,0 +1,90 @@ +--- kernel-power-2.6.28/drivers/power/bq27x00_battery.c 2011-09-21 13:16:45.007978008 +0200 ++++ kernel-power-2.6.28/drivers/power/bq27x00_battery.c 2011-09-21 13:49:06.207956191 +0200 +@@ -36,7 +36,12 @@ + #include + #include + +-#include ++#define CONFIG_BATTERY_BQ27X00_I2C ++ ++struct bq27000_platform_data { ++ const char *name; ++ int (*read)(struct device *dev, unsigned int); ++}; + + #define DRIVER_VERSION "1.2.0" + +@@ -113,7 +118,9 @@ static enum power_supply_property bq27x0 + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_CURRENT_NOW, + POWER_SUPPLY_PROP_CAPACITY, ++/* + POWER_SUPPLY_PROP_CAPACITY_LEVEL, ++*/ + POWER_SUPPLY_PROP_TEMP, + POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, + POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, +@@ -122,8 +129,10 @@ static enum power_supply_property bq27x0 + POWER_SUPPLY_PROP_CHARGE_FULL, + POWER_SUPPLY_PROP_CHARGE_NOW, + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, ++/* + POWER_SUPPLY_PROP_CYCLE_COUNT, + POWER_SUPPLY_PROP_ENERGY_NOW, ++*/ + }; + + static unsigned int poll_interval = 360; +@@ -353,7 +362,9 @@ static void bq27x00_battery_poll(struct + + if (poll_interval > 0) { + /* The timer does not have to be accurate. */ ++ /* + set_timer_slack(&di->work.timer, poll_interval * HZ / 4); ++ */ + schedule_delayed_work(&di->work, poll_interval * HZ); + } + } +@@ -423,6 +434,7 @@ static int bq27x00_battery_status(struct + return 0; + } + ++/* + static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di, + union power_supply_propval *val) + { +@@ -452,6 +464,7 @@ static int bq27x00_battery_capacity_leve + + return 0; + } ++*/ + + /* + * Return the battery Voltage in milivolts +@@ -520,9 +533,11 @@ static int bq27x00_battery_get_property( + case POWER_SUPPLY_PROP_CAPACITY: + ret = bq27x00_simple_value(di->cache.capacity, val); + break; ++/* + case POWER_SUPPLY_PROP_CAPACITY_LEVEL: + ret = bq27x00_battery_capacity_level(di, val); + break; ++*/ + case POWER_SUPPLY_PROP_TEMP: + ret = bq27x00_simple_value(di->cache.temperature, val); + break; +@@ -547,12 +562,14 @@ static int bq27x00_battery_get_property( + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + ret = bq27x00_simple_value(di->charge_design_full, val); + break; ++/* + case POWER_SUPPLY_PROP_CYCLE_COUNT: + ret = bq27x00_simple_value(di->cache.cycle_count, val); + break; + case POWER_SUPPLY_PROP_ENERGY_NOW: + ret = bq27x00_simple_value(di->cache.energy, val); + break; ++*/ + default: + return -EINVAL; + } diff --git a/kernel-power-2.6.28/debian/patches/bq27x00-reg.diff b/kernel-power-2.6.28/debian/patches/bq27x00-reg.diff new file mode 100644 index 0000000..11a9950 --- /dev/null +++ b/kernel-power-2.6.28/debian/patches/bq27x00-reg.diff @@ -0,0 +1,205 @@ +diff --git a/drivers/power/bq27x00_battery.c b/drivers/power/bq27x00_battery.c +index 46db966..6a6224e 100644 +--- a/drivers/power/bq27x00_battery.c ++++ b/drivers/power/bq27x00_battery.c +@@ -29,12 +29,15 @@ + #include + #include + #include ++#include ++#include + #include + #include + #include + #include + #include + #include ++#include + + #include + +@@ -89,8 +92,34 @@ struct bq27x00_reg_cache { + int flags; + }; + ++#define BQ27X00_READ_REG _IO(MISC_MAJOR, 0) ++ ++/** ++ * struct bq27x00_reg_parms - User data for ioctl call BQ27X00_READ_REG ++ * @reg: Battery register ++ * @single: 1 if register is 8bit, 0 if 16bit ++ * @ret: value of register reg ++ * Ioctl call BQ27X00_READ_REG can be used to read battery register. ++ * If bq27x00_battery is loaded, it is not possible to use i2c-get ++ * to get status of battery registers, so this ioctl can be used. ++ */ ++struct bq27x00_reg_parms { ++ int reg; ++ int single; ++ int ret; ++}; ++ ++struct bq27x00_reg_device { ++ struct miscdevice miscdev; ++ struct bq27x00_device_info *di; ++ struct bq27x00_reg_device *next, *prev; ++}; ++ ++static struct bq27x00_reg_device *bq27x00_reg_devices = NULL; ++ + struct bq27x00_device_info { + struct device *dev; ++ struct bq27x00_reg_device *regdev; + int id; + enum bq27x00_chip chip; + +@@ -141,6 +153,109 @@ static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg, + return di->bus.read(di, reg, single); + } + ++/* Code for register device access */ ++ ++static long bq27x00_battery_reg_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) ++{ ++ int ret; ++ int minor = iminor(filp->f_dentry->d_inode); ++ struct bq27x00_reg_parms param; ++ struct bq27x00_reg_device *regdev = bq27x00_reg_devices; ++ ++ while (regdev) { ++ if (regdev->miscdev.minor == minor) ++ break; ++ regdev = regdev->next; ++ } ++ ++ if (!regdev) ++ return -ENXIO; ++ ++ if (cmd != BQ27X00_READ_REG) ++ return -EINVAL; ++ ++ ret = copy_from_user(¶m, (void __user *)arg, sizeof(param)); ++ if (ret != 0) ++ return -EACCES; ++ ++ param.ret = bq27x00_read(regdev->di, param.reg, param.single); ++ ++ ret = copy_to_user((void __user *)arg, ¶m, sizeof(param)); ++ if (ret != 0) ++ return -EACCES; ++ ++ return 0; ++} ++ ++static int bq27x00_battery_reg_open(struct inode *inode, struct file *file) ++{ ++ if (!try_module_get(THIS_MODULE)) ++ return -EPERM; ++ ++ return 0; ++} ++ ++static int bq27x00_battery_reg_release(struct inode *inode, struct file *file) ++{ ++ module_put(THIS_MODULE); ++ return 0; ++} ++ ++static struct file_operations bq27x00_reg_fileops = { ++ .owner = THIS_MODULE, ++ .unlocked_ioctl = bq27x00_battery_reg_ioctl, ++ .open = bq27x00_battery_reg_open, ++ .release = bq27x00_battery_reg_release, ++}; ++ ++static int bq27x00_battery_reg_init(struct bq27x00_device_info *di) ++{ ++ struct bq27x00_reg_device *regdev; ++ int ret; ++ ++ regdev = kzalloc(sizeof *regdev, GFP_KERNEL); ++ if (!regdev) ++ return -ENOMEM; ++ ++ regdev->miscdev.minor = MISC_DYNAMIC_MINOR; ++ regdev->miscdev.name = di->bat.name; ++ regdev->miscdev.fops = &bq27x00_reg_fileops; ++ regdev->di = di; ++ ++ ret = misc_register(®dev->miscdev); ++ if (ret != 0) { ++ kfree(regdev); ++ return ret; ++ } ++ ++ di->regdev = regdev; ++ ++ if (bq27x00_reg_devices) ++ bq27x00_reg_devices->prev = regdev; ++ ++ regdev->prev = NULL; ++ regdev->next = bq27x00_reg_devices; ++ bq27x00_reg_devices = regdev; ++ ++ return 0; ++} ++ ++static void bq27x00_battery_reg_exit(struct bq27x00_device_info *di) ++{ ++ misc_deregister(&di->regdev->miscdev); ++ ++ if (di->regdev->next) ++ di->regdev->next->prev = di->regdev->prev; ++ ++ if (di->regdev->prev) ++ di->regdev->prev->next = di->regdev->next; ++ ++ if (di->regdev == bq27x00_reg_devices) ++ bq27x00_reg_devices = NULL; ++ ++ kfree(di->regdev); ++} ++ + /* + * Return the battery Relative State-of-Charge + * Or < 0 if something fails. +@@ -839,6 +839,9 @@ static int bq27x00_battery_probe(struct + + i2c_set_clientdata(client, di); + ++ if (bq27x00_battery_reg_init(di)) ++ di->regdev = NULL; ++ + return 0; + + batt_failed_3: +@@ -859,6 +862,9 @@ static int bq27x00_battery_remove(struct + + bq27x00_powersupply_unregister(di); + ++ if (di->regdev) ++ bq27x00_battery_reg_exit(di); ++ + kfree(di->bat.name); + + mutex_lock(&battery_mutex); +@@ -829,6 +944,9 @@ static int __devinit bq27000_battery_probe(struct platform_device *pdev) + if (ret) + goto err_free; + ++ if (bq27x00_battery_reg_init(di)) ++ di->regdev = NULL; ++ + return 0; + + err_free: +@@ -844,6 +962,9 @@ static int __devexit bq27000_battery_remove(struct platform_device *pdev) + + bq27x00_powersupply_unregister(di); + ++ if (di->regdev) ++ bq27x00_battery_reg_exit(di); ++ + platform_set_drvdata(pdev, NULL); + kfree(di); + diff --git a/kernel-power-2.6.28/debian/patches/bq27x00-rx51-board.diff b/kernel-power-2.6.28/debian/patches/bq27x00-rx51-board.diff new file mode 100644 index 0000000..92e0619 --- /dev/null +++ b/kernel-power-2.6.28/debian/patches/bq27x00-rx51-board.diff @@ -0,0 +1,12 @@ +--- kernel-power-2.6.28/arch/arm/mach-omap2/board-rx51-peripherals.c 2011-01-23 03:53:13.000000000 +0100 ++++ kernel-power-2.6.28/arch/arm/mach-omap2/board-rx51-peripherals.c 2011-01-23 04:02:21.000000000 +0100 +@@ -572,6 +580,9 @@ static struct i2c_board_info __initdata + I2C_BOARD_INFO("tsl2563", 0x29), + .platform_data = &rx51_tsl2563_platform_data, + }, ++ { ++ I2C_BOARD_INFO("bq27200", 0x55), ++ }, + }; + + static struct i2c_board_info __initdata rx51_peripherals_i2c_board_info_3[] = { diff --git a/kernel-power-2.6.28/debian/patches/bq27x00-upstream.diff b/kernel-power-2.6.28/debian/patches/bq27x00-upstream.diff new file mode 100644 index 0000000..abe9637 --- /dev/null +++ b/kernel-power-2.6.28/debian/patches/bq27x00-upstream.diff @@ -0,0 +1,1027 @@ +--- kernel-power-2.6.28/drivers/power/bq27x00_battery.c 2011-09-15 00:34:44.600070307 +0200 ++++ kernel-power-2.6.28/drivers/power/bq27x00_battery.c 2011-09-21 13:16:45.007978008 +0200 +@@ -3,6 +3,8 @@ + * + * Copyright (C) 2008 Rodolfo Giometti + * Copyright (C) 2008 Eurotech S.p.A. ++ * Copyright (C) 2010-2011 Lars-Peter Clausen ++ * Copyright (C) 2011 Pali Rohár + * + * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc. + * +@@ -15,6 +17,13 @@ + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + */ ++ ++/* ++ * Datasheets: ++ * http://focus.ti.com/docs/prod/folders/print/bq27000.html ++ * http://focus.ti.com/docs/prod/folders/print/bq27500.html ++ */ ++ + #include + #include + #include +@@ -24,144 +33,455 @@ + #include + #include + #include ++#include + #include + +-#define DRIVER_VERSION "1.0.0" ++#include ++ ++#define DRIVER_VERSION "1.2.0" + + #define BQ27x00_REG_TEMP 0x06 + #define BQ27x00_REG_VOLT 0x08 +-#define BQ27x00_REG_RSOC 0x0B /* Relative State-of-Charge */ + #define BQ27x00_REG_AI 0x14 + #define BQ27x00_REG_FLAGS 0x0A ++#define BQ27x00_REG_TTE 0x16 ++#define BQ27x00_REG_TTF 0x18 ++#define BQ27x00_REG_TTECP 0x26 ++#define BQ27x00_REG_NAC 0x0C /* Nominal available capaciy */ ++#define BQ27x00_REG_LMD 0x12 /* Last measured discharge */ ++#define BQ27x00_REG_CYCT 0x2A /* Cycle count total */ ++#define BQ27x00_REG_AE 0x22 /* Available enery */ ++ ++#define BQ27000_REG_RSOC 0x0B /* Relative State-of-Charge */ ++#define BQ27000_REG_ILMD 0x76 /* Initial last measured discharge */ ++#define BQ27000_FLAG_EDVF BIT(0) /* Final End-of-Discharge-Voltage flag */ ++#define BQ27000_FLAG_EDV1 BIT(1) /* First End-of-Discharge-Voltage flag */ ++#define BQ27000_FLAG_CI BIT(4) /* Capacity Inaccurate flag */ ++#define BQ27000_FLAG_FC BIT(5) ++#define BQ27000_FLAG_CHGS BIT(7) /* Charge state flag */ ++ ++#define BQ27500_REG_SOC 0x2C ++#define BQ27500_REG_DCAP 0x3C /* Design capacity */ ++#define BQ27500_FLAG_DSG BIT(0) /* Discharging */ ++#define BQ27500_FLAG_SOCF BIT(1) /* State-of-Charge threshold final */ ++#define BQ27500_FLAG_SOC1 BIT(2) /* State-of-Charge threshold 1 */ ++#define BQ27500_FLAG_CHG BIT(8) /* Charging */ ++#define BQ27500_FLAG_FC BIT(9) /* Fully charged */ + +-/* If the system has several batteries we need a different name for each +- * of them... +- */ +-static DEFINE_IDR(battery_id); +-static DEFINE_MUTEX(battery_mutex); ++#define BQ27000_RS 20 /* Resistor sense */ + + struct bq27x00_device_info; + struct bq27x00_access_methods { +- int (*read)(u8 reg, int *rt_value, int b_single, +- struct bq27x00_device_info *di); ++ int (*read)(struct bq27x00_device_info *di, u8 reg, bool single); ++}; ++ ++enum bq27x00_chip { BQ27000, BQ27500 }; ++ ++struct bq27x00_reg_cache { ++ int temperature; ++ int time_to_empty; ++ int time_to_empty_avg; ++ int time_to_full; ++ int charge_full; ++ int cycle_count; ++ int capacity; ++ int energy; ++ int flags; + }; + + struct bq27x00_device_info { + struct device *dev; + int id; +- int voltage_uV; +- int current_uA; +- int temp_C; +- int charge_rsoc; +- struct bq27x00_access_methods *bus; ++ enum bq27x00_chip chip; ++ ++ struct bq27x00_reg_cache cache; ++ int charge_design_full; ++ ++ unsigned long last_update; ++ struct delayed_work work; ++ + struct power_supply bat; + +- struct i2c_client *client; ++ struct bq27x00_access_methods bus; ++ ++ struct mutex lock; + }; + + static enum power_supply_property bq27x00_battery_props[] = { ++ POWER_SUPPLY_PROP_STATUS, + POWER_SUPPLY_PROP_PRESENT, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_CURRENT_NOW, + POWER_SUPPLY_PROP_CAPACITY, ++ POWER_SUPPLY_PROP_CAPACITY_LEVEL, + POWER_SUPPLY_PROP_TEMP, ++ POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, ++ POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, ++ POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, ++ POWER_SUPPLY_PROP_TECHNOLOGY, ++ POWER_SUPPLY_PROP_CHARGE_FULL, ++ POWER_SUPPLY_PROP_CHARGE_NOW, ++ POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, ++ POWER_SUPPLY_PROP_CYCLE_COUNT, ++ POWER_SUPPLY_PROP_ENERGY_NOW, + }; + ++static unsigned int poll_interval = 360; ++module_param(poll_interval, uint, 0644); ++MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \ ++ "0 disables polling"); ++ + /* + * Common code for BQ27x00 devices + */ + +-static int bq27x00_read(u8 reg, int *rt_value, int b_single, +- struct bq27x00_device_info *di) ++static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg, ++ bool single) + { +- int ret; ++ return di->bus.read(di, reg, single); ++} + +- ret = di->bus->read(reg, rt_value, b_single, di); +- *rt_value = be16_to_cpu(*rt_value); ++/* ++ * Return the battery Relative State-of-Charge ++ * Or < 0 if something fails. ++ */ ++static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di) ++{ ++ int rsoc; + +- return ret; ++ if (di->chip == BQ27500) ++ rsoc = bq27x00_read(di, BQ27500_REG_SOC, false); ++ else ++ rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true); ++ ++ if (rsoc < 0) ++ dev_err(di->dev, "error reading relative State-of-Charge\n"); ++ ++ return rsoc; + } + + /* +- * Return the battery temperature in Celcius degrees ++ * Return a battery charge value in µAh + * Or < 0 if something fails. + */ +-static int bq27x00_battery_temperature(struct bq27x00_device_info *di) ++static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg) + { +- int ret; +- int temp = 0; ++ int charge; + +- ret = bq27x00_read(BQ27x00_REG_TEMP, &temp, 0, di); +- if (ret) { ++ charge = bq27x00_read(di, reg, false); ++ if (charge < 0) { ++ dev_err(di->dev, "error reading charge register %02x: %d\n", reg, charge); ++ return charge; ++ } ++ ++ if (di->chip == BQ27500) ++ charge *= 1000; ++ else ++ charge = charge * 3570 / BQ27000_RS; ++ ++ return charge; ++} ++ ++/* ++ * 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) ++{ ++ return bq27x00_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) ++{ ++ return bq27x00_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) ++{ ++ int ilmd; ++ ++ if (di->chip == BQ27500) ++ ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false); ++ else ++ ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true); ++ ++ if (ilmd < 0) { ++ dev_err(di->dev, "error reading initial last measured discharge\n"); ++ return ilmd; ++ } ++ ++ if (di->chip == BQ27500) ++ ilmd *= 1000; ++ else ++ ilmd = ilmd * 256 * 3570 / BQ27000_RS; ++ ++ return ilmd; ++} ++ ++/* ++ * Return the battery Available energy in µWh ++ * Or < 0 if something fails. ++ */ ++static int bq27x00_battery_read_energy(struct bq27x00_device_info *di) ++{ ++ int ae; ++ ++ ae = bq27x00_read(di, BQ27x00_REG_AE, false); ++ if (ae < 0) { ++ dev_err(di->dev, "error reading available energy\n"); ++ return ae; ++ } ++ ++ if (di->chip == BQ27500) ++ ae *= 1000; ++ else ++ ae = ae * 29200 / BQ27000_RS; ++ ++ return ae; ++} ++ ++/* ++ * Return the battery temperature in tenths of degree Celsius ++ * Or < 0 if something fails. ++ */ ++static int bq27x00_battery_read_temperature(struct bq27x00_device_info *di) ++{ ++ int temp; ++ ++ temp = bq27x00_read(di, BQ27x00_REG_TEMP, false); ++ if (temp < 0) { + dev_err(di->dev, "error reading temperature\n"); +- return ret; ++ return temp; + } + +- return (temp >> 2) - 273; ++ if (di->chip == BQ27500) ++ temp -= 2731; ++ else ++ temp = ((temp * 5) - 5463) / 2; ++ ++ return temp; + } + + /* +- * Return the battery Voltage in milivolts ++ * Return the battery Cycle count total + * Or < 0 if something fails. + */ +-static int bq27x00_battery_voltage(struct bq27x00_device_info *di) ++static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di) + { +- int ret; +- int volt = 0; ++ int cyct; + +- ret = bq27x00_read(BQ27x00_REG_VOLT, &volt, 0, di); +- if (ret) { +- dev_err(di->dev, "error reading voltage\n"); +- return ret; ++ cyct = bq27x00_read(di, BQ27x00_REG_CYCT, false); ++ if (cyct < 0) ++ dev_err(di->dev, "error reading cycle count total\n"); ++ ++ return cyct; ++} ++ ++/* ++ * Read a time register. ++ * Return < 0 if something fails. ++ */ ++static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg) ++{ ++ int tval; ++ ++ tval = bq27x00_read(di, reg, false); ++ if (tval < 0) { ++ dev_err(di->dev, "error reading time register %02x: %d\n", reg, tval); ++ return tval; ++ } ++ ++ if (tval == 65535) ++ return -ENODATA; ++ ++ return tval * 60; ++} ++ ++static void bq27x00_update(struct bq27x00_device_info *di) ++{ ++ struct bq27x00_reg_cache cache = {0, }; ++ bool is_bq27500 = di->chip == BQ27500; ++ ++ cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, is_bq27500); ++ if (cache.flags >= 0) { ++ if (!is_bq27500 && (cache.flags & BQ27000_FLAG_CI)) { ++ dev_err(di->dev, "battery is not calibrated! ignoring capacity values\n"); ++ cache.capacity = -ENODATA; ++ cache.energy = -ENODATA; ++ cache.time_to_empty = -ENODATA; ++ cache.time_to_empty_avg = -ENODATA; ++ cache.time_to_full = -ENODATA; ++ cache.charge_full = -ENODATA; ++ } else { ++ cache.capacity = bq27x00_battery_read_rsoc(di); ++ cache.energy = bq27x00_battery_read_energy(di); ++ cache.time_to_empty = bq27x00_battery_read_time(di, BQ27x00_REG_TTE); ++ cache.time_to_empty_avg = bq27x00_battery_read_time(di, BQ27x00_REG_TTECP); ++ cache.time_to_full = bq27x00_battery_read_time(di, BQ27x00_REG_TTF); ++ cache.charge_full = bq27x00_battery_read_lmd(di); ++ } ++ cache.temperature = bq27x00_battery_read_temperature(di); ++ cache.cycle_count = bq27x00_battery_read_cyct(di); ++ ++ /* We only have to read charge design full once */ ++ if (di->charge_design_full <= 0) ++ di->charge_design_full = bq27x00_battery_read_ilmd(di); ++ } ++ ++ if (memcmp(&di->cache, &cache, sizeof(cache)) != 0) { ++ di->cache = cache; ++ power_supply_changed(&di->bat); + } + +- return volt; ++ di->last_update = jiffies; ++} ++ ++static void bq27x00_battery_poll(struct work_struct *work) ++{ ++ struct bq27x00_device_info *di = ++ container_of(work, struct bq27x00_device_info, work.work); ++ ++ bq27x00_update(di); ++ ++ if (poll_interval > 0) { ++ /* The timer does not have to be accurate. */ ++ set_timer_slack(&di->work.timer, poll_interval * HZ / 4); ++ schedule_delayed_work(&di->work, poll_interval * HZ); ++ } + } + + /* +- * Return the battery average current ++ * Return the battery average current in µA + * 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 bq27x00_battery_current(struct bq27x00_device_info *di, ++ union power_supply_propval *val) + { +- int ret; +- int curr = 0; +- int flags = 0; ++ int curr; ++ int flags; + +- ret = bq27x00_read(BQ27x00_REG_AI, &curr, 0, di); +- if (ret) { +- dev_err(di->dev, "error reading current\n"); +- return 0; ++ curr = bq27x00_read(di, BQ27x00_REG_AI, false); ++ if (curr < 0) { ++ dev_err(di->dev, "error reading current"); ++ return curr; ++ } ++ ++ if (di->chip == BQ27500) { ++ /* bq27500 returns signed value */ ++ val->intval = (int)((s16)curr) * 1000; ++ } else { ++ flags = bq27x00_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; ++ } ++ ++ return 0; ++} ++ ++static int bq27x00_battery_status(struct bq27x00_device_info *di, ++ union power_supply_propval *val) ++{ ++ int status; ++ ++ if (di->chip == BQ27500) { ++ if (di->cache.flags & BQ27500_FLAG_FC) ++ status = POWER_SUPPLY_STATUS_FULL; ++ else if (di->cache.flags & BQ27500_FLAG_DSG) ++ status = POWER_SUPPLY_STATUS_DISCHARGING; ++ else if (di->cache.flags & BQ27500_FLAG_CHG) ++ status = POWER_SUPPLY_STATUS_CHARGING; ++ else if (power_supply_am_i_supplied(&di->bat)) ++ status = POWER_SUPPLY_STATUS_NOT_CHARGING; ++ else ++ status = POWER_SUPPLY_STATUS_UNKNOWN; ++ } else { ++ if (di->cache.flags & BQ27000_FLAG_FC) ++ status = POWER_SUPPLY_STATUS_FULL; ++ else if (di->cache.flags & BQ27000_FLAG_CHGS) ++ status = POWER_SUPPLY_STATUS_CHARGING; ++ else if (power_supply_am_i_supplied(&di->bat)) ++ status = POWER_SUPPLY_STATUS_NOT_CHARGING; ++ else ++ status = POWER_SUPPLY_STATUS_DISCHARGING; + } +- ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di); +- if (ret < 0) { +- dev_err(di->dev, "error reading flags\n"); +- return 0; +- } +- if ((flags & (1 << 7)) != 0) { +- dev_dbg(di->dev, "negative current!\n"); +- return -curr; ++ ++ val->intval = status; ++ ++ return 0; ++} ++ ++static int bq27x00_battery_capacity_level(struct bq27x00_device_info *di, ++ union power_supply_propval *val) ++{ ++ int level; ++ ++ if (di->chip == BQ27500) { ++ if (di->cache.flags & BQ27500_FLAG_FC) ++ level = POWER_SUPPLY_CAPACITY_LEVEL_FULL; ++ else if (di->cache.flags & BQ27500_FLAG_SOC1) ++ level = POWER_SUPPLY_CAPACITY_LEVEL_LOW; ++ else if (di->cache.flags & BQ27500_FLAG_SOCF) ++ level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; ++ else ++ level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; ++ } else { ++ if (di->cache.flags & BQ27000_FLAG_FC) ++ level = POWER_SUPPLY_CAPACITY_LEVEL_FULL; ++ else if (di->cache.flags & BQ27000_FLAG_EDV1) ++ level = POWER_SUPPLY_CAPACITY_LEVEL_LOW; ++ else if (di->cache.flags & BQ27000_FLAG_EDVF) ++ level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; ++ else ++ level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; + } +- return curr; ++ ++ val->intval = level; ++ ++ return 0; + } + + /* +- * Return the battery Relative State-of-Charge ++ * Return the battery Voltage in milivolts + * Or < 0 if something fails. + */ +-static int bq27x00_battery_rsoc(struct bq27x00_device_info *di) ++static int bq27x00_battery_voltage(struct bq27x00_device_info *di, ++ union power_supply_propval *val) + { +- int ret; +- int rsoc = 0; ++ int volt; + +- ret = bq27x00_read(BQ27x00_REG_RSOC, &rsoc, 1, di); +- if (ret) { +- dev_err(di->dev, "error reading relative State-of-Charge\n"); +- return ret; ++ volt = bq27x00_read(di, BQ27x00_REG_VOLT, false); ++ if (volt < 0) { ++ dev_err(di->dev, "error reading voltage\n"); ++ return volt; + } + +- return rsoc >> 8; ++ val->intval = volt * 1000; ++ ++ return 0; ++} ++ ++static int bq27x00_simple_value(int value, ++ union power_supply_propval *val) ++{ ++ if (value < 0) ++ return value; ++ ++ val->intval = value; ++ ++ return 0; + } + + #define to_bq27x00_device_info(x) container_of((x), \ +@@ -171,89 +491,167 @@ static int bq27x00_battery_get_property( + enum power_supply_property psp, + union power_supply_propval *val) + { ++ int ret = 0; + struct bq27x00_device_info *di = to_bq27x00_device_info(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); ++ } ++ mutex_unlock(&di->lock); ++ ++ if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0) ++ return -ENODEV; ++ + switch (psp) { ++ case POWER_SUPPLY_PROP_STATUS: ++ ret = bq27x00_battery_status(di, val); ++ break; + case POWER_SUPPLY_PROP_VOLTAGE_NOW: ++ ret = bq27x00_battery_voltage(di, val); ++ break; + case POWER_SUPPLY_PROP_PRESENT: +- val->intval = bq27x00_battery_voltage(di); +- if (psp == POWER_SUPPLY_PROP_PRESENT) +- val->intval = val->intval <= 0 ? 0 : 1; ++ val->intval = di->cache.flags < 0 ? 0 : 1; + break; + case POWER_SUPPLY_PROP_CURRENT_NOW: +- val->intval = bq27x00_battery_current(di); ++ ret = bq27x00_battery_current(di, val); + break; + case POWER_SUPPLY_PROP_CAPACITY: +- val->intval = bq27x00_battery_rsoc(di); ++ ret = bq27x00_simple_value(di->cache.capacity, val); ++ break; ++ case POWER_SUPPLY_PROP_CAPACITY_LEVEL: ++ ret = bq27x00_battery_capacity_level(di, val); + break; + case POWER_SUPPLY_PROP_TEMP: +- val->intval = bq27x00_battery_temperature(di); ++ ret = bq27x00_simple_value(di->cache.temperature, val); ++ break; ++ case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: ++ ret = bq27x00_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); ++ break; ++ case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW: ++ ret = bq27x00_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); ++ break; ++ case POWER_SUPPLY_PROP_CHARGE_FULL: ++ ret = bq27x00_simple_value(di->cache.charge_full, val); ++ break; ++ case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: ++ ret = bq27x00_simple_value(di->charge_design_full, val); ++ break; ++ case POWER_SUPPLY_PROP_CYCLE_COUNT: ++ ret = bq27x00_simple_value(di->cache.cycle_count, val); ++ break; ++ case POWER_SUPPLY_PROP_ENERGY_NOW: ++ ret = bq27x00_simple_value(di->cache.energy, val); + break; + default: + return -EINVAL; + } + +- return 0; ++ return ret; + } + +-static void bq27x00_powersupply_init(struct bq27x00_device_info *di) ++static void bq27x00_external_power_changed(struct power_supply *psy) + { ++ struct bq27x00_device_info *di = to_bq27x00_device_info(psy); ++ ++ cancel_delayed_work_sync(&di->work); ++ schedule_delayed_work(&di->work, 0); ++} ++ ++static int bq27x00_powersupply_init(struct bq27x00_device_info *di) ++{ ++ int ret; ++ + di->bat.type = POWER_SUPPLY_TYPE_BATTERY; + di->bat.properties = bq27x00_battery_props; + di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props); + di->bat.get_property = bq27x00_battery_get_property; +- di->bat.external_power_changed = NULL; ++ di->bat.external_power_changed = bq27x00_external_power_changed; ++ ++ INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll); ++ mutex_init(&di->lock); ++ ++ ret = power_supply_register(di->dev, &di->bat); ++ if (ret) { ++ dev_err(di->dev, "failed to register battery: %d\n", ret); ++ return ret; ++ } ++ ++ dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION); ++ ++ bq27x00_update(di); ++ ++ return 0; + } + +-/* +- * BQ27200 specific code ++static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di) ++{ ++ cancel_delayed_work_sync(&di->work); ++ ++ power_supply_unregister(&di->bat); ++ ++ mutex_destroy(&di->lock); ++} ++ ++ ++/* i2c specific code */ ++#ifdef CONFIG_BATTERY_BQ27X00_I2C ++ ++/* If the system has several batteries we need a different name for each ++ * of them... + */ ++static DEFINE_IDR(battery_id); ++static DEFINE_MUTEX(battery_mutex); + +-static int bq27200_read(u8 reg, int *rt_value, int b_single, +- struct bq27x00_device_info *di) ++static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single) + { +- struct i2c_client *client = di->client; +- struct i2c_msg msg[1]; ++ struct i2c_client *client = to_i2c_client(di->dev); ++ struct i2c_msg msg[2]; + unsigned char data[2]; +- int err; ++ int ret; + + if (!client->adapter) + return -ENODEV; + +- msg->addr = client->addr; +- msg->flags = 0; +- msg->len = 1; +- msg->buf = data; +- +- data[0] = reg; +- err = i2c_transfer(client->adapter, msg, 1); +- +- if (err >= 0) { +- if (!b_single) +- msg->len = 2; +- else +- msg->len = 1; ++ msg[0].addr = client->addr; ++ msg[0].flags = 0; ++ msg[0].buf = ® ++ msg[0].len = sizeof(reg); ++ msg[1].addr = client->addr; ++ msg[1].flags = I2C_M_RD; ++ msg[1].buf = data; ++ if (single) ++ msg[1].len = 1; ++ else ++ msg[1].len = 2; + +- msg->flags = I2C_M_RD; +- err = i2c_transfer(client->adapter, msg, 1); +- if (err >= 0) { +- if (!b_single) +- *rt_value = get_unaligned_be16(data); +- else +- *rt_value = data[0]; ++ ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); ++ if (ret < 0) ++ return ret; + +- return 0; +- } +- } +- return err; ++ if (!single) ++ ret = get_unaligned_le16(data); ++ else ++ ret = data[0]; ++ ++ return ret; + } + +-static int bq27200_battery_probe(struct i2c_client *client, ++static int bq27x00_battery_probe(struct i2c_client *client, + const struct i2c_device_id *id) + { + char *name; + struct bq27x00_device_info *di; +- struct bq27x00_access_methods *bus; + int num; + int retval = 0; + +@@ -267,7 +665,7 @@ static int bq27200_battery_probe(struct + if (retval < 0) + return retval; + +- name = kasprintf(GFP_KERNEL, "bq27200-%d", num); ++ name = kasprintf(GFP_KERNEL, "%s-%d", id->name, num); + if (!name) { + dev_err(&client->dev, "failed to allocate device name\n"); + retval = -ENOMEM; +@@ -280,37 +678,20 @@ static int bq27200_battery_probe(struct + retval = -ENOMEM; + goto batt_failed_2; + } +- di->id = num; + +- bus = kzalloc(sizeof(*bus), GFP_KERNEL); +- if (!bus) { +- dev_err(&client->dev, "failed to allocate access method " +- "data\n"); +- retval = -ENOMEM; +- goto batt_failed_3; +- } +- +- i2c_set_clientdata(client, di); ++ di->id = num; + di->dev = &client->dev; ++ di->chip = id->driver_data; + di->bat.name = name; +- bus->read = &bq27200_read; +- di->bus = bus; +- di->client = client; ++ di->bus.read = &bq27x00_read_i2c; + +- bq27x00_powersupply_init(di); +- +- retval = power_supply_register(&client->dev, &di->bat); +- if (retval) { +- dev_err(&client->dev, "failed to register battery\n"); +- goto batt_failed_4; +- } ++ if (bq27x00_powersupply_init(di)) ++ goto batt_failed_3; + +- dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION); ++ i2c_set_clientdata(client, di); + + return 0; + +-batt_failed_4: +- kfree(bus); + batt_failed_3: + kfree(di); + batt_failed_2: +@@ -323,11 +704,11 @@ batt_failed_1: + return retval; + } + +-static int bq27200_battery_remove(struct i2c_client *client) ++static int bq27x00_battery_remove(struct i2c_client *client) + { + struct bq27x00_device_info *di = i2c_get_clientdata(client); + +- power_supply_unregister(&di->bat); ++ bq27x00_powersupply_unregister(di); + + kfree(di->bat.name); + +@@ -340,31 +721,180 @@ static int bq27200_battery_remove(struct + return 0; + } + +-/* +- * Module stuff +- */ +- +-static const struct i2c_device_id bq27200_id[] = { +- { "bq27200", 0 }, ++static const struct i2c_device_id bq27x00_id[] = { ++ { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */ ++ { "bq27500", BQ27500 }, + {}, + }; ++MODULE_DEVICE_TABLE(i2c, bq27x00_id); ++ ++static struct i2c_driver bq27x00_battery_driver = { ++ .driver = { ++ .name = "bq27x00-battery", ++ }, ++ .probe = bq27x00_battery_probe, ++ .remove = bq27x00_battery_remove, ++ .id_table = bq27x00_id, ++}; ++ ++static inline int bq27x00_battery_i2c_init(void) ++{ ++ int ret = i2c_add_driver(&bq27x00_battery_driver); ++ if (ret) ++ printk(KERN_ERR "Unable to register BQ27x00 i2c driver\n"); ++ ++ return ret; ++} ++ ++static inline void bq27x00_battery_i2c_exit(void) ++{ ++ i2c_del_driver(&bq27x00_battery_driver); ++} ++ ++#else ++ ++static inline int bq27x00_battery_i2c_init(void) { return 0; } ++static inline void bq27x00_battery_i2c_exit(void) {}; ++ ++#endif ++ ++/* platform specific code */ ++#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM ++ ++static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg, ++ bool single) ++{ ++ struct device *dev = di->dev; ++ struct bq27000_platform_data *pdata = dev->platform_data; ++ unsigned int timeout = 3; ++ int upper, lower; ++ int temp; ++ ++ if (!single) { ++ /* Make sure the value has not changed in between reading the ++ * lower and the upper part */ ++ upper = pdata->read(dev, reg + 1); ++ do { ++ temp = upper; ++ if (upper < 0) ++ return upper; ++ ++ lower = pdata->read(dev, reg); ++ if (lower < 0) ++ return lower; ++ ++ upper = pdata->read(dev, reg + 1); ++ } while (temp != upper && --timeout); ++ ++ if (timeout == 0) ++ return -EIO; ++ ++ return (upper << 8) | lower; ++ } ++ ++ return pdata->read(dev, reg); ++} ++ ++static int __devinit bq27000_battery_probe(struct platform_device *pdev) ++{ ++ struct bq27x00_device_info *di; ++ struct bq27000_platform_data *pdata = pdev->dev.platform_data; ++ int ret; ++ ++ if (!pdata) { ++ dev_err(&pdev->dev, "no platform_data supplied\n"); ++ return -EINVAL; ++ } ++ ++ if (!pdata->read) { ++ dev_err(&pdev->dev, "no hdq read callback supplied\n"); ++ return -EINVAL; ++ } ++ ++ di = kzalloc(sizeof(*di), GFP_KERNEL); ++ if (!di) { ++ dev_err(&pdev->dev, "failed to allocate device info data\n"); ++ return -ENOMEM; ++ } ++ ++ platform_set_drvdata(pdev, di); ++ ++ di->dev = &pdev->dev; ++ di->chip = BQ27000; ++ ++ di->bat.name = pdata->name ?: dev_name(&pdev->dev); ++ di->bus.read = &bq27000_read_platform; + +-static struct i2c_driver bq27200_battery_driver = { ++ ret = bq27x00_powersupply_init(di); ++ if (ret) ++ goto err_free; ++ ++ return 0; ++ ++err_free: ++ platform_set_drvdata(pdev, NULL); ++ kfree(di); ++ ++ return ret; ++} ++ ++static int __devexit bq27000_battery_remove(struct platform_device *pdev) ++{ ++ struct bq27x00_device_info *di = platform_get_drvdata(pdev); ++ ++ bq27x00_powersupply_unregister(di); ++ ++ platform_set_drvdata(pdev, NULL); ++ kfree(di); ++ ++ return 0; ++} ++ ++static struct platform_driver bq27000_battery_driver = { ++ .probe = bq27000_battery_probe, ++ .remove = __devexit_p(bq27000_battery_remove), + .driver = { +- .name = "bq27200-battery", ++ .name = "bq27000-battery", ++ .owner = THIS_MODULE, + }, +- .probe = bq27200_battery_probe, +- .remove = bq27200_battery_remove, +- .id_table = bq27200_id, + }; + ++static inline int bq27x00_battery_platform_init(void) ++{ ++ int ret = platform_driver_register(&bq27000_battery_driver); ++ if (ret) ++ printk(KERN_ERR "Unable to register BQ27000 platform driver\n"); ++ ++ return ret; ++} ++ ++static inline void bq27x00_battery_platform_exit(void) ++{ ++ platform_driver_unregister(&bq27000_battery_driver); ++} ++ ++#else ++ ++static inline int bq27x00_battery_platform_init(void) { return 0; } ++static inline void bq27x00_battery_platform_exit(void) {}; ++ ++#endif ++ ++/* ++ * Module stuff ++ */ ++ + static int __init bq27x00_battery_init(void) + { + int ret; + +- ret = i2c_add_driver(&bq27200_battery_driver); ++ ret = bq27x00_battery_i2c_init(); ++ if (ret) ++ return ret; ++ ++ ret = bq27x00_battery_platform_init(); + if (ret) +- printk(KERN_ERR "Unable to register BQ27200 driver\n"); ++ bq27x00_battery_i2c_exit(); + + return ret; + } +@@ -372,7 +902,8 @@ module_init(bq27x00_battery_init); + + static void __exit bq27x00_battery_exit(void) + { +- i2c_del_driver(&bq27200_battery_driver); ++ bq27x00_battery_platform_exit(); ++ bq27x00_battery_i2c_exit(); + } + module_exit(bq27x00_battery_exit); + diff --git a/kernel-power-2.6.28/debian/patches/bq27x00_battery.diff b/kernel-power-2.6.28/debian/patches/bq27x00_battery.diff deleted file mode 100644 index b46ed98..0000000 --- a/kernel-power-2.6.28/debian/patches/bq27x00_battery.diff +++ /dev/null @@ -1,974 +0,0 @@ ---- kernel-power-2.6.28/drivers/power/bq27x00_battery.c 2011-05-01 01:48:44.000000000 +0200 -+++ kernel-power-2.6.28/drivers/power/bq27x00_battery.c 2011-05-01 01:51:12.000000000 +0200 -@@ -3,6 +3,8 @@ - * - * Copyright (C) 2008 Rodolfo Giometti - * Copyright (C) 2008 Eurotech S.p.A. -+ * Copyright (C) 2010-2011 Lars-Peter Clausen -+ * Copyright (C) 2011 Pali Rohár - * - * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc. - * -@@ -15,6 +17,13 @@ - * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - * - */ -+ -+/* -+ * Datasheets: -+ * http://focus.ti.com/docs/prod/folders/print/bq27000.html -+ * http://focus.ti.com/docs/prod/folders/print/bq27500.html -+ */ -+ - #include - #include - #include -@@ -24,144 +33,407 @@ - #include - #include - #include -+#include - #include - --#define DRIVER_VERSION "1.0.0" -+#define CONFIG_BATTERY_BQ27X00_I2C -+ -+struct bq27000_platform_data { -+ const char *name; -+ int (*read)(struct device *dev, unsigned int); -+}; -+ -+#define DRIVER_VERSION "1.2.0" - - #define BQ27x00_REG_TEMP 0x06 - #define BQ27x00_REG_VOLT 0x08 --#define BQ27x00_REG_RSOC 0x0B /* Relative State-of-Charge */ - #define BQ27x00_REG_AI 0x14 - #define BQ27x00_REG_FLAGS 0x0A -+#define BQ27x00_REG_TTE 0x16 -+#define BQ27x00_REG_TTF 0x18 -+#define BQ27x00_REG_TTECP 0x26 -+#define BQ27x00_REG_NAC 0x0C /* Nominal available capaciy */ -+#define BQ27x00_REG_LMD 0x12 /* Last measured discharge */ -+#define BQ27x00_REG_CYCT 0x2A /* Cycle count total */ -+#define BQ27x00_REG_AE 0x22 /* Available enery */ -+ -+#define BQ27000_REG_RSOC 0x0B /* Relative State-of-Charge */ -+#define BQ27000_REG_ILMD 0x76 /* Initial last measured discharge */ -+#define BQ27000_FLAG_CHGS BIT(7) -+#define BQ27000_FLAG_FC BIT(5) -+ -+#define BQ27500_REG_SOC 0x2C -+#define BQ27500_REG_DCAP 0x3C /* Design capacity */ -+#define BQ27500_FLAG_DSC BIT(0) -+#define BQ27500_FLAG_FC BIT(9) - --/* If the system has several batteries we need a different name for each -- * of them... -- */ --static DEFINE_IDR(battery_id); --static DEFINE_MUTEX(battery_mutex); -+#define BQ27000_RS 20 /* Resistor sense */ - - struct bq27x00_device_info; - struct bq27x00_access_methods { -- int (*read)(u8 reg, int *rt_value, int b_single, -- struct bq27x00_device_info *di); -+ int (*read)(struct bq27x00_device_info *di, u8 reg, bool single); -+}; -+ -+enum bq27x00_chip { BQ27000, BQ27500 }; -+ -+struct bq27x00_reg_cache { -+ int temperature; -+ int time_to_empty; -+ int time_to_empty_avg; -+ int time_to_full; -+ int charge_full; -+ int capacity; -+ int flags; -+ -+ int current_now; - }; - - struct bq27x00_device_info { - struct device *dev; - int id; -- int voltage_uV; -- int current_uA; -- int temp_C; -- int charge_rsoc; -- struct bq27x00_access_methods *bus; -+ enum bq27x00_chip chip; -+ -+ struct bq27x00_reg_cache cache; -+ int charge_design_full; -+ -+ unsigned long last_update; -+ struct delayed_work work; -+ - struct power_supply bat; - -- struct i2c_client *client; -+ struct bq27x00_access_methods bus; -+ -+ struct mutex lock; - }; - - static enum power_supply_property bq27x00_battery_props[] = { -+ POWER_SUPPLY_PROP_STATUS, - POWER_SUPPLY_PROP_PRESENT, - POWER_SUPPLY_PROP_VOLTAGE_NOW, - POWER_SUPPLY_PROP_CURRENT_NOW, - POWER_SUPPLY_PROP_CAPACITY, - POWER_SUPPLY_PROP_TEMP, -+ POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, -+ POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, -+ POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, -+ POWER_SUPPLY_PROP_TECHNOLOGY, -+ POWER_SUPPLY_PROP_CHARGE_FULL, -+ POWER_SUPPLY_PROP_CHARGE_NOW, -+ POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, - }; - -+static unsigned int poll_interval = 360; -+module_param(poll_interval, uint, 0644); -+MODULE_PARM_DESC(poll_interval, "battery poll interval in seconds - " \ -+ "0 disables polling"); -+ - /* - * Common code for BQ27x00 devices - */ - --static int bq27x00_read(u8 reg, int *rt_value, int b_single, -- struct bq27x00_device_info *di) -+static inline int bq27x00_read(struct bq27x00_device_info *di, u8 reg, -+ bool single) - { -- int ret; -+ return di->bus.read(di, reg, single); -+} -+ -+/* -+ * Return the battery Relative State-of-Charge -+ * Or < 0 if something fails. -+ */ -+static int bq27x00_battery_read_rsoc(struct bq27x00_device_info *di) -+{ -+ int rsoc; - -- ret = di->bus->read(reg, rt_value, b_single, di); -- *rt_value = be16_to_cpu(*rt_value); -+ if (di->chip == BQ27500) -+ rsoc = bq27x00_read(di, BQ27500_REG_SOC, false); -+ else -+ rsoc = bq27x00_read(di, BQ27000_REG_RSOC, true); - -- return ret; -+ if (rsoc < 0) -+ dev_err(di->dev, "error reading relative State-of-Charge\n"); -+ -+ return rsoc; - } - - /* -- * Return the battery temperature in Celcius degrees -+ * Return a battery charge value in µAh - * Or < 0 if something fails. - */ --static int bq27x00_battery_temperature(struct bq27x00_device_info *di) -+static int bq27x00_battery_read_charge(struct bq27x00_device_info *di, u8 reg) - { -- int ret; -- int temp = 0; -+ int charge; - -- ret = bq27x00_read(BQ27x00_REG_TEMP, &temp, 0, di); -- if (ret) { -- dev_err(di->dev, "error reading temperature\n"); -- return ret; -+ charge = bq27x00_read(di, reg, false); -+ if (charge < 0) { -+ dev_err(di->dev, "error reading nominal available capacity\n"); -+ return charge; - } - -- return (temp >> 2) - 273; -+ if (di->chip == BQ27500) -+ charge *= 1000; -+ else -+ charge = charge * 3570 / BQ27000_RS; -+ -+ return charge; - } - - /* -- * Return the battery Voltage in milivolts -+ * Return the battery Nominal available capaciy in µAh - * Or < 0 if something fails. - */ --static int bq27x00_battery_voltage(struct bq27x00_device_info *di) -+static inline int bq27x00_battery_read_nac(struct bq27x00_device_info *di) - { -- int ret; -- int volt = 0; -+ return bq27x00_battery_read_charge(di, BQ27x00_REG_NAC); -+} - -- ret = bq27x00_read(BQ27x00_REG_VOLT, &volt, 0, di); -- if (ret) { -- dev_err(di->dev, "error reading voltage\n"); -- return ret; -+/* -+ * 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) -+{ -+ return bq27x00_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) -+{ -+ int ilmd; -+ -+ if (di->chip == BQ27500) -+ ilmd = bq27x00_read(di, BQ27500_REG_DCAP, false); -+ else -+ ilmd = bq27x00_read(di, BQ27000_REG_ILMD, true); -+ -+ if (ilmd < 0) { -+ dev_err(di->dev, "error reading initial last measured discharge\n"); -+ return ilmd; - } - -- return volt; -+ if (di->chip == BQ27500) -+ ilmd *= 1000; -+ else -+ ilmd = ilmd * 256 * 3570 / BQ27000_RS; -+ -+ return ilmd; - } - - /* -- * Return the battery average current -- * Note that current can be negative signed as well -- * Or 0 if something fails. -+ * Return the battery Cycle count total -+ * Or < 0 if something fails. - */ --static int bq27x00_battery_current(struct bq27x00_device_info *di) -+static int bq27x00_battery_read_cyct(struct bq27x00_device_info *di) - { -- int ret; -- int curr = 0; -- int flags = 0; -+ int cyct; - -- ret = bq27x00_read(BQ27x00_REG_AI, &curr, 0, di); -- if (ret) { -- dev_err(di->dev, "error reading current\n"); -- return 0; -+ cyct = bq27x00_read(di, BQ27x00_REG_CYCT, false); -+ if (cyct < 0) -+ dev_err(di->dev, "error reading cycle count total\n"); -+ -+ return cyct; -+} -+ -+/* -+ * Read a time register. -+ * Return < 0 if something fails. -+ */ -+static int bq27x00_battery_read_time(struct bq27x00_device_info *di, u8 reg) -+{ -+ int tval; -+ -+ tval = bq27x00_read(di, reg, false); -+ if (tval < 0) { -+ dev_err(di->dev, "error reading register %02x: %d\n", reg, tval); -+ return tval; - } -- ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di); -- if (ret < 0) { -- dev_err(di->dev, "error reading flags\n"); -+ -+ if (tval == 65535) - return 0; -+ -+ return tval * 60; -+} -+ -+static void bq27x00_update(struct bq27x00_device_info *di) -+{ -+ struct bq27x00_reg_cache cache = {0, }; -+ bool is_bq27500 = di->chip == BQ27500; -+ -+ cache.flags = bq27x00_read(di, BQ27x00_REG_FLAGS, is_bq27500); -+ if (cache.flags >= 0) { -+ cache.capacity = bq27x00_battery_read_rsoc(di); -+ cache.temperature = bq27x00_read(di, BQ27x00_REG_TEMP, false); -+ cache.time_to_empty = bq27x00_battery_read_time(di, BQ27x00_REG_TTE); -+ cache.time_to_empty_avg = bq27x00_battery_read_time(di, BQ27x00_REG_TTECP); -+ cache.time_to_full = bq27x00_battery_read_time(di, BQ27x00_REG_TTF); -+ cache.charge_full = bq27x00_battery_read_lmd(di); -+ -+ if (!is_bq27500) -+ cache.current_now = bq27x00_read(di, BQ27x00_REG_AI, false); -+ -+ /* We only have to read charge design full once */ -+ if (di->charge_design_full <= 0) -+ di->charge_design_full = bq27x00_battery_read_ilmd(di); - } -- if ((flags & (1 << 7)) != 0) { -- dev_dbg(di->dev, "negative current!\n"); -- return -curr; -+ -+ /* Ignore current_now which is a snapshot of the current battery state -+ * and is likely to be different even between two consecutive reads */ -+ if (memcmp(&di->cache, &cache, sizeof(cache) - sizeof(int)) != 0) { -+ di->cache = cache; -+ power_supply_changed(&di->bat); -+ } -+ -+ di->last_update = jiffies; -+} -+ -+static void bq27x00_battery_poll(struct work_struct *work) -+{ -+ struct bq27x00_device_info *di = -+ container_of(work, struct bq27x00_device_info, work.work); -+ -+ bq27x00_update(di); -+ -+ if (poll_interval > 0) { -+ schedule_delayed_work(&di->work, poll_interval * HZ); - } -- return curr; - } - -+ - /* -- * Return the battery Relative State-of-Charge -+ * Return the battery temperature in tenths of degree Celsius - * Or < 0 if something fails. - */ --static int bq27x00_battery_rsoc(struct bq27x00_device_info *di) -+static int bq27x00_battery_temperature(struct bq27x00_device_info *di, -+ union power_supply_propval *val) - { -- int ret; -- int rsoc = 0; -+ if (di->cache.temperature < 0) -+ return di->cache.temperature; - -- ret = bq27x00_read(BQ27x00_REG_RSOC, &rsoc, 1, di); -- if (ret) { -- dev_err(di->dev, "error reading relative State-of-Charge\n"); -- return ret; -+ if (di->chip == BQ27500) -+ val->intval = di->cache.temperature - 2731; -+ else -+ val->intval = ((di->cache.temperature * 5) - 5463) / 2; -+ -+ return 0; -+} -+ -+/* -+ * Return the battery average current in µA -+ * Note that current can be negative signed as well -+ * Or 0 if something fails. -+ */ -+static int bq27x00_battery_current(struct bq27x00_device_info *di, -+ union power_supply_propval *val) -+{ -+ int curr; -+ -+ if (di->chip == BQ27500) -+ curr = bq27x00_read(di, BQ27x00_REG_AI, false); -+ else -+ curr = di->cache.current_now; -+ -+ if (curr < 0) -+ return curr; -+ -+ if (di->chip == BQ27500) { -+ /* bq27500 returns signed value */ -+ val->intval = (int)((s16)curr) * 1000; -+ } else { -+ if (di->cache.flags & BQ27000_FLAG_CHGS) { -+ dev_dbg(di->dev, "negative current!\n"); -+ curr = -curr; -+ } -+ -+ val->intval = curr * 3570 / BQ27000_RS; - } - -- return rsoc >> 8; -+ return 0; -+} -+ -+static int bq27x00_battery_status(struct bq27x00_device_info *di, -+ union power_supply_propval *val) -+{ -+ int status; -+ -+ if (di->chip == BQ27500) { -+ if (di->cache.flags & BQ27500_FLAG_FC) -+ status = POWER_SUPPLY_STATUS_FULL; -+ else if (di->cache.flags & BQ27500_FLAG_DSC) -+ status = POWER_SUPPLY_STATUS_DISCHARGING; -+ else -+ status = POWER_SUPPLY_STATUS_CHARGING; -+ } else { -+ if (di->cache.flags & BQ27000_FLAG_FC) -+ status = POWER_SUPPLY_STATUS_FULL; -+ else if (di->cache.flags & BQ27000_FLAG_CHGS) -+ status = POWER_SUPPLY_STATUS_CHARGING; -+ else if (power_supply_am_i_supplied(&di->bat)) -+ status = POWER_SUPPLY_STATUS_NOT_CHARGING; -+ else -+ status = POWER_SUPPLY_STATUS_DISCHARGING; -+ } -+ -+ val->intval = status; -+ -+ return 0; -+} -+ -+/* -+ * Return the battery Voltage in milivolts -+ * Or < 0 if something fails. -+ */ -+static int bq27x00_battery_voltage(struct bq27x00_device_info *di, -+ union power_supply_propval *val) -+{ -+ int volt; -+ -+ volt = bq27x00_read(di, BQ27x00_REG_VOLT, false); -+ if (volt < 0) -+ return volt; -+ -+ val->intval = volt * 1000; -+ -+ return 0; -+} -+ -+/* -+ * Return the battery Available energy in µWh -+ * Or < 0 if something fails. -+ */ -+static int bq27x00_battery_energy(struct bq27x00_device_info *di, -+ union power_supply_propval *val) -+{ -+ int ae; -+ -+ ae = bq27x00_read(di, BQ27x00_REG_AE, false); -+ if (ae < 0) { -+ dev_err(di->dev, "error reading available energy\n"); -+ return ae; -+ } -+ -+ if (di->chip == BQ27500) -+ ae *= 1000; -+ else -+ ae = ae * 29200 / BQ27000_RS; -+ -+ val->intval = ae; -+ -+ return 0; -+} -+ -+ -+static int bq27x00_simple_value(int value, -+ union power_supply_propval *val) -+{ -+ if (value < 0) -+ return value; -+ -+ val->intval = value; -+ -+ return 0; - } - - #define to_bq27x00_device_info(x) container_of((x), \ -@@ -171,89 +443,161 @@ static int bq27x00_battery_get_property( - enum power_supply_property psp, - union power_supply_propval *val) - { -+ int ret = 0; - struct bq27x00_device_info *di = to_bq27x00_device_info(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); -+ } -+ mutex_unlock(&di->lock); -+ -+ if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0) -+ return -ENODEV; -+ - switch (psp) { -+ case POWER_SUPPLY_PROP_STATUS: -+ ret = bq27x00_battery_status(di, val); -+ break; - case POWER_SUPPLY_PROP_VOLTAGE_NOW: -+ ret = bq27x00_battery_voltage(di, val); -+ break; - case POWER_SUPPLY_PROP_PRESENT: -- val->intval = bq27x00_battery_voltage(di); -- if (psp == POWER_SUPPLY_PROP_PRESENT) -- val->intval = val->intval <= 0 ? 0 : 1; -+ val->intval = di->cache.flags < 0 ? 0 : 1; - break; - case POWER_SUPPLY_PROP_CURRENT_NOW: -- val->intval = bq27x00_battery_current(di); -+ ret = bq27x00_battery_current(di, val); - break; - case POWER_SUPPLY_PROP_CAPACITY: -- val->intval = bq27x00_battery_rsoc(di); -+ ret = bq27x00_simple_value(di->cache.capacity, val); - break; - case POWER_SUPPLY_PROP_TEMP: -- val->intval = bq27x00_battery_temperature(di); -+ ret = bq27x00_battery_temperature(di, val); -+ break; -+ case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: -+ ret = bq27x00_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); -+ break; -+ case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW: -+ ret = bq27x00_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); -+ break; -+ case POWER_SUPPLY_PROP_CHARGE_FULL: -+ ret = bq27x00_simple_value(di->cache.charge_full, val); -+ break; -+ case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: -+ ret = bq27x00_simple_value(di->charge_design_full, val); -+ break; -+ case POWER_SUPPLY_PROP_ENERGY_NOW: -+ ret = bq27x00_battery_energy(di, val); - break; - default: - return -EINVAL; - } - -- return 0; -+ return ret; - } - --static void bq27x00_powersupply_init(struct bq27x00_device_info *di) -+static void bq27x00_external_power_changed(struct power_supply *psy) - { -+ struct bq27x00_device_info *di = to_bq27x00_device_info(psy); -+ -+ cancel_delayed_work_sync(&di->work); -+ schedule_delayed_work(&di->work, 0); -+} -+ -+static int bq27x00_powersupply_init(struct bq27x00_device_info *di) -+{ -+ int ret; -+ - di->bat.type = POWER_SUPPLY_TYPE_BATTERY; - di->bat.properties = bq27x00_battery_props; - di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props); - di->bat.get_property = bq27x00_battery_get_property; -- di->bat.external_power_changed = NULL; -+ di->bat.external_power_changed = bq27x00_external_power_changed; -+ -+ INIT_DELAYED_WORK(&di->work, bq27x00_battery_poll); -+ mutex_init(&di->lock); -+ -+ ret = power_supply_register(di->dev, &di->bat); -+ if (ret) { -+ dev_err(di->dev, "failed to register battery: %d\n", ret); -+ return ret; -+ } -+ -+ dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION); -+ -+ bq27x00_update(di); -+ -+ return 0; - } - --/* -- * BQ27200 specific code -+static void bq27x00_powersupply_unregister(struct bq27x00_device_info *di) -+{ -+ cancel_delayed_work_sync(&di->work); -+ -+ power_supply_unregister(&di->bat); -+ -+ mutex_destroy(&di->lock); -+} -+ -+ -+/* i2c specific code */ -+#ifdef CONFIG_BATTERY_BQ27X00_I2C -+ -+/* If the system has several batteries we need a different name for each -+ * of them... - */ -+static DEFINE_IDR(battery_id); -+static DEFINE_MUTEX(battery_mutex); - --static int bq27200_read(u8 reg, int *rt_value, int b_single, -- struct bq27x00_device_info *di) -+static int bq27x00_read_i2c(struct bq27x00_device_info *di, u8 reg, bool single) - { -- struct i2c_client *client = di->client; -- struct i2c_msg msg[1]; -+ struct i2c_client *client = to_i2c_client(di->dev); -+ struct i2c_msg msg[2]; - unsigned char data[2]; -- int err; -+ int ret; - - if (!client->adapter) - return -ENODEV; - -- msg->addr = client->addr; -- msg->flags = 0; -- msg->len = 1; -- msg->buf = data; -- -- data[0] = reg; -- err = i2c_transfer(client->adapter, msg, 1); -- -- if (err >= 0) { -- if (!b_single) -- msg->len = 2; -- else -- msg->len = 1; -+ msg[0].addr = client->addr; -+ msg[0].flags = 0; -+ msg[0].buf = ® -+ msg[0].len = sizeof(reg); -+ msg[1].addr = client->addr; -+ msg[1].flags = I2C_M_RD; -+ msg[1].buf = data; -+ if (single) -+ msg[1].len = 1; -+ else -+ msg[1].len = 2; - -- msg->flags = I2C_M_RD; -- err = i2c_transfer(client->adapter, msg, 1); -- if (err >= 0) { -- if (!b_single) -- *rt_value = get_unaligned_be16(data); -- else -- *rt_value = data[0]; -+ ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); -+ if (ret < 0) -+ return ret; - -- return 0; -- } -- } -- return err; -+ if (!single) -+ ret = get_unaligned_le16(data); -+ else -+ ret = data[0]; -+ -+ return ret; - } - --static int bq27200_battery_probe(struct i2c_client *client, -+static int bq27x00_battery_probe(struct i2c_client *client, - const struct i2c_device_id *id) - { - char *name; - struct bq27x00_device_info *di; -- struct bq27x00_access_methods *bus; - int num; - int retval = 0; - -@@ -267,7 +611,7 @@ static int bq27200_battery_probe(struct - if (retval < 0) - return retval; - -- name = kasprintf(GFP_KERNEL, "bq27200-%d", num); -+ name = kasprintf(GFP_KERNEL, "%s-%d", id->name, num); - if (!name) { - dev_err(&client->dev, "failed to allocate device name\n"); - retval = -ENOMEM; -@@ -280,37 +624,20 @@ static int bq27200_battery_probe(struct - retval = -ENOMEM; - goto batt_failed_2; - } -- di->id = num; - -- bus = kzalloc(sizeof(*bus), GFP_KERNEL); -- if (!bus) { -- dev_err(&client->dev, "failed to allocate access method " -- "data\n"); -- retval = -ENOMEM; -- goto batt_failed_3; -- } -- -- i2c_set_clientdata(client, di); -+ di->id = num; - di->dev = &client->dev; -+ di->chip = id->driver_data; - di->bat.name = name; -- bus->read = &bq27200_read; -- di->bus = bus; -- di->client = client; -- -- bq27x00_powersupply_init(di); -+ di->bus.read = &bq27x00_read_i2c; - -- retval = power_supply_register(&client->dev, &di->bat); -- if (retval) { -- dev_err(&client->dev, "failed to register battery\n"); -- goto batt_failed_4; -- } -+ if (bq27x00_powersupply_init(di)) -+ goto batt_failed_3; - -- dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION); -+ i2c_set_clientdata(client, di); - - return 0; - --batt_failed_4: -- kfree(bus); - batt_failed_3: - kfree(di); - batt_failed_2: -@@ -323,11 +650,11 @@ batt_failed_1: - return retval; - } - --static int bq27200_battery_remove(struct i2c_client *client) -+static int bq27x00_battery_remove(struct i2c_client *client) - { - struct bq27x00_device_info *di = i2c_get_clientdata(client); - -- power_supply_unregister(&di->bat); -+ bq27x00_powersupply_unregister(di); - - kfree(di->bat.name); - -@@ -340,31 +667,180 @@ static int bq27200_battery_remove(struct - return 0; - } - --/* -- * Module stuff -- */ -- --static const struct i2c_device_id bq27200_id[] = { -- { "bq27200", 0 }, -+static const struct i2c_device_id bq27x00_id[] = { -+ { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */ -+ { "bq27500", BQ27500 }, - {}, - }; -+MODULE_DEVICE_TABLE(i2c, bq27x00_id); -+ -+static struct i2c_driver bq27x00_battery_driver = { -+ .driver = { -+ .name = "bq27x00-battery", -+ }, -+ .probe = bq27x00_battery_probe, -+ .remove = bq27x00_battery_remove, -+ .id_table = bq27x00_id, -+}; -+ -+static inline int bq27x00_battery_i2c_init(void) -+{ -+ int ret = i2c_add_driver(&bq27x00_battery_driver); -+ if (ret) -+ printk(KERN_ERR "Unable to register BQ27x00 i2c driver\n"); -+ -+ return ret; -+} -+ -+static inline void bq27x00_battery_i2c_exit(void) -+{ -+ i2c_del_driver(&bq27x00_battery_driver); -+} -+ -+#else -+ -+static inline int bq27x00_battery_i2c_init(void) { return 0; } -+static inline void bq27x00_battery_i2c_exit(void) {}; -+ -+#endif -+ -+/* platform specific code */ -+#ifdef CONFIG_BATTERY_BQ27X00_PLATFORM -+ -+static int bq27000_read_platform(struct bq27x00_device_info *di, u8 reg, -+ bool single) -+{ -+ struct device *dev = di->dev; -+ struct bq27000_platform_data *pdata = dev->platform_data; -+ unsigned int timeout = 3; -+ int upper, lower; -+ int temp; -+ -+ if (!single) { -+ /* Make sure the value has not changed in between reading the -+ * lower and the upper part */ -+ upper = pdata->read(dev, reg + 1); -+ do { -+ temp = upper; -+ if (upper < 0) -+ return upper; -+ -+ lower = pdata->read(dev, reg); -+ if (lower < 0) -+ return lower; -+ -+ upper = pdata->read(dev, reg + 1); -+ } while (temp != upper && --timeout); -+ -+ if (timeout == 0) -+ return -EIO; -+ -+ return (upper << 8) | lower; -+ } -+ -+ return pdata->read(dev, reg); -+} -+ -+static int __devinit bq27000_battery_probe(struct platform_device *pdev) -+{ -+ struct bq27x00_device_info *di; -+ struct bq27000_platform_data *pdata = pdev->dev.platform_data; -+ int ret; -+ -+ if (!pdata) { -+ dev_err(&pdev->dev, "no platform_data supplied\n"); -+ return -EINVAL; -+ } -+ -+ if (!pdata->read) { -+ dev_err(&pdev->dev, "no hdq read callback supplied\n"); -+ return -EINVAL; -+ } -+ -+ di = kzalloc(sizeof(*di), GFP_KERNEL); -+ if (!di) { -+ dev_err(&pdev->dev, "failed to allocate device info data\n"); -+ return -ENOMEM; -+ } -+ -+ platform_set_drvdata(pdev, di); -+ -+ di->dev = &pdev->dev; -+ di->chip = BQ27000; -+ -+ di->bat.name = pdata->name ?: dev_name(&pdev->dev); -+ di->bus.read = &bq27000_read_platform; - --static struct i2c_driver bq27200_battery_driver = { -+ ret = bq27x00_powersupply_init(di); -+ if (ret) -+ goto err_free; -+ -+ return 0; -+ -+err_free: -+ platform_set_drvdata(pdev, NULL); -+ kfree(di); -+ -+ return ret; -+} -+ -+static int __devexit bq27000_battery_remove(struct platform_device *pdev) -+{ -+ struct bq27x00_device_info *di = platform_get_drvdata(pdev); -+ -+ bq27x00_powersupply_unregister(di); -+ -+ platform_set_drvdata(pdev, NULL); -+ kfree(di); -+ -+ return 0; -+} -+ -+static struct platform_driver bq27000_battery_driver = { -+ .probe = bq27000_battery_probe, -+ .remove = __devexit_p(bq27000_battery_remove), - .driver = { -- .name = "bq27200-battery", -+ .name = "bq27000-battery", -+ .owner = THIS_MODULE, - }, -- .probe = bq27200_battery_probe, -- .remove = bq27200_battery_remove, -- .id_table = bq27200_id, - }; - -+static inline int bq27x00_battery_platform_init(void) -+{ -+ int ret = platform_driver_register(&bq27000_battery_driver); -+ if (ret) -+ printk(KERN_ERR "Unable to register BQ27000 platform driver\n"); -+ -+ return ret; -+} -+ -+static inline void bq27x00_battery_platform_exit(void) -+{ -+ platform_driver_unregister(&bq27000_battery_driver); -+} -+ -+#else -+ -+static inline int bq27x00_battery_platform_init(void) { return 0; } -+static inline void bq27x00_battery_platform_exit(void) {}; -+ -+#endif -+ -+/* -+ * Module stuff -+ */ -+ - static int __init bq27x00_battery_init(void) - { - int ret; - -- ret = i2c_add_driver(&bq27200_battery_driver); -+ ret = bq27x00_battery_i2c_init(); -+ if (ret) -+ return ret; -+ -+ ret = bq27x00_battery_platform_init(); - if (ret) -- printk(KERN_ERR "Unable to register BQ27200 driver\n"); -+ bq27x00_battery_i2c_exit(); - - return ret; - } -@@ -372,7 +848,8 @@ module_init(bq27x00_battery_init); - - static void __exit bq27x00_battery_exit(void) - { -- i2c_del_driver(&bq27200_battery_driver); -+ bq27x00_battery_platform_exit(); -+ bq27x00_battery_i2c_exit(); - } - module_exit(bq27x00_battery_exit); - diff --git a/kernel-power-2.6.28/debian/patches/power-supply-ignore-enodata.diff b/kernel-power-2.6.28/debian/patches/power-supply-ignore-enodata.diff new file mode 100644 index 0000000..7f3b14e --- /dev/null +++ b/kernel-power-2.6.28/debian/patches/power-supply-ignore-enodata.diff @@ -0,0 +1,37 @@ +From f722e17fdb2c97bbec2563636dd88489cdb1428b Mon Sep 17 00:00:00 2001 +From: Lars-Peter Clausen +Date: Sat, 8 Jan 2011 19:12:26 +0100 +Subject: [PATCH] power_supply: Ignore -ENODATA errors when generating uevents + +Sometimes a driver can not report a meaningful value for a certain property +and returns -ENODATA. + +Currently when generating a uevent and a property return -ENODATA it is +treated as an error an no uevent is generated at all. This is not an +desirable behavior. + +This patch adds a special case for -ENODATA and ignores properties which +return this error code when generating the uevent. + +Signed-off-by: Lars-Peter Clausen +Tested-by: Grazvydas Ignotas +--- + drivers/power/power_supply_sysfs.c | 2 +- + 1 files changed, 1 insertions(+), 1 deletions(-) + +diff --git a/drivers/power/power_supply_sysfs.c b/drivers/power/power_supply_sysfs.c +index cd1f907..605514a 100644 +--- a/drivers/power/power_supply_sysfs.c ++++ b/drivers/power/power_supply_sysfs.c +@@ -270,7 +270,7 @@ int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env) + attr = &power_supply_attrs[psy->properties[j]]; + + ret = power_supply_show_property(dev, attr, prop_buf); +- if (ret == -ENODEV) { ++ if (ret == -ENODEV || ret == -ENODATA) { + /* When a battery is absent, we expect -ENODEV. Don't abort; + send the uevent with at least the the PRESENT=0 property */ + ret = 0; +-- +1.7.6.2 + diff --git a/kernel-power-2.6.28/debian/patches/series b/kernel-power-2.6.28/debian/patches/series index 0c6b803..7a02295 100644 --- a/kernel-power-2.6.28/debian/patches/series +++ b/kernel-power-2.6.28/debian/patches/series @@ -37,8 +37,11 @@ radio-bcm2048.diff #i2c-battery.diff usbhostmode.diff bt-mice.diff -board-rx51-peripherals.diff -bq27x00_battery.diff +power-supply-ignore-enodata.diff +bq27x00-rx51-board.diff +bq27x00-upstream.diff +bq27x00-maemo.diff +bq27x00-reg.diff l2cap_parent.diff wl12xx-rx-fix.diff anti-io-stalling.diff -- 1.7.9.5