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 | 720 |
1 files changed, 575 insertions, 145 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 index 3f6262a357..2f2061629a 100644 --- 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 @@ -12,8 +12,8 @@ Index: linux-2.6.37/drivers/cbus/Kconfig =================================================================== ---- linux-2.6.37.orig/drivers/cbus/Kconfig 2011-01-28 22:33:39.703215389 +0100 -+++ linux-2.6.37/drivers/cbus/Kconfig 2011-01-28 23:41:57.094298060 +0100 +--- linux-2.6.37.orig/drivers/cbus/Kconfig 2011-02-06 00:24:48.502005279 +0100 ++++ linux-2.6.37/drivers/cbus/Kconfig 2011-02-06 00:24:48.550008091 +0100 @@ -94,4 +94,12 @@ to Retu/Vilma. Detection state and events are exposed through sysfs. @@ -29,8 +29,8 @@ Index: linux-2.6.37/drivers/cbus/Kconfig endmenu Index: linux-2.6.37/drivers/cbus/Makefile =================================================================== ---- linux-2.6.37.orig/drivers/cbus/Makefile 2011-01-28 22:33:39.694216931 +0100 -+++ linux-2.6.37/drivers/cbus/Makefile 2011-01-28 22:33:39.754206648 +0100 +--- linux-2.6.37.orig/drivers/cbus/Makefile 2011-02-06 00:24:48.493004751 +0100 ++++ linux-2.6.37/drivers/cbus/Makefile 2011-02-06 00:24:48.550008091 +0100 @@ -12,3 +12,6 @@ obj-$(CONFIG_CBUS_TAHVO_USER) += tahvo-user.o obj-$(CONFIG_CBUS_RETU_USER) += retu-user.o @@ -41,8 +41,8 @@ Index: linux-2.6.37/drivers/cbus/Makefile Index: linux-2.6.37/drivers/cbus/n810bm_main.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.37/drivers/cbus/n810bm_main.c 2011-01-28 23:41:23.510064352 +0100 -@@ -0,0 +1,562 @@ ++++ linux-2.6.37/drivers/cbus/n810bm_main.c 2011-02-06 13:36:49.581078785 +0100 +@@ -0,0 +1,959 @@ +/* + * Nokia n810 battery management + * @@ -63,6 +63,8 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + * GNU General Public License for more details. + */ + ++#define DEBUG ++ +#include <linux/module.h> +#include <linux/device.h> +#include <linux/platform_device.h> @@ -70,13 +72,17 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c +#include <linux/spinlock.h> +#include <linux/timer.h> +#include <linux/reboot.h> ++#include <linux/firmware.h> + +#include "retu.h" +#include "tahvo.h" +#include "lipocharge.h" + + -+#define N810BM_CHECK_INTERVAL (HZ * 5) ++#define N810BM_PMM_BLOCK_FILENAME "n810-cal-bme-pmm.fw" ++#define N810BM_PMM_BLOCK_SIZE 0x600 ++ ++#define N810BM_CHECK_INTERVAL (HZ * 2) +#define N810BM_MIN_VOLTAGE_THRES 3300 /* Absolute minimum voltage threshold */ + + @@ -121,22 +127,37 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + + +enum n810bm_capacity { -+ N810BM_CAP_UNKNOWN = 0, ++ N810BM_CAP_UNKNOWN = -1, ++ N810BM_CAP_NONE = 0, + N810BM_CAP_1500MAH = 1500, /* 1500 mAh battery */ +}; + +struct n810bm { ++ bool battery_present; /* A battery is inserted */ ++ bool charger_present; /* The charger is connected */ ++ enum n810bm_capacity capacity; /* The capacity of the inserted battery (if any) */ ++ ++ bool charger_enabled; /* Want to charge? */ //TODO ++ struct lipocharge charger; /* Charger subsystem */ ++ + struct platform_device *pdev; ++ const struct firmware *pmm_block; /* CAL PMM block */ + -+ enum n810bm_capacity capacity; + struct timer_list check_timer; + -+ struct lipocharge *charger; -+ ++ bool initialized; /* The hardware was initialized */ + spinlock_t lock; +}; + + ++static inline struct n810bm * device_to_n810bm(struct device *dev) ++{ ++ struct platform_device *pdev = to_platform_device(dev); ++ struct n810bm *bm = platform_get_drvdata(pdev); ++ ++ return bm; ++} ++ +static NORET_TYPE void n810bm_emergency(struct n810bm *bm, const char *message) ATTRIB_NORET; +static void n810bm_emergency(struct n810bm *bm, const char *message) +{ @@ -146,7 +167,63 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + panic("n810bm: Failed to halt machine in emergency state\n"); +} + -+#if 0 ++static u16 tahvo_read(struct n810bm *bm, unsigned int reg) ++{ ++ int ret; ++ unsigned long flags; ++ ++ spin_lock_irqsave(&tahvo_lock, flags); ++ ret = tahvo_read_reg(reg); ++ spin_unlock_irqrestore(&tahvo_lock, flags); ++ if (ret < 0 || ret > 0xFFFF) ++ n810bm_emergency(bm, "tahvo_read"); ++ ++ return ret; ++} ++ ++static void tahvo_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set) ++{ ++ int ret; ++ unsigned long flags; ++ u16 value; ++ ++ spin_lock_irqsave(&tahvo_lock, flags); ++ if (~mask) { ++ ret = tahvo_read_reg(reg); ++ if (ret < 0 || ret > 0xFFFF) ++ goto fatal_unlock; ++ value = ret; ++ } else ++ value = 0; ++ value &= ~mask; ++ value |= set; ++ ret = tahvo_write_reg(reg, value); ++ if (ret) ++ goto fatal_unlock; ++ spin_unlock_irqrestore(&tahvo_lock, flags); ++ ++ return; ++ ++fatal_unlock: ++ spin_unlock_irqrestore(&tahvo_lock, flags); ++ n810bm_emergency(bm, "tahvo_maskset"); ++} ++ ++static inline void tahvo_write(struct n810bm *bm, unsigned int reg, u16 value) ++{ ++ tahvo_maskset(bm, reg, 0xFFFF, value); ++} ++ ++static inline void tahvo_set(struct n810bm *bm, unsigned int reg, u16 mask) ++{ ++ tahvo_maskset(bm, reg, mask, mask); ++} ++ ++static inline void tahvo_clear(struct n810bm *bm, unsigned int reg, u16 mask) ++{ ++ tahvo_maskset(bm, reg, mask, 0); ++} ++ +static u16 retu_read(struct n810bm *bm, unsigned int reg) +{ + int ret; @@ -160,7 +237,6 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + + return ret; +} -+#endif + +static void retu_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set) +{ @@ -192,7 +268,7 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + +static inline void retu_write(struct n810bm *bm, unsigned int reg, u16 value) +{ -+ return retu_maskset(bm, reg, 0xFFFF, value); ++ retu_maskset(bm, reg, 0xFFFF, value); +} + +static int retu_adc_average(struct n810bm *bm, unsigned int chan, @@ -214,6 +290,77 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + return value; +} + ++/* Set the current measure timer that triggers on Tahvo IRQ 7 */ ++static void n810bm_set_current_measure_timer(struct n810bm *bm, ++ u16 millisec_interval) ++{ ++ u16 value = millisec_interval; ++ ++ if (value <= 0xF905) { ++ value = ((u64)0x10624DD3 * (u64)(value + 0xF9)) >> 32; ++ value /= 16; ++ } else ++ value = 0xFF; ++ ++ tahvo_write(bm, TAHVO_REG_BATCURRTIMER, value & 0xFF); ++ ++ tahvo_set(bm, TAHVO_REG_CHGCTL, ++ TAHVO_REG_CHGCTL_CURTIMRST); ++ tahvo_clear(bm, TAHVO_REG_CHGCTL, ++ TAHVO_REG_CHGCTL_CURTIMRST); ++} ++ ++static void n810bm_enable_current_measure(struct n810bm *bm, bool slow, bool irq) ++{ ++ u16 millisec_interval; ++ ++ if (slow) ++ millisec_interval = 1000; ++ else ++ millisec_interval = 250; ++ ++ /* Enable the current measurement circuitry */ ++ tahvo_set(bm, TAHVO_REG_CHGCTL, ++ TAHVO_REG_CHGCTL_CURMEAS); ++ ++ /* Setup the measurement timer */ ++ n810bm_set_current_measure_timer(bm, millisec_interval); ++ if (irq) ++ tahvo_enable_irq(TAHVO_INT_BATCURR); ++ ++ //TODO also do a software timer for safety. ++} ++ ++static void n810bm_disable_current_measure(struct n810bm *bm) ++{ ++ /* Disable the measurement timer */ ++ n810bm_set_current_measure_timer(bm, 0); ++ tahvo_disable_irq(TAHVO_INT_BATCURR); ++ ++ /* Disable the current measurement circuitry */ ++ tahvo_clear(bm, TAHVO_REG_CHGCTL, ++ TAHVO_REG_CHGCTL_CURMEAS); ++} ++ ++/* Measure the actual battery current. Returns a signed value in mA. ++ * Does only work, if current measurement was enabled. */ ++static int n810bm_measure_batt_current(struct n810bm *bm) ++{ ++ u16 retval; ++ int adc = 0, ma, i; ++ ++ for (i = 0; i < 3; i++) { ++ retval = tahvo_read(bm, TAHVO_REG_BATCURR); ++ adc += (s16)retval; /* Value is signed */ ++ } ++ adc /= 3; ++ ++ //TODO convert to mA ++ ma = adc; ++ ++ return ma; ++} ++ +static int adc_sanity_check(struct n810bm *bm, unsigned int channel) +{ + int value; @@ -224,9 +371,9 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + channel); + return -EIO; + } -+ dev_info(&bm->pdev->dev, -+ "GND ADC channel %u sanity check got value: %d", -+ channel, value); ++ dev_dbg(&bm->pdev->dev, ++ "GND ADC channel %u sanity check got value: %d", ++ channel, value); + if (value > 5) { + n810bm_emergency(bm, "GND ADC sanity check failed"); + return -EIO; @@ -345,19 +492,67 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + return percent; +} + ++/* Periodic check */ +static void n810bm_check_timer(unsigned long data) +{ + struct n810bm *bm = (struct n810bm *)data; + unsigned long flags; ++ u16 status; ++ bool battery_was_present, charger_was_present; ++ bool force_charge = 0; + 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"); ++ status = retu_read(bm, RETU_REG_STATUS); ++ battery_was_present = bm->battery_present; ++ charger_was_present = bm->charger_present; ++ bm->battery_present = !!(status & RETU_REG_STATUS_BATAVAIL); ++ bm->charger_present = !!(status & RETU_REG_STATUS_CHGPLUG); ++ ++ if (bm->battery_present != battery_was_present) { ++ /* Battery state changed */ ++ if (bm->battery_present) { ++ bm->capacity = n810bm_read_batt_capacity(bm); ++ if (bm->capacity == N810BM_CAP_UNKNOWN) { ++ dev_err(&bm->pdev->dev, "Unknown battery detected"); ++ } else { ++ dev_info(&bm->pdev->dev, "Detected %u mAh battery", ++ (unsigned int)bm->capacity); ++ } ++ } else { ++ bm->capacity = N810BM_CAP_NONE; ++ dev_info(&bm->pdev->dev, "The main battery was removed"); ++ //TODO what do if charging? ++ } ++ } ++ ++ if (bm->charger_present != charger_was_present) { ++ /* Charger state changed */ ++ dev_info(&bm->pdev->dev, "The charger was %s", ++ bm->charger_present ? "plugged in" : "removed"); ++ } ++ ++ if (bm->battery_present && !lipocharge_is_charging(&bm->charger)) { ++ mv = n810bm_measure_batt_voltage(bm); ++ if (mv < 0) ++ n810bm_emergency(bm, "check timer: Failed to measure"); ++ if (!bm->charger_present) { ++ if (mv < N810BM_MIN_VOLTAGE_THRES) { ++ n810bm_emergency(bm, "check timer: " ++ "Minimum voltage threshold reached"); ++ } ++ force_charge = 1; ++ } ++ } ++ ++ if (bm->charger_present && bm->battery_present) { ++ if (bm->charger_enabled || force_charge) { ++ if (!lipocharge_is_charging(&bm->charger)) { ++ //TODO start charging, if battery is below some threshold ++ } ++ } ++ } + + mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL)); + spin_unlock_irqrestore(&bm->lock, flags); @@ -367,28 +562,88 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + +static void n810bm_adc_irq_handler(unsigned long data) +{ -+// struct n810bm *bm = (struct n810bm *)data; ++ struct n810bm *bm = (struct n810bm *)data; + + retu_ack_irq(RETU_INT_ADCS); + //TODO -+printk("n810bm: ADC timer triggered\n"); ++dev_dbg(&bm->pdev->dev, "ADC interrupt triggered\n"); ++} ++ ++static void n810bm_tahvo_current_measure_irq_handler(unsigned long data) ++{ ++ struct n810bm *bm = (struct n810bm *)data; ++ ++ tahvo_ack_irq(TAHVO_INT_BATCURR); ++ //TODO ++dev_dbg(&bm->pdev->dev, "Tahvo measure IRQ triggered\n"); +} + ++#define DEFINE_SHOW_INT_FUNC(name, member) \ ++ static ssize_t n810bm_##name##_show(struct device *dev, \ ++ struct device_attribute *attr, \ ++ char *buf) \ ++ { \ ++ struct n810bm *bm = device_to_n810bm(dev); \ ++ ssize_t count; \ ++ \ ++ spin_lock_irq(&bm->lock); \ ++ count = snprintf(buf, PAGE_SIZE, "%d\n", (int)(bm->member)); \ ++ spin_unlock_irq(&bm->lock); \ ++ \ ++ return count; \ ++ } ++ ++#define DEFINE_STORE_INT_FUNC(name, member) \ ++ static ssize_t n810bm_##name##_store(struct device *dev, \ ++ struct device_attribute *attr, \ ++ const char *buf, size_t count) \ ++ { \ ++ struct n810bm *bm = device_to_n810bm(dev); \ ++ long val; \ ++ int err; \ ++ \ ++ spin_lock_irq(&bm->lock); \ ++ err = strict_strtol(buf, 0, &val); \ ++ if (!err) \ ++ bm->member = (typeof(bm->member))val; \ ++ spin_unlock_irq(&bm->lock); \ ++ \ ++ return err ? err : count; \ ++ } ++ ++#define DEFINE_ATTR_SHOW_INT(name, member) \ ++ DEFINE_SHOW_INT_FUNC(name, member) \ ++ static DEVICE_ATTR(name, 0444, n810bm_##name##_show, NULL); ++ ++#define DEFINE_ATTR_SHOW_STORE_INT(name, member) \ ++ DEFINE_SHOW_INT_FUNC(name, member) \ ++ DEFINE_STORE_INT_FUNC(name, member) \ ++ static DEVICE_ATTR(name, 0644, n810bm_##name##_show, \ ++ n810bm_##name##_store); ++ ++DEFINE_ATTR_SHOW_INT(batt_present, battery_present); ++DEFINE_ATTR_SHOW_INT(charger_present, charger_present); ++DEFINE_ATTR_SHOW_STORE_INT(charger_enable, charger_enabled); ++ +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); ++ struct n810bm *bm = device_to_n810bm(dev); + 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)); ++ if (bm->battery_present) { ++ millivolt = n810bm_measure_batt_voltage(bm); ++ if (millivolt >= 0) { ++ count = snprintf(buf, PAGE_SIZE, "%u\n", ++ n810bm_mvolt2percent(millivolt)); ++ err = 0; ++ } ++ } else { ++ count = snprintf(buf, PAGE_SIZE, "no battery\n"); + err = 0; + } + spin_unlock_irq(&bm->lock); @@ -401,13 +656,15 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + struct device_attribute *attr, + char *buf) +{ -+ struct platform_device *pdev = to_platform_device(dev); -+ struct n810bm *bm = platform_get_drvdata(pdev); ++ struct n810bm *bm = device_to_n810bm(dev); + ssize_t count; + + spin_lock_irq(&bm->lock); -+ count = snprintf(buf, PAGE_SIZE, "%u\n", -+ (unsigned int)bm->capacity); ++ if (bm->battery_present) { ++ count = snprintf(buf, PAGE_SIZE, "%d\n", ++ (int)bm->capacity); ++ } else ++ count = snprintf(buf, PAGE_SIZE, "no battery\n"); + spin_unlock_irq(&bm->lock); + + return count; @@ -418,8 +675,7 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + struct device_attribute *attr, + char *buf) +{ -+ struct platform_device *pdev = to_platform_device(dev); -+ struct n810bm *bm = platform_get_drvdata(pdev); ++ struct n810bm *bm = device_to_n810bm(dev); + ssize_t count = 0; + int k, err = -ENODEV; + @@ -435,33 +691,36 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c +} +static DEVICE_ATTR(batt_temp, 0444, n810bm_attr_battemp_show, NULL); + -+static ssize_t n810bm_attr_charger_voltage(struct device *dev, -+ struct device_attribute *attr, -+ char *buf) ++static ssize_t n810bm_attr_charger_voltage_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); ++ struct n810bm *bm = device_to_n810bm(dev); + ssize_t count = 0; + int mv, err = -ENODEV; + + spin_lock_irq(&bm->lock); -+ mv = n810bm_measure_charger_voltage(bm); -+ if (mv >= 0) { -+ count = snprintf(buf, PAGE_SIZE, "%d\n", mv); ++ if (bm->charger_present) { ++ mv = n810bm_measure_charger_voltage(bm); ++ if (mv >= 0) { ++ count = snprintf(buf, PAGE_SIZE, "%d\n", mv); ++ err = 0; ++ } ++ } else { ++ count = snprintf(buf, PAGE_SIZE, "no charger\n"); + err = 0; + } + spin_unlock_irq(&bm->lock); + + return err ? err : count; +} -+static DEVICE_ATTR(charger_voltage, 0444, n810bm_attr_charger_voltage, NULL); ++static DEVICE_ATTR(charger_voltage, 0444, n810bm_attr_charger_voltage_show, NULL); + -+static ssize_t n810bm_attr_backup_batt_voltage(struct device *dev, -+ struct device_attribute *attr, -+ char *buf) ++static ssize_t n810bm_attr_backup_batt_voltage_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); ++ struct n810bm *bm = device_to_n810bm(dev); + ssize_t count = 0; + int mv, err = -ENODEV; + @@ -475,11 +734,101 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + + return err ? err : count; +} -+static DEVICE_ATTR(backup_batt_voltage, 0444, n810bm_attr_backup_batt_voltage, NULL); ++static DEVICE_ATTR(backup_batt_voltage, 0444, n810bm_attr_backup_batt_voltage_show, NULL); ++ ++static ssize_t n810bm_attr_batt_current_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct n810bm *bm = device_to_n810bm(dev); ++ ssize_t count = 0; ++ int ma; ++ ++ spin_lock_irq(&bm->lock); ++ if (bm->battery_present) { ++ ma = n810bm_measure_batt_current(bm);//FIXME ++ count = snprintf(buf, PAGE_SIZE, "%d\n", ma); ++ } else ++ count = snprintf(buf, PAGE_SIZE, "no battery\n"); ++ spin_unlock_irq(&bm->lock); ++ ++ return count; ++} ++static DEVICE_ATTR(batt_current, 0444, n810bm_attr_batt_current_show, NULL); ++ ++//TODO remove this ++static ssize_t n810bm_attr_charger_status_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct n810bm *bm = device_to_n810bm(dev); ++ ssize_t count = 0; ++ unsigned int stat; ++ ++ spin_lock_irq(&bm->lock); ++ stat = retu_read(bm, RETU_REG_STATUS); ++ count = snprintf(buf, PAGE_SIZE, "0x%X\n", stat); ++ spin_unlock_irq(&bm->lock); ++ ++ return count; ++} ++static DEVICE_ATTR(charger_status, 0444, n810bm_attr_charger_status_show, NULL); ++ ++//TODO remove this ++static ssize_t n810bm_attr_charge_current_show(struct device *dev, ++ struct device_attribute *attr, ++ char *buf) ++{ ++ struct n810bm *bm = device_to_n810bm(dev); ++ ssize_t count = 0; ++ unsigned int val; ++ ++ spin_lock_irq(&bm->lock); ++ val = tahvo_read(bm, TAHVO_REG_CHGCURR); ++ count = snprintf(buf, PAGE_SIZE, "0x%X\n", val); ++ spin_unlock_irq(&bm->lock); ++ ++ return count; ++} ++ ++static ssize_t n810bm_attr_charge_current_store(struct device *dev, ++ struct device_attribute *attr, ++ const char *buf, size_t count) ++{ ++ struct n810bm *bm = device_to_n810bm(dev); ++ unsigned long val; ++ int err; ++ ++ spin_lock_irq(&bm->lock); ++ err = strict_strtoul(buf, 0, &val); ++ if (!err && val <= 0xFF) ++ tahvo_write(bm, TAHVO_REG_CHGCURR, val); ++ spin_unlock_irq(&bm->lock); ++ ++ return err ? err : count; ++} ++static DEVICE_ATTR(charge_current, 0644, ++ n810bm_attr_charge_current_show, ++ n810bm_attr_charge_current_store); ++ ++static const struct device_attribute *n810bm_attrs[] = { ++ &dev_attr_batt_present, ++ &dev_attr_batt_charge, ++ &dev_attr_batt_current, ++ &dev_attr_batt_capacity, ++ &dev_attr_batt_temp, ++ &dev_attr_backup_batt_voltage, ++ &dev_attr_charger_present, ++ &dev_attr_charger_voltage, ++ &dev_attr_charger_status, ++ &dev_attr_charger_enable, ++ &dev_attr_charge_current, ++}; + +static void n810bm_hw_exit(struct n810bm *bm) +{ + retu_write(bm, RETU_REG_ADCSCR, 0); ++ //TODO +} + +static int n810bm_hw_init(struct n810bm *bm) @@ -488,22 +837,103 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + + err = n810bm_check_adc_sanity(bm); + if (err) ++ return err; ++ ++ return 0; ++} ++ ++static int n810bm_device_init(struct n810bm *bm) ++{ ++ int attr_index; ++ int err; ++ ++ err = n810bm_hw_init(bm); ++ if (err) + goto error; -+ bm->capacity = n810bm_read_batt_capacity(bm); -+ if (bm->capacity == N810BM_CAP_UNKNOWN) { -+ dev_err(&bm->pdev->dev, "Unknown battery detected"); -+ err = -ENODEV; -+ goto error; ++ for (attr_index = 0; attr_index < ARRAY_SIZE(n810bm_attrs); attr_index++) { ++ err = device_create_file(&bm->pdev->dev, n810bm_attrs[attr_index]); ++ if (err) ++ goto err_unwind_attrs; + } -+ dev_info(&bm->pdev->dev, "Detected %u mAh battery\n", -+ (unsigned int)bm->capacity); ++ err = retu_request_irq(RETU_INT_ADCS, ++ n810bm_adc_irq_handler, ++ (unsigned long)bm, "n810bm"); ++ if (err) ++ goto err_unwind_attrs; ++ err = tahvo_request_irq(TAHVO_INT_BATCURR, ++ n810bm_tahvo_current_measure_irq_handler, ++ (unsigned long)bm, "n810bm"); ++ if (err) ++ goto err_free_retu_irq; ++ ++ lipocharge_init(&bm->charger); ++ mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL)); ++ ++ bm->initialized = 1; ++ dev_info(&bm->pdev->dev, "Battery management initialized"); + + return 0; + ++err_free_retu_irq: ++ retu_free_irq(RETU_INT_ADCS); ++err_unwind_attrs: ++ for (attr_index--; attr_index >= 0; attr_index--) ++ device_remove_file(&bm->pdev->dev, n810bm_attrs[attr_index]); ++/*err_exit:*/ ++ n810bm_hw_exit(bm); +error: + return err; +} + ++static void n810bm_device_exit(struct n810bm *bm) ++{ ++ int i; ++ ++ if (!bm->initialized) ++ return; ++ ++ lipocharge_exit(&bm->charger); ++ tahvo_free_irq(TAHVO_INT_BATCURR); ++ retu_free_irq(RETU_INT_ADCS); ++ del_timer_sync(&bm->check_timer); ++ for (i = 0; i < ARRAY_SIZE(n810bm_attrs); i++) ++ device_remove_file(&bm->pdev->dev, n810bm_attrs[i]); ++ n810bm_hw_exit(bm); ++ release_firmware(bm->pmm_block); ++ ++ bm->initialized = 0; ++} ++ ++static void n810bm_pmm_block_found(const struct firmware *fw, void *context) ++{ ++ struct n810bm *bm = context; ++ int err; ++ ++ if (!fw) { ++ dev_err(&bm->pdev->dev, ++ "CAL PMM block image file not found"); ++ goto error; ++ } ++ if (fw->size != N810BM_PMM_BLOCK_SIZE || ++ memcmp(fw->data, "BME-PMM-BLOCK01", 15) != 0) { ++ dev_err(&bm->pdev->dev, ++ "CAL PMM block image file has an invalid format"); ++ goto error; ++ } ++ ++ bm->pmm_block = fw; ++ err = n810bm_device_init(bm); ++ if (err) { ++ dev_err(&bm->pdev->dev, ++ "Failed to initialized battery management (%d)", err); ++ goto error; ++ } ++ ++ return; ++error: ++ release_firmware(fw); ++} ++ +static int __devinit n810bm_probe(struct platform_device *pdev) +{ + struct n810bm *bm; @@ -517,50 +947,23 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c + spin_lock_init(&bm->lock); + setup_timer(&bm->check_timer, n810bm_check_timer, (unsigned long)bm); + -+ err = n810bm_hw_init(bm); -+ if (err) ++ dev_info(&bm->pdev->dev, "Requesting CAL BME PMM block firmware file " ++ N810BM_PMM_BLOCK_FILENAME); ++ err = request_firmware_nowait(THIS_MODULE, 1, ++ N810BM_PMM_BLOCK_FILENAME, ++ &bm->pdev->dev, GFP_KERNEL, ++ bm, n810bm_pmm_block_found); ++ if (err) { ++ dev_err(&bm->pdev->dev, ++ "Failed to request CAL PMM block image file (%d)", 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 = device_create_file(&pdev->dev, &dev_attr_batt_temp); -+ if (err) -+ goto err_rem_capa; -+ err = device_create_file(&pdev->dev, &dev_attr_charger_voltage); -+ if (err) -+ goto err_rem_temp; -+ err = device_create_file(&pdev->dev, &dev_attr_backup_batt_voltage); -+ if (err) -+ goto err_rem_chg; -+ err = retu_request_irq(RETU_INT_ADCS, n810bm_adc_irq_handler, -+ (unsigned long)bm, "n810bm"); -+ if (err) -+ goto err_rem_bkup; -+ -+ mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL)); -+ -+ dev_info(&pdev->dev, "Battery management initialized"); ++ } + + return 0; + -+err_rem_bkup: -+ device_remove_file(&pdev->dev, &dev_attr_backup_batt_voltage); -+err_rem_chg: -+ device_remove_file(&pdev->dev, &dev_attr_charger_voltage); -+err_rem_temp: -+ device_remove_file(&pdev->dev, &dev_attr_batt_temp); -+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; +} + @@ -568,14 +971,7 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c +{ + 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_backup_batt_voltage); -+ device_remove_file(&pdev->dev, &dev_attr_charger_voltage); -+ device_remove_file(&pdev->dev, &dev_attr_batt_temp); -+ device_remove_file(&pdev->dev, &dev_attr_batt_capacity); -+ device_remove_file(&pdev->dev, &dev_attr_batt_charge); -+ n810bm_hw_exit(bm); ++ n810bm_device_exit(bm); + + kfree(bm); + platform_set_drvdata(pdev, NULL); @@ -603,12 +999,13 @@ Index: linux-2.6.37/drivers/cbus/n810bm_main.c +module_exit(n810bm_modexit); + +MODULE_DESCRIPTION("Nokia n810 battery management"); ++MODULE_FIRMWARE(N810BM_PMM_BLOCK_FILENAME); +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Michael Buesch"); Index: linux-2.6.37/drivers/cbus/retu.c =================================================================== ---- linux-2.6.37.orig/drivers/cbus/retu.c 2011-01-28 22:33:39.695216760 +0100 -+++ linux-2.6.37/drivers/cbus/retu.c 2011-01-28 22:33:39.754206648 +0100 +--- linux-2.6.37.orig/drivers/cbus/retu.c 2011-02-06 00:24:48.493004751 +0100 ++++ linux-2.6.37/drivers/cbus/retu.c 2011-02-06 00:24:48.551008149 +0100 @@ -85,10 +85,10 @@ * * This function writes a value to the specified register @@ -624,17 +1021,18 @@ Index: linux-2.6.37/drivers/cbus/retu.c void retu_set_clear_reg_bits(int reg, u16 set, u16 clear) Index: linux-2.6.37/drivers/cbus/retu.h =================================================================== ---- linux-2.6.37.orig/drivers/cbus/retu.h 2011-01-28 22:33:39.695216760 +0100 -+++ linux-2.6.37/drivers/cbus/retu.h 2011-01-28 22:40:55.380584650 +0100 -@@ -39,6 +39,7 @@ - #define RETU_REG_CC2 0x0e /* Common control register 2 */ +--- linux-2.6.37.orig/drivers/cbus/retu.h 2011-02-06 00:24:48.493004751 +0100 ++++ linux-2.6.37/drivers/cbus/retu.h 2011-02-06 00:24:48.551008149 +0100 +@@ -40,6 +40,8 @@ #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_STATUS_BATAVAIL 0x0100 /* Battery available */ ++#define RETU_REG_STATUS_CHGPLUG 0x1000 /* Charger is plugged in */ #define RETU_REG_WATCHDOG 0x17 /* Watchdog register */ #define RETU_REG_AUDTXR 0x18 /* Audio Codec Tx register */ -@@ -57,8 +58,25 @@ + #define RETU_REG_MAX 0x1f +@@ -57,8 +59,25 @@ #define MAX_RETU_IRQ_HANDLERS 16 @@ -663,8 +1061,8 @@ Index: linux-2.6.37/drivers/cbus/retu.h int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name); Index: linux-2.6.37/arch/arm/mach-omap2/board-n8x0.c =================================================================== ---- linux-2.6.37.orig/arch/arm/mach-omap2/board-n8x0.c 2011-01-28 22:33:39.679219500 +0100 -+++ linux-2.6.37/arch/arm/mach-omap2/board-n8x0.c 2011-01-28 22:33:39.754206648 +0100 +--- linux-2.6.37.orig/arch/arm/mach-omap2/board-n8x0.c 2011-02-06 00:24:48.478003872 +0100 ++++ linux-2.6.37/arch/arm/mach-omap2/board-n8x0.c 2011-02-06 00:24:48.551008149 +0100 @@ -907,6 +907,17 @@ ARRAY_SIZE(n8x0_gpio_switches)); } @@ -695,8 +1093,8 @@ Index: linux-2.6.37/arch/arm/mach-omap2/board-n8x0.c Index: linux-2.6.37/drivers/cbus/lipocharge.c =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.37/drivers/cbus/lipocharge.c 2011-01-28 22:33:39.755206476 +0100 -@@ -0,0 +1,63 @@ ++++ linux-2.6.37/drivers/cbus/lipocharge.c 2011-02-06 12:57:01.427475867 +0100 +@@ -0,0 +1,58 @@ +/* + * Generic LIPO battery charger + * @@ -727,32 +1125,27 @@ Index: linux-2.6.37/drivers/cbus/lipocharge.c + spin_unlock(&c->lock); +} + -+struct lipocharge * lipocharge_alloc(gfp_t gfp) ++void lipocharge_init(struct lipocharge *c) +{ -+ 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) ++void lipocharge_exit(struct lipocharge *c) +{ -+ kfree(c); +} + +int lipocharge_start(struct lipocharge *c) +{ -+ if (!c->set_current || !c->get_voltage || ++ if (!c->set_charge_current || !c->get_charge_current || ++ !c->get_voltage || + !c->finished || !c->emergency) + return -EINVAL; + if (!c->top_voltage || c->top_voltage > 4200) + return -EINVAL; + //TODO ++ ++ return 0; +} + +void lipocharge_stop(struct lipocharge *c) @@ -763,8 +1156,8 @@ Index: linux-2.6.37/drivers/cbus/lipocharge.c Index: linux-2.6.37/drivers/cbus/lipocharge.h =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.37/drivers/cbus/lipocharge.h 2011-01-28 22:33:39.755206476 +0100 -@@ -0,0 +1,50 @@ ++++ linux-2.6.37/drivers/cbus/lipocharge.h 2011-02-06 12:36:29.800830614 +0100 +@@ -0,0 +1,55 @@ +#ifndef LIPOCHARGE_H_ +#define LIPOCHARGE_H_ + @@ -775,6 +1168,7 @@ Index: linux-2.6.37/drivers/cbus/lipocharge.h +#define LIPORATE(a,b) (((a) * 1000) + (b)) +#define LIPORATE_1C LIPORATE(1,0) /* 1C */ +#define LIPORATE_p8C LIPORATE(0,8) /* 0.8C */ ++#define LIPORATE_p6C LIPORATE(0,6) /* 0.6C */ + +/** struct lipocharge - A generic LIPO charger + * @@ -782,55 +1176,91 @@ Index: linux-2.6.37/drivers/cbus/lipocharge.h + * @rate: Charge rate. + * @top_voltage: Fully charged voltage, in mV. + * -+ * @set_current: Set the charge current, in mA. ++ * @set_charge_current: Set the charge current, in mA. ++ * @get_charge_current: Get the battery current, in signed mA. + * @get_voltage: Get the battery voltage, in mV. + * ++ * @finished: Charging finished. + * @emergency: Something went wrong. Force shutdown. -+ * -+ * @priv: opaque pointer. + */ -+struct lipocharge -+{ ++struct lipocharge { + unsigned int capacity; + unsigned int rate; + unsigned int top_voltage; + -+ int (*set_current)(struct lipocharge *c, unsigned int ma); ++ int (*set_charge_current)(struct lipocharge *c, unsigned int ma); ++ int (*get_charge_current)(struct lipocharge *c, 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; ++ bool charging; +}; + -+struct lipocharge * lipocharge_alloc(gfp_t gfp); -+void lipocharge_free(struct lipocharge *c); ++void lipocharge_init(struct lipocharge *c); ++void lipocharge_exit(struct lipocharge *c); + +int lipocharge_start(struct lipocharge *c); +void lipocharge_stop(struct lipocharge *c); + ++static inline bool lipocharge_is_charging(struct lipocharge *c) ++{ ++ return c->charging; ++} ++ +#endif /* LIPOCHARGE_H_ */ Index: linux-2.6.37/drivers/cbus/tahvo.h =================================================================== ---- linux-2.6.37.orig/drivers/cbus/tahvo.h 2011-01-28 22:33:39.696216589 +0100 -+++ linux-2.6.37/drivers/cbus/tahvo.h 2011-01-28 22:33:39.755206476 +0100 -@@ -30,8 +30,14 @@ +--- linux-2.6.37.orig/drivers/cbus/tahvo.h 2011-02-06 00:24:48.494004810 +0100 ++++ linux-2.6.37/drivers/cbus/tahvo.h 2011-02-06 00:24:48.551008149 +0100 +@@ -30,17 +30,28 @@ #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_CHGCURR 0x04 /* Charge current control PWM (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_CHGCTL_EN 0x0001 /* Global charge enable */ ++#define TAHVO_REG_CHGCTL_PWMOVR 0x0004 /* PWM override. Force charge PWM to 100% duty cycle. */ ++#define TAHVO_REG_CHGCTL_UNK8 0x0008 /* XXX: Unknown. Written on init. */ ++#define TAHVO_REG_CHGCTL_CURMEAS 0x0040 /* Enable battery current measurement. */ ++#define TAHVO_REG_CHGCTL_CURTIMRST 0x0080 /* Current measure timer reset. */ ++#define TAHVO_REG_BATCURRTIMER 0x0c /* Battery current measure timer (8-bit) */ +#define TAHVO_REG_BATCURR 0x0d /* Battery (dis)charge current (signed 16-bit) */ + #define TAHVO_REG_MAX 0x0d /* Interrupt sources */ + #define TAHVO_INT_VBUSON 0 ++#define TAHVO_INT_BATCURR 7 /* Battery current measure timer */ + + #define MAX_TAHVO_IRQ_HANDLERS 8 + + int tahvo_read_reg(int reg); +-void tahvo_write_reg(int reg, u16 val); ++int tahvo_write_reg(int reg, u16 val); + void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear); + int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name); + void tahvo_free_irq(int id); +Index: linux-2.6.37/drivers/cbus/tahvo.c +=================================================================== +--- linux-2.6.37.orig/drivers/cbus/tahvo.c 2011-02-06 00:24:48.494004810 +0100 ++++ linux-2.6.37/drivers/cbus/tahvo.c 2011-02-06 00:24:48.552008207 +0100 +@@ -85,10 +85,10 @@ + * + * This function writes a value to the specified register + */ +-void tahvo_write_reg(int reg, u16 val) ++int tahvo_write_reg(int reg, u16 val) + { + BUG_ON(!tahvo_initialized); +- cbus_write_reg(cbus_host, TAHVO_ID, reg, val); ++ return cbus_write_reg(cbus_host, TAHVO_ID, reg, val); + } + + /** |