diff options
Diffstat (limited to 'target/linux/omap24xx/patches-2.6.37/900-n810-battery-management.patch')
| -rw-r--r-- | target/linux/omap24xx/patches-2.6.37/900-n810-battery-management.patch | 657 |
1 files changed, 657 insertions, 0 deletions
diff --git a/target/linux/omap24xx/patches-2.6.37/900-n810-battery-management.patch b/target/linux/omap24xx/patches-2.6.37/900-n810-battery-management.patch new file mode 100644 index 000000000..1b8316b22 --- /dev/null +++ b/target/linux/omap24xx/patches-2.6.37/900-n810-battery-management.patch @@ -0,0 +1,657 @@ +--- + arch/arm/mach-omap2/board-n8x0.c | 13 + + drivers/cbus/Kconfig | 12 + + drivers/cbus/Makefile | 3 + drivers/cbus/lipocharge.c | 63 ++++++ + drivers/cbus/lipocharge.h | 50 ++++ + drivers/cbus/n810bm_main.c | 397 +++++++++++++++++++++++++++++++++++++++ + drivers/cbus/retu.c | 4 + drivers/cbus/retu.h | 3 + drivers/cbus/tahvo.h | 6 + 9 files changed, 548 insertions(+), 3 deletions(-) + +Index: linux-2.6.37-rc1/drivers/cbus/Kconfig +=================================================================== +--- linux-2.6.37-rc1.orig/drivers/cbus/Kconfig 2010-11-05 17:38:14.843000000 +0100 ++++ linux-2.6.37-rc1/drivers/cbus/Kconfig 2010-11-05 17:38:14.894000001 +0100 +@@ -94,4 +94,16 @@ + to Retu/Vilma. Detection state and events are exposed through + sysfs. + ++config N810BM ++ depends on CBUS_RETU && CBUS_TAHVO ++ tristate "Nokia n810 battery management" ++ ---help--- ++ Nokia n810 device battery management. ++ ++ WARNING: This driver is based on reverse engineered information. ++ It is possibly dangerous to use this software. ++ Use this software at your own risk! ++ ++ If unsure, say N. ++ + endmenu +Index: linux-2.6.37-rc1/drivers/cbus/Makefile +=================================================================== +--- linux-2.6.37-rc1.orig/drivers/cbus/Makefile 2010-11-05 17:38:14.834000050 +0100 ++++ linux-2.6.37-rc1/drivers/cbus/Makefile 2010-11-05 17:38:14.894000001 +0100 +@@ -12,3 +12,6 @@ + obj-$(CONFIG_CBUS_TAHVO_USER) += tahvo-user.o + obj-$(CONFIG_CBUS_RETU_USER) += retu-user.o + obj-$(CONFIG_CBUS_RETU_HEADSET) += retu-headset.o ++n810bm-y += n810bm_main.o ++n810bm-y += lipocharge.o ++obj-$(CONFIG_N810BM) += n810bm.o +Index: linux-2.6.37-rc1/drivers/cbus/n810bm_main.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.37-rc1/drivers/cbus/n810bm_main.c 2010-11-05 17:38:14.894000001 +0100 +@@ -0,0 +1,397 @@ ++/* ++ * Nokia n810 battery management ++ * ++ * WARNING: This driver is based on reverse engineered information. ++ * It is possibly dangerous to use this software. ++ * Use this software at your own risk! ++ * ++ * Copyright (c) 2010 Michael Buesch <mb@bu3sch.de> ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#include <linux/module.h> ++#include <linux/device.h> ++#include <linux/platform_device.h> ++#include <linux/slab.h> ++#include <linux/spinlock.h> ++#include <linux/timer.h> ++#include <linux/reboot.h> ++ ++#include "retu.h" ++#include "tahvo.h" ++#include "lipocharge.h" ++ ++ ++#define N810BM_CHECK_INTERVAL (HZ * 5) ++#define N810BM_MIN_VOLTAGE_THRES 3300 /* Absolute minimum voltage threshold */ ++ ++ ++/* Battery related retu ADC channels */ ++#define RETU_ADC_BSI 0x01 /* Battery Size Indicator */ ++#define RETU_ADC_BATTVOLT 0x08 /* Battery voltage measurement */ ++ ++/* RETU_ADC_BSI ++ * The battery size indicator ADC measures the resistance between ++ * the battery BSI pin and ground. This is used to detect the battery ++ * capacity, as the BSI resistor is related to capacity. ++ * ++ * Manually measured lookup table. ++ * Hard to measure, thus not very accurate. ++ * ++ * Resistance | ADC value ++ * ======================== ++ * 120k | 0x3AC ++ * 110k | 0x37C ++ * 100k | 0x351 ++ * 90k | 0x329 ++ */ ++ ++/* RETU_ADC_BATTVOLT ++ * Manually measured lookup table. ++ * Hard to measure, thus not very accurate. ++ * ++ * Voltage | ADC value ++ * ===================== ++ * 2.80V | 0x037 ++ * 2.90V | 0x05E ++ * 3.00V | 0x090 ++ * 3.10V | 0x0A4 ++ * 3.20V | 0x0CC ++ * 3.30V | 0x0EF ++ * 3.40V | 0x115 ++ * 3.50V | 0x136 ++ * 3.60V | 0x15C ++ * 3.70V | 0x187 ++ * 3.80V | 0x1A5 ++ * 3.90V | 0x1C9 ++ * 4.00V | 0x1ED ++ * 4.10V | 0x212 ++ * 4.20V | 0x236 ++ */ ++ ++ ++enum n810bm_capacity { ++ N810BM_CAP_UNKNOWN = 0, ++ N810BM_CAP_1500MAH = 1500, /* 1500 mAh battery */ ++}; ++ ++struct n810bm { ++ struct platform_device *pdev; ++ ++ enum n810bm_capacity capacity; ++ struct timer_list check_timer; ++ ++ struct lipocharge *charger; ++ ++ spinlock_t lock; ++}; ++ ++ ++static NORET_TYPE void n810bm_emergency(struct n810bm *bm, const char *message) ATTRIB_NORET; ++static void n810bm_emergency(struct n810bm *bm, const char *message) ++{ ++ printk(KERN_EMERG "n810 battery management fatal fault: %s\n", message); ++ /* Force a hard shutdown. */ ++ machine_power_off(); ++ panic("n810bm: Failed to halt machine in emergency state\n"); ++} ++ ++#if 0 ++static u16 retu_read(struct n810bm *bm, unsigned int reg) ++{ ++ int ret; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&retu_lock, flags); ++ ret = retu_read_reg(reg); ++ spin_unlock_irqrestore(&retu_lock, flags); ++ if (ret < 0 || ret > 0xFFFF) ++ n810bm_emergency(bm, "retu_read"); ++ ++ return ret; ++} ++#endif ++ ++static void retu_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set) ++{ ++ int ret; ++ unsigned long flags; ++ u16 value; ++ ++ spin_lock_irqsave(&retu_lock, flags); ++ if (~mask) { ++ ret = retu_read_reg(reg); ++ if (ret < 0 || ret > 0xFFFF) ++ goto fatal_unlock; ++ value = ret; ++ } else ++ value = 0; ++ value &= ~mask; ++ value |= set; ++ ret = retu_write_reg(reg, value); ++ if (ret) ++ goto fatal_unlock; ++ spin_unlock_irqrestore(&retu_lock, flags); ++ ++ return; ++ ++fatal_unlock: ++ spin_unlock_irqrestore(&retu_lock, flags); ++ n810bm_emergency(bm, "retu_maskset"); ++} ++ ++static inline void retu_write(struct n810bm *bm, unsigned int reg, u16 value) ++{ ++ return retu_maskset(bm, reg, 0xFFFF, value); ++} ++ ++static int retu_adc_average(struct n810bm *bm, unsigned int chan, ++ unsigned int nr_passes) ++{ ++ unsigned int i, value = 0; ++ int ret; ++ ++ if (WARN_ON(!nr_passes)) ++ return 0; ++ for (i = 0; i < nr_passes; i++) { ++ ret = retu_read_adc(chan); ++ if (ret < 0) ++ return ret; ++ value += ret; ++ } ++ value /= nr_passes; ++ ++ return value; ++} ++ ++/* Measure the battery voltage. Returns the value in mV (or negative value on error). */ ++static int n810bm_measure_batt_voltage(struct n810bm *bm) ++{ ++ int adc; ++ unsigned int mv; ++ const unsigned int scale = 1000; ++ ++ adc = retu_adc_average(bm, RETU_ADC_BATTVOLT, 5); ++ if (adc < 0) ++ return adc; ++ if (adc <= 0x37) ++ return 2800; ++ mv = 2800 + ((adc - 0x37) * (((4200 - 2800) * scale) / (0x236 - 0x37))) / scale; ++ ++ return mv; ++} ++ ++/* Read the battery capacity via BSI pin. */ ++static enum n810bm_capacity n810bm_read_batt_capacity(struct n810bm *bm) ++{ ++ int adc; ++ const unsigned int hyst = 20; ++ ++ adc = retu_adc_average(bm, RETU_ADC_BSI, 5); ++ if (adc < 0) { ++ dev_err(&bm->pdev->dev, "Failed to read BSI ADC"); ++ return N810BM_CAP_UNKNOWN; ++ } ++ ++ if (adc >= 0x3B5 - hyst && adc <= 0x3B5 + hyst) ++ return N810BM_CAP_1500MAH; ++ ++ dev_err(&bm->pdev->dev, "Capacity indicator 0x%X unknown", adc); ++ ++ return N810BM_CAP_UNKNOWN; ++} ++ ++/* Convert a battery voltage (in mV) to percentage. */ ++static unsigned int n810bm_mvolt2percent(unsigned int mv) ++{ ++ const unsigned int minv = 3700; ++ const unsigned int maxv = 4150; ++ unsigned int percent; ++ ++ mv = clamp(mv, minv, maxv); ++ percent = (mv - minv) * 100 / (maxv - minv); ++ ++ return percent; ++} ++ ++static void n810bm_check_timer(unsigned long data) ++{ ++ struct n810bm *bm = (struct n810bm *)data; ++ unsigned long flags; ++ int mv; ++ ++ spin_lock_irqsave(&bm->lock, flags); ++ ++ mv = n810bm_measure_batt_voltage(bm); ++ if (mv < 0) ++ n810bm_emergency(bm, "check timer: Failed to measure"); ++ if (mv < N810BM_MIN_VOLTAGE_THRES) ++ n810bm_emergency(bm, "check timer: Minimum voltage threshold reached"); ++ ++ mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL)); ++ spin_unlock_irqrestore(&bm->lock, flags); ++ ++ return; ++} ++ ++static void n810bm_adc_irq_handler(unsigned long data) ++{ ++ struct n810bm *bm = (struct n810bm *)data; ++ ++ retu_ack_irq(RETU_INT_ADCS); ++ //TODO ++printk("n810bm: ADC timer triggered\n"); ++} ++ ++static ssize_t n810bm_attr_charge_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct platform_device *pdev = to_platform_device(dev); ++ struct n810bm *bm = platform_get_drvdata(pdev); ++ int err = -ENODEV; ++ ssize_t count = 0; ++ int millivolt; ++ ++ spin_lock_irq(&bm->lock); ++ millivolt = n810bm_measure_batt_voltage(bm); ++ if (millivolt >= 0) { ++ count = snprintf(buf, PAGE_SIZE, "%u\n", ++ n810bm_mvolt2percent(millivolt)); ++ err = 0; ++ } ++ spin_unlock_irq(&bm->lock); ++ ++ return err ? err : count; ++} ++static DEVICE_ATTR(batt_charge, 0444, n810bm_attr_charge_show, NULL); ++ ++static ssize_t n810bm_attr_capacity_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct platform_device *pdev = to_platform_device(dev); ++ struct n810bm *bm = platform_get_drvdata(pdev); ++ ssize_t count; ++ ++ spin_lock_irq(&bm->lock); ++ count = snprintf(buf, PAGE_SIZE, "%u\n", ++ (unsigned int)bm->capacity); ++ spin_unlock_irq(&bm->lock); ++ ++ return count; ++} ++static DEVICE_ATTR(batt_capacity, 0444, n810bm_attr_capacity_show, NULL); ++ ++static void n810bm_hw_exit(struct n810bm *bm) ++{ ++ retu_write(bm, RETU_REG_ADCSCR, 0); ++} ++ ++static int n810bm_hw_init(struct n810bm *bm) ++{ ++ retu_write(bm, RETU_REG_ADCSCR, 0); ++ ++ bm->capacity = n810bm_read_batt_capacity(bm); ++ if (bm->capacity == N810BM_CAP_UNKNOWN) { ++ dev_err(&bm->pdev->dev, "Unknown battery detected"); ++ return -ENODEV; ++ } ++ dev_info(&bm->pdev->dev, "Detected %u mAh battery\n", ++ (unsigned int)bm->capacity); ++ ++ return 0; ++} ++ ++static int __devinit n810bm_probe(struct platform_device *pdev) ++{ ++ struct n810bm *bm; ++ int err; ++ ++ bm = kzalloc(sizeof(*bm), GFP_KERNEL); ++ if (!bm) ++ return -ENOMEM; ++ bm->pdev = pdev; ++ platform_set_drvdata(pdev, bm); ++ spin_lock_init(&bm->lock); ++ setup_timer(&bm->check_timer, n810bm_check_timer, (unsigned long)bm); ++ ++ err = n810bm_hw_init(bm); ++ if (err) ++ goto err_free; ++ err = device_create_file(&pdev->dev, &dev_attr_batt_charge); ++ if (err) ++ goto err_exit; ++ err = device_create_file(&pdev->dev, &dev_attr_batt_capacity); ++ if (err) ++ goto err_rem_charge; ++ err = retu_request_irq(RETU_INT_ADCS, n810bm_adc_irq_handler, ++ (unsigned long)bm, "n810bm"); ++ if (err) ++ goto err_rem_capa; ++ ++ mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL)); ++ ++ dev_info(&pdev->dev, "Battery management initialized"); ++ ++ return 0; ++ ++err_rem_capa: ++ device_remove_file(&pdev->dev, &dev_attr_batt_capacity); ++err_rem_charge: ++ device_remove_file(&pdev->dev, &dev_attr_batt_charge); ++err_exit: ++ n810bm_hw_exit(bm); ++err_free: ++ kfree(bm); ++ platform_set_drvdata(pdev, NULL); ++ return err; ++} ++ ++static int __devexit n810bm_remove(struct platform_device *pdev) ++{ ++ struct n810bm *bm = platform_get_drvdata(pdev); ++ ++ retu_free_irq(RETU_INT_ADCS); ++ del_timer_sync(&bm->check_timer); ++ device_remove_file(&pdev->dev, &dev_attr_batt_capacity); ++ device_remove_file(&pdev->dev, &dev_attr_batt_charge); ++ n810bm_hw_exit(bm); ++ ++ kfree(bm); ++ platform_set_drvdata(pdev, NULL); ++ ++ return 0; ++} ++ ++static struct platform_driver n810bm_driver = { ++ .remove = __devexit_p(n810bm_remove), ++ .driver = { ++ .name = "n810bm", ++ } ++}; ++ ++static int __init n810bm_modinit(void) ++{ ++ return platform_driver_probe(&n810bm_driver, n810bm_probe); ++} ++module_init(n810bm_modinit); ++ ++static void __exit n810bm_modexit(void) ++{ ++ platform_driver_unregister(&n810bm_driver); ++} ++module_exit(n810bm_modexit); ++ ++MODULE_DESCRIPTION("Nokia n810 battery management"); ++MODULE_LICENSE("GPL"); ++MODULE_AUTHOR("Michael Buesch"); +Index: linux-2.6.37-rc1/drivers/cbus/retu.c +=================================================================== +--- linux-2.6.37-rc1.orig/drivers/cbus/retu.c 2010-11-05 17:38:14.834000050 +0100 ++++ linux-2.6.37-rc1/drivers/cbus/retu.c 2010-11-05 17:38:14.895000001 +0100 +@@ -85,10 +85,10 @@ + * + * This function writes a value to the specified register + */ +-void retu_write_reg(int reg, u16 val) ++int retu_write_reg(int reg, u16 val) + { + BUG_ON(!retu_initialized); +- cbus_write_reg(cbus_host, RETU_ID, reg, val); ++ return cbus_write_reg(cbus_host, RETU_ID, reg, val); + } + + void retu_set_clear_reg_bits(int reg, u16 set, u16 clear) +Index: linux-2.6.37-rc1/drivers/cbus/retu.h +=================================================================== +--- linux-2.6.37-rc1.orig/drivers/cbus/retu.h 2010-11-05 17:38:14.834000050 +0100 ++++ linux-2.6.37-rc1/drivers/cbus/retu.h 2010-11-05 17:38:14.895000001 +0100 +@@ -39,6 +39,7 @@ + #define RETU_REG_CC2 0x0e /* Common control register 2 */ + #define RETU_REG_CTRL_CLR 0x0f /* Regulator clear register */ + #define RETU_REG_CTRL_SET 0x10 /* Regulator set register */ ++#define RETU_REG_UNK1 0x14 /* 0x1000 is set when charger is plugged in */ + #define RETU_REG_STATUS 0x16 /* Status register */ + #define RETU_REG_WATCHDOG 0x17 /* Watchdog register */ + #define RETU_REG_AUDTXR 0x18 /* Audio Codec Tx register */ +@@ -58,7 +59,7 @@ + #define MAX_RETU_IRQ_HANDLERS 16 + + int retu_read_reg(int reg); +-void retu_write_reg(int reg, u16 val); ++int retu_write_reg(int reg, u16 val); + void retu_set_clear_reg_bits(int reg, u16 set, u16 clear); + int retu_read_adc(int channel); + int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name); +Index: linux-2.6.37-rc1/arch/arm/mach-omap2/board-n8x0.c +=================================================================== +--- linux-2.6.37-rc1.orig/arch/arm/mach-omap2/board-n8x0.c 2010-11-05 17:38:14.819000329 +0100 ++++ linux-2.6.37-rc1/arch/arm/mach-omap2/board-n8x0.c 2010-11-05 17:38:14.895000001 +0100 +@@ -908,6 +908,17 @@ + ARRAY_SIZE(n8x0_gpio_switches)); + } + ++static struct platform_device n810_bm_device = { ++ .name = "n810bm", ++ .id = -1, ++}; ++ ++static void __init n810_bm_init(void) ++{ ++ if (platform_device_register(&n810_bm_device)) ++ BUG(); ++} ++ + static void __init n8x0_init_machine(void) + { + omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAC); +@@ -930,6 +941,8 @@ + n8x0_onenand_init(); + n8x0_mmc_init(); + n8x0_usb_init(); ++ ++ n810_bm_init(); + } + + MACHINE_START(NOKIA_N800, "Nokia N800") +Index: linux-2.6.37-rc1/drivers/cbus/lipocharge.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.37-rc1/drivers/cbus/lipocharge.c 2010-11-05 17:38:14.895000001 +0100 +@@ -0,0 +1,63 @@ ++/* ++ * Generic LIPO battery charger ++ * ++ * Copyright (c) 2010 Michael Buesch <mb@bu3sch.de> ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License ++ * as published by the Free Software Foundation; either version 2 ++ * of the License, or (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#include "lipocharge.h" ++ ++#include <linux/slab.h> ++ ++ ++static void lipocharge_timer(unsigned long data) ++{ ++ struct lipocharge *c = (struct lipocharge *)data; ++ ++ spin_lock(&c->lock); ++ //TODO ++ spin_unlock(&c->lock); ++} ++ ++struct lipocharge * lipocharge_alloc(gfp_t gfp) ++{ ++ struct lipocharge *c; ++ ++ c = kzalloc(sizeof(*c), gfp); ++ if (!c) ++ return NULL; ++ spin_lock_init(&c->lock); ++ setup_timer(&c->timer, lipocharge_timer, (unsigned long)c); ++ ++ return c; ++} ++ ++void lipocharge_free(struct lipocharge *c) ++{ ++ kfree(c); ++} ++ ++int lipocharge_start(struct lipocharge *c) ++{ ++ if (!c->set_current || !c->get_voltage || ++ !c->finished || !c->emergency) ++ return -EINVAL; ++ if (!c->top_voltage || c->top_voltage > 4200) ++ return -EINVAL; ++ //TODO ++} ++ ++void lipocharge_stop(struct lipocharge *c) ++{ ++ del_timer_sync(&c->timer); ++ //TODO ++} +Index: linux-2.6.37-rc1/drivers/cbus/lipocharge.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.37-rc1/drivers/cbus/lipocharge.h 2010-11-05 17:38:14.895000001 +0100 +@@ -0,0 +1,50 @@ ++#ifndef LIPOCHARGE_H_ ++#define LIPOCHARGE_H_ ++ ++#include <linux/timer.h> ++#include <linux/spinlock.h> ++ ++ ++#define LIPORATE(a,b) (((a) * 1000) + (b)) ++#define LIPORATE_1C LIPORATE(1,0) /* 1C */ ++#define LIPORATE_p8C LIPORATE(0,8) /* 0.8C */ ++ ++/** struct lipocharge - A generic LIPO charger ++ * ++ * @capacity: Battery capacity in mAh. ++ * @rate: Charge rate. ++ * @top_voltage: Fully charged voltage, in mV. ++ * ++ * @set_current: Set the charge current, in mA. ++ * @get_voltage: Get the battery voltage, in mV. ++ * ++ * @emergency: Something went wrong. Force shutdown. ++ * ++ * @priv: opaque pointer. ++ */ ++struct lipocharge ++{ ++ unsigned int capacity; ++ unsigned int rate; ++ unsigned int top_voltage; ++ ++ int (*set_current)(struct lipocharge *c, unsigned int ma); ++ int (*get_voltage)(struct lipocharge *c, unsigned int *mv); ++ ++ void (*finished)(struct lipocharge *c); ++ void (*emergency)(struct lipocharge *c); ++ ++ void *priv; ++ ++ /* internal */ ++ spinlock_t lock; ++ struct timer_list timer; ++}; ++ ++struct lipocharge * lipocharge_alloc(gfp_t gfp); ++void lipocharge_free(struct lipocharge *c); ++ ++int lipocharge_start(struct lipocharge *c); ++void lipocharge_stop(struct lipocharge *c); ++ ++#endif /* LIPOCHARGE_H_ */ +Index: linux-2.6.37-rc1/drivers/cbus/tahvo.h +=================================================================== +--- linux-2.6.37-rc1.orig/drivers/cbus/tahvo.h 2010-11-05 17:38:14.835000037 +0100 ++++ linux-2.6.37-rc1/drivers/cbus/tahvo.h 2010-11-05 17:38:14.895000001 +0100 +@@ -30,8 +30,14 @@ + #define TAHVO_REG_IDR 0x01 /* Interrupt ID */ + #define TAHVO_REG_IDSR 0x02 /* Interrupt status */ + #define TAHVO_REG_IMR 0x03 /* Interrupt mask */ ++#define TAHVO_REG_CHGCURR 0x04 /* Charge current control (8-bit) */ + #define TAHVO_REG_LEDPWMR 0x05 /* LED PWM */ + #define TAHVO_REG_USBR 0x06 /* USB control */ ++#define TAHVO_REG_CHGCTL 0x08 /* Charge control register */ ++#define TAHVO_REG_CHGCTL_EN 0x0001 /* Global charge enable */ ++#define TAHVO_REG_CHGCTL2 0x0c /* Charge control register 2 */ ++#define TAHVO_REG_BATCURR 0x0d /* Battery (dis)charge current (signed 16-bit) */ ++ + #define TAHVO_REG_MAX 0x0d + + /* Interrupt sources */ |