drivers/cbus/tahvo.h | 6
9 files changed, 548 insertions(+), 3 deletions(-)
-Index: linux-2.6.37-rc1/drivers/cbus/Kconfig
+Index: linux-2.6.37.1/drivers/cbus/Kconfig
===================================================================
---- linux-2.6.37-rc1.orig/drivers/cbus/Kconfig 2010-11-06 17:28:21.821000000 +0100
-+++ linux-2.6.37-rc1/drivers/cbus/Kconfig 2010-11-06 17:28:21.872000001 +0100
-@@ -94,4 +94,16 @@
+--- linux-2.6.37.1.orig/drivers/cbus/Kconfig 2011-02-19 20:26:01.282338290 +0100
++++ linux-2.6.37.1/drivers/cbus/Kconfig 2011-02-19 20:26:01.526318768 +0100
+@@ -94,4 +94,12 @@
to Retu/Vilma. Detection state and events are exposed through
sysfs.
+ ---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
+Index: linux-2.6.37.1/drivers/cbus/Makefile
===================================================================
---- linux-2.6.37-rc1.orig/drivers/cbus/Makefile 2010-11-06 17:28:21.812000054 +0100
-+++ linux-2.6.37-rc1/drivers/cbus/Makefile 2010-11-06 17:28:21.872000001 +0100
+--- linux-2.6.37.1.orig/drivers/cbus/Makefile 2011-02-19 20:26:01.250340850 +0100
++++ linux-2.6.37.1/drivers/cbus/Makefile 2011-02-19 20:26:01.526318768 +0100
@@ -12,3 +12,6 @@
obj-$(CONFIG_CBUS_TAHVO_USER) += tahvo-user.o
obj-$(CONFIG_CBUS_RETU_USER) += retu-user.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
+Index: linux-2.6.37.1/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-06 17:28:21.872000001 +0100
-@@ -0,0 +1,397 @@
++++ linux-2.6.37.1/drivers/cbus/n810bm_main.c 2011-02-20 15:11:55.764356685 +0100
+@@ -0,0 +1,1559 @@
+/*
+ * Nokia n810 battery management
+ *
-+ * WARNING: This driver is based on reverse engineered information.
++ * WARNING: This driver is based on unconfirmed documentation.
+ * It is possibly dangerous to use this software.
+ * Use this software at your own risk!
+ *
-+ * Copyright (c) 2010 Michael Buesch <mb@bu3sch.de>
++ * Copyright (c) 2010-2011 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
+ * GNU General Public License for more details.
+ */
+
++#define DEBUG
++
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
-+#include <linux/spinlock.h>
++#include <linux/mutex.h>
+#include <linux/timer.h>
-+#include <linux/reboot.h>
++#include <linux/firmware.h>
++#include <linux/bitops.h>
++#include <linux/workqueue.h>
++#include <linux/delay.h>
+
++#include "cbus.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 */
++#define N810BM_PMM_BLOCK_FILENAME "n810-cal-bme-pmm.fw"
++#define N810BM_PMM_BLOCK_SIZE 0x600
++#define N810BM_PMM_GROUP_SIZE 0x200
++#define N810BM_PMM_ELEM_SIZE 0x10
+
++#define N810BM_CHECK_INTERVAL (HZ * 2)
++#define N810BM_MIN_VOLTAGE_THRES 3200 /* 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
+ */
+
+
++enum n810bm_pmm_adc_id {
++ N810BM_PMM_ADC_0x01 = 0x01,
++ N810BM_PMM_ADC_0x02 = 0x02,
++ N810BM_PMM_ADC_0x03 = 0x03,
++ N810BM_PMM_ADC_0x04 = 0x04,
++ N810BM_PMM_ADC_BATTEMP = 0x05,
++ N810BM_PMM_ADC_0x06 = 0x06,
++ N810BM_PMM_ADC_0x07 = 0x07,
++ N810BM_PMM_ADC_0x08 = 0x08,
++ N810BM_PMM_ADC_0x0E = 0x0E,
++ N810BM_PMM_ADC_0x13 = 0x13,
++ N810BM_PMM_ADC_0x14 = 0x14,
++ N810BM_PMM_ADC_0x15 = 0x15,
++ N810BM_PMM_ADC_0x16 = 0x16,
++ N810BM_PMM_ADC_0x17 = 0x17,
++ N810BM_PMM_ADC_0xFE = 0xFE,
++};
++
++struct n810bm_adc_calib {
++ enum n810bm_pmm_adc_id id;
++ u8 flags;
++ u8 adc_groupnr;
++ u32 field1;
++ u32 field2;
++ u16 field3;
++ u16 field4;
++};
++
++struct n810bm_calib {
++ struct n810bm_adc_calib adc[25];
++};
++
+enum n810bm_capacity {
-+ N810BM_CAP_UNKNOWN = 0,
++ N810BM_CAP_UNKNOWN = -1,
++ N810BM_CAP_NONE = 0,
+ N810BM_CAP_1500MAH = 1500, /* 1500 mAh battery */
+};
+
++enum n810bm_notify_flags {
++ N810BM_NOTIFY_battery_charging,
++ N810BM_NOTIFY_charger_pwm,
++};
++
+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? */
++ struct lipocharge charger; /* Charger subsystem */
++ unsigned int active_current_pwm; /* Active value of TAHVO_REG_CHGCURR */
++ int current_measure_enabled; /* Current measure enable refcount */
++
+ struct platform_device *pdev;
++ struct n810bm_calib calib; /* Calibration data */
+
-+ enum n810bm_capacity capacity;
-+ struct timer_list check_timer;
++ bool verbose_charge_log; /* Verbose charge logging */
+
-+ struct lipocharge *charger;
++ unsigned long notify_flags;
++ struct work_struct notify_work;
++ struct work_struct currmeas_irq_work;
++ struct delayed_work periodic_check_work;
+
-+ spinlock_t lock;
++ bool initialized; /* The hardware was initialized */
++ struct mutex mutex;
+};
+
++static void n810bm_notify_battery_charging(struct n810bm *bm);
++static void n810bm_notify_charger_pwm(struct n810bm *bm);
++
++
++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 inline bool n810bm_known_battery_present(struct n810bm *bm)
++{
++ return bm->battery_present &&
++ bm->capacity != N810BM_CAP_UNKNOWN &&
++ bm->capacity != N810BM_CAP_NONE;
++}
+
+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");
++ cbus_emergency();
++}
++
++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);
+}
+
-+#if 0
+static u16 retu_read(struct n810bm *bm, unsigned int reg)
+{
+ int ret;
+
+ return ret;
+}
-+#endif
+
+static void retu_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set)
+{
+
+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,
+ return value;
+}
+
++static int pmm_record_get(struct n810bm *bm,
++ const struct firmware *pmm_block,
++ void *buffer, size_t length,
++ unsigned int group, unsigned int element, unsigned int offset)
++{
++ const u8 *pmm_area = pmm_block->data;
++ u8 active_group_mask;
++
++ if (pmm_block->size != N810BM_PMM_BLOCK_SIZE)
++ return -EINVAL;
++ if (group >= N810BM_PMM_BLOCK_SIZE / N810BM_PMM_GROUP_SIZE)
++ return -EINVAL;
++ if (element >= N810BM_PMM_GROUP_SIZE / N810BM_PMM_ELEM_SIZE)
++ return -EINVAL;
++ if (offset >= N810BM_PMM_ELEM_SIZE || length > N810BM_PMM_ELEM_SIZE ||
++ length + offset > N810BM_PMM_ELEM_SIZE)
++ return -EINVAL;
++
++ active_group_mask = pmm_area[16];
++ if (!(active_group_mask & (1 << group))) {
++ dev_dbg(&bm->pdev->dev, "pwm_record_get: Requested group %u, "
++ "but group is not active", group);
++ return -ENOENT;
++ }
++
++ memcpy(buffer,
++ pmm_area + group * N810BM_PMM_GROUP_SIZE
++ + element * N810BM_PMM_ELEM_SIZE
++ + offset,
++ length);
++
++ return 0;
++}
++
++/* PMM block group 1 element */
++struct group1_element {
++ u8 id;
++ u8 flags;
++ u8 adc_groupnr;
++ u8 _padding;
++ __le32 field1;
++ __le32 field2;
++} __packed;
++
++static void extract_group1_elem(struct n810bm *bm,
++ const struct firmware *pmm_block,
++ const u8 *pmm_adc_ids, size_t nr_pmm_adc_ids,
++ u32 field1_mask, u32 field2_mask)
++{
++ struct group1_element elem;
++ int err;
++ unsigned int i, element_nr;
++ struct n810bm_adc_calib *adc_calib;
++
++ for (i = 0; i < nr_pmm_adc_ids; i++) {
++ element_nr = pmm_adc_ids[i] + 3;
++
++ err = pmm_record_get(bm, pmm_block, &elem, sizeof(elem),
++ 1, element_nr, 0);
++ if (err)
++ continue;
++ WARN_ON(element_nr - 3 + 1 >= ARRAY_SIZE(bm->calib.adc));
++ adc_calib = &bm->calib.adc[element_nr - 3 + 1];
++
++ if (adc_calib->flags == elem.flags) {
++ WARN_ON(adc_calib->id != elem.id);
++ adc_calib->field1 = le32_to_cpu(elem.field1) & field1_mask;
++ adc_calib->field2 = le32_to_cpu(elem.field2) & field2_mask;
++ }
++ }
++}
++
++static int n810bm_parse_pmm_group1(struct n810bm *bm,
++ const struct firmware *pmm_block)
++{
++ struct group1_element elem;
++ int err;
++
++ static const u8 pmm_adc_ids_0[] = {
++ N810BM_PMM_ADC_0x01,
++ N810BM_PMM_ADC_0x02,
++ N810BM_PMM_ADC_0x13,
++ N810BM_PMM_ADC_0x0E,
++ };
++ static const u8 pmm_adc_ids_1[] = {
++ N810BM_PMM_ADC_0x04,
++ };
++ static const u8 pmm_adc_ids_2[] = {
++ N810BM_PMM_ADC_BATTEMP,
++ };
++
++ /* Parse element 2 */
++ err = pmm_record_get(bm, pmm_block, &elem, sizeof(elem),
++ 1, 2, 0);
++ if (err) {
++ dev_err(&bm->pdev->dev,
++ "PMM: Failed to get group 1 / element 2");
++ return err;
++ }
++ if (elem.id == N810BM_PMM_ADC_0xFE && elem.flags == 0x05) {
++ bm->calib.adc[0].id = elem.id;
++ bm->calib.adc[0].flags = elem.flags;
++ bm->calib.adc[0].field1 = le32_to_cpu(elem.field1);
++ bm->calib.adc[0].field2 = le32_to_cpu(elem.field2);
++ }
++
++ extract_group1_elem(bm, pmm_block,
++ pmm_adc_ids_0, ARRAY_SIZE(pmm_adc_ids_0),
++ 0xFFFFFFFF, 0xFFFFFFFF);
++ extract_group1_elem(bm, pmm_block,
++ pmm_adc_ids_1, ARRAY_SIZE(pmm_adc_ids_1),
++ 0xFFFFFFFF, 0);
++ extract_group1_elem(bm, pmm_block,
++ pmm_adc_ids_2, ARRAY_SIZE(pmm_adc_ids_2),
++ 0xFFFFFFFF, 0x0000FFFF);
++
++ return 0;
++}
++
++static int n810bm_parse_pmm_group2(struct n810bm *bm,
++ const struct firmware *pmm_block)
++{
++ dev_err(&bm->pdev->dev, "TODO: CAL BME PMM group 2 parser not implemented, yet");
++ return -EOPNOTSUPP;
++}
++
++static void n810bm_adc_calib_set_defaults(struct n810bm *bm)
++{
++ struct n810bm_adc_calib *adc_calib;
++ const struct n810bm_adc_calib *def;
++ unsigned int i, index;
++
++ static const struct n810bm_adc_calib defaults[] = {
++ /* ADC group-nr 0 */
++ {
++ .id = N810BM_PMM_ADC_0x06,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ }, {
++ .id = N810BM_PMM_ADC_0x07,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ }, {
++ .id = N810BM_PMM_ADC_0x15,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ }, {
++ .id = N810BM_PMM_ADC_0x08,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ }, {
++ .id = N810BM_PMM_ADC_0x16,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ }, {
++ .id = N810BM_PMM_ADC_0x17,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ }, {
++ .id = N810BM_PMM_ADC_0x03,
++ .flags = 0x00,
++ .adc_groupnr = 0,
++ },
++ /* ADC group-nr 1 */
++ {
++ .id = N810BM_PMM_ADC_0xFE,
++ .flags = 0x05,
++ .adc_groupnr = 1,
++ .field1 = (u32)-2,
++ .field2 = 13189,
++ }, {
++ .id = N810BM_PMM_ADC_0x01,
++ .flags = 0x01,
++ .adc_groupnr = 1,
++ .field1 = 2527,
++ .field2 = 21373,
++ }, {
++ .id = N810BM_PMM_ADC_0x02,
++ .flags = 0x01,
++ .adc_groupnr = 1,
++ .field1 = 0,
++ .field2 = 129848,
++ }, {
++ .id = N810BM_PMM_ADC_0x13,
++ .flags = 0x01,
++ .adc_groupnr = 1,
++ .field1 = 0,
++ .field2 = 20000,
++ }, {
++ .id = N810BM_PMM_ADC_0x0E,
++ .flags = 0x06,
++ .adc_groupnr = 1,
++ .field1 = 0,
++ .field2 = 9660,
++ },
++ /* ADC group-nr 2 */
++ {
++ .id = N810BM_PMM_ADC_0x04,
++ .flags = 0x02,
++ .adc_groupnr = 2,
++ .field1 = 1169,
++ .field2 = 0,
++ },
++ /* ADC group-nr 3 */
++ {
++ .id = N810BM_PMM_ADC_BATTEMP,
++ .flags = 0x03,
++ .adc_groupnr = 3,
++ .field1 = 265423000,
++ .field2 = 298,
++ },
++ /* ADC group-nr 4 */
++ {
++ .id = N810BM_PMM_ADC_0x14,
++ .flags = 0x04,
++ .adc_groupnr = 4,
++ .field1 = 19533778,
++ .field2 = 308019670,
++ .field3 = 4700,
++ .field4 = 2500,
++ },
++ };
++
++ /* Clear the array */
++ memset(&bm->calib.adc, 0, sizeof(bm->calib.adc));
++ for (i = 0; i < ARRAY_SIZE(bm->calib.adc); i++)
++ bm->calib.adc[i].flags = 0xFF;
++
++ /* Copy the defaults */
++ for (i = 0; i < ARRAY_SIZE(defaults); i++) {
++ def = &defaults[i];
++
++ index = 0;
++ if (def->id != N810BM_PMM_ADC_0xFE)
++ index = def->id + 1;
++ WARN_ON(index >= ARRAY_SIZE(bm->calib.adc));
++
++ adc_calib = &bm->calib.adc[index];
++ *adc_calib = *def;
++ }
++}
++
++static const struct n810bm_adc_calib * n810bm_get_adc_calib(struct n810bm *bm,
++ enum n810bm_pmm_adc_id id)
++{
++ unsigned int index = 0;
++
++ if (id != N810BM_PMM_ADC_0xFE)
++ index = (unsigned int)id + 1;
++ WARN_ON(index >= ARRAY_SIZE(bm->calib.adc));
++
++ return &bm->calib.adc[index];
++}
++
++static int n810bm_parse_pmm_block(struct n810bm *bm,
++ const struct firmware *pmm_block)
++{
++ u8 byte;
++ int err;
++ unsigned int i, count;
++ struct n810bm_adc_calib *adc_calib;
++
++ /* Initialize to defaults */
++ n810bm_adc_calib_set_defaults(bm);
++
++ /* Parse the PMM data */
++ err = pmm_record_get(bm, pmm_block, &byte, sizeof(byte),
++ 1, 0, 0); /* group 1 / element 0 */
++ err |= (byte != 0x01);
++ err |= pmm_record_get(bm, pmm_block, &byte, sizeof(byte),
++ 1, 1, 0); /* group 1 / element 1 */
++ err |= (byte != 0x01);
++ if (err)
++ err = n810bm_parse_pmm_group2(bm, pmm_block);
++ else
++ err = n810bm_parse_pmm_group1(bm, pmm_block);
++ if (err)
++ return err;
++
++ /* Sanity checks */
++ for (i = 0, count = 0; i < ARRAY_SIZE(bm->calib.adc); i++) {
++ adc_calib = &bm->calib.adc[i];
++ if (adc_calib->flags == 0xFF)
++ continue;
++ switch (adc_calib->id) {
++ case N810BM_PMM_ADC_0x01:
++ if (adc_calib->field1 < 2400 ||
++ adc_calib->field1 > 2700)
++ goto value_check_fail;
++ if (adc_calib->field2 < 20000 ||
++ adc_calib->field2 > 23000)
++ goto value_check_fail;
++ count++;
++ break;
++ case N810BM_PMM_ADC_0x04:
++ if (adc_calib->field1 < 1100 ||
++ adc_calib->field1 > 1300)
++ goto value_check_fail;
++ count++;
++ break;
++ case N810BM_PMM_ADC_0x0E:
++ if (adc_calib->field2 < 7000 ||
++ adc_calib->field2 > 12000)
++ goto value_check_fail;
++ count++;
++ break;
++ case N810BM_PMM_ADC_0xFE:
++ if ((s32)adc_calib->field1 > 14 ||
++ (s32)adc_calib->field1 < -14)
++ goto value_check_fail;
++ if (adc_calib->field2 < 13000 ||
++ adc_calib->field2 > 13350)
++ goto value_check_fail;
++ count++;
++ break;
++ case N810BM_PMM_ADC_0x02:
++ case N810BM_PMM_ADC_BATTEMP:
++ case N810BM_PMM_ADC_0x13:
++ count++;
++ break;
++ case N810BM_PMM_ADC_0x03:
++ case N810BM_PMM_ADC_0x07:
++ case N810BM_PMM_ADC_0x08:
++ case N810BM_PMM_ADC_0x06:
++ case N810BM_PMM_ADC_0x14:
++ case N810BM_PMM_ADC_0x15:
++ case N810BM_PMM_ADC_0x16:
++ case N810BM_PMM_ADC_0x17:
++ break;
++ }
++ dev_dbg(&bm->pdev->dev,
++ "ADC 0x%02X calib: 0x%02X 0x%02X 0x%08X 0x%08X 0x%04X 0x%04X",
++ adc_calib->id, adc_calib->flags, adc_calib->adc_groupnr,
++ adc_calib->field1, adc_calib->field2,
++ adc_calib->field3, adc_calib->field4);
++ }
++ if (count != 7) {
++ dev_err(&bm->pdev->dev, "PMM sanity check: Did not find "
++ "all required values (count=%u)", count);
++ goto check_fail;
++ }
++
++ return 0;
++
++value_check_fail:
++ dev_err(&bm->pdev->dev, "PMM image sanity check failed "
++ "(id=%02X, field1=%08X, field2=%08X)",
++ adc_calib->id, adc_calib->field1, adc_calib->field2);
++check_fail:
++ return -EILSEQ;
++}
++
++/* Set the current measure timer that triggers on Tahvo IRQ 7
++ * An interval of zero disables the timer. */
++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);
++
++ if (millisec_interval)
++ tahvo_enable_irq(TAHVO_INT_BATCURR);
++ else
++ tahvo_disable_irq(TAHVO_INT_BATCURR);
++
++ //TODO also do a software timer for safety.
++}
++
++static void n810bm_enable_current_measure(struct n810bm *bm)
++{
++ WARN_ON(bm->current_measure_enabled < 0);
++ if (!bm->current_measure_enabled) {
++ /* Enable the current measurement circuitry */
++ tahvo_set(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_CURMEAS);
++ dev_dbg(&bm->pdev->dev,
++ "Current measurement circuitry enabled");
++ }
++ bm->current_measure_enabled++;
++}
++
++static void n810bm_disable_current_measure(struct n810bm *bm)
++{
++ bm->current_measure_enabled--;
++ WARN_ON(bm->current_measure_enabled < 0);
++ if (!bm->current_measure_enabled) {
++ /* Disable the current measurement circuitry */
++ tahvo_clear(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_CURMEAS);
++ dev_dbg(&bm->pdev->dev,
++ "Current measurement circuitry disabled");
++ }
++}
++
++/* 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;
++
++ if (WARN_ON(bm->current_measure_enabled <= 0))
++ return 0;
++ 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;
++}
++
++/* Requires bm->mutex locked */
++static int n810bm_measure_batt_current_async(struct n810bm *bm)
++{
++ int ma;
++ bool charging = lipocharge_is_charging(&bm->charger);
++
++ n810bm_enable_current_measure(bm);
++ if (!charging)
++ WARN_ON(bm->active_current_pwm != 0);
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_EN |
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ TAHVO_REG_CHGCTL_EN |
++ TAHVO_REG_CHGCTL_PWMOVR |
++ (charging ? 0 : TAHVO_REG_CHGCTL_PWMOVRZERO));
++ ma = n810bm_measure_batt_current(bm);
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_EN |
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ (charging ? TAHVO_REG_CHGCTL_EN : 0));
++ n810bm_disable_current_measure(bm);
++
++ return ma;
++}
++
++static int adc_sanity_check(struct n810bm *bm, unsigned int channel)
++{
++ int value;
++
++ value = retu_read_adc(channel);
++ if (value < 0) {
++ dev_err(&bm->pdev->dev, "Failed to read GND ADC channel %u",
++ channel);
++ return -EIO;
++ }
++ 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;
++ }
++
++ return 0;
++}
++
++static int n810bm_check_adc_sanity(struct n810bm *bm)
++{
++ int err;
++
++ /* Discard one conversion */
++ retu_write(bm, RETU_REG_ADCSCR, 0);
++ retu_read_adc(RETU_ADC_GND2);
++
++ err = adc_sanity_check(bm, RETU_ADC_GND2);
++ if (err)
++ return err;
++
++ return 0;
++}
++
+/* Measure the battery voltage. Returns the value in mV (or negative value on error). */
+static int n810bm_measure_batt_voltage(struct n810bm *bm)
+{
+ return 2800;
+ mv = 2800 + ((adc - 0x37) * (((4200 - 2800) * scale) / (0x236 - 0x37))) / scale;
+
++ //TODO compensate for power consumption
++ //TODO honor calibration values
++
+ return mv;
+}
+
++/* Measure the charger voltage. Returns the value in mV (or negative value on error). */
++static int n810bm_measure_charger_voltage(struct n810bm *bm)
++{
++ int adc;
++ unsigned int mv;
++
++ adc = retu_adc_average(bm, RETU_ADC_CHGVOLT, 5);
++ if (adc < 0)
++ return adc;
++ //TODO convert to mV
++ mv = adc;
++
++ return mv;
++}
++
++/* Measure backup battery voltage. Returns the value in mV (or negative value on error). */
++static int n810bm_measure_backup_batt_voltage(struct n810bm *bm)
++{
++ int adc;
++ unsigned int mv;
++
++ adc = retu_adc_average(bm, RETU_ADC_BKUPVOLT, 3);
++ if (adc < 0)
++ return adc;
++ //TODO convert to mV
++ mv = adc;
++
++ return mv;
++}
++
++/* Measure the battery temperature. Returns the value in K (or negative value on error). */
++static int n810bm_measure_batt_temp(struct n810bm *bm)
++{
++ int adc;
++ unsigned int k;
++
++ adc = retu_adc_average(bm, RETU_ADC_BATTEMP, 3);
++ if (adc < 0)
++ return adc;
++ //TODO convert to K
++ k = adc;
++
++ return k;
++}
++
+/* Read the battery capacity via BSI pin. */
+static enum n810bm_capacity n810bm_read_batt_capacity(struct n810bm *bm)
+{
+ return percent;
+}
+
-+static void n810bm_check_timer(unsigned long data)
++static void n810bm_start_charge(struct n810bm *bm)
+{
-+ struct n810bm *bm = (struct n810bm *)data;
-+ unsigned long flags;
++ int err;
++
++ WARN_ON(!bm->battery_present);
++ WARN_ON(!bm->charger_present);
++
++ /* Set PWM to zero */
++ bm->active_current_pwm = 0;
++ tahvo_write(bm, TAHVO_REG_CHGCURR, bm->active_current_pwm);
++
++ /* Charge global enable */
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_EN |
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ TAHVO_REG_CHGCTL_EN);
++
++ WARN_ON((int)bm->capacity <= 0);
++ bm->charger.capacity = bm->capacity;
++ err = lipocharge_start(&bm->charger);
++ WARN_ON(err);
++
++ /* Initialize current measurement circuitry */
++ n810bm_enable_current_measure(bm);
++ n810bm_set_current_measure_timer(bm, 250);
++
++ dev_info(&bm->pdev->dev, "Charging battery");
++ n810bm_notify_charger_pwm(bm);
++ n810bm_notify_battery_charging(bm);
++}
++
++static void n810bm_stop_charge(struct n810bm *bm)
++{
++ if (lipocharge_is_charging(&bm->charger)) {
++ n810bm_set_current_measure_timer(bm, 0);
++ n810bm_disable_current_measure(bm);
++ }
++ lipocharge_stop(&bm->charger);
++
++ /* Set PWM to zero */
++ bm->active_current_pwm = 0;
++ tahvo_write(bm, TAHVO_REG_CHGCURR, bm->active_current_pwm);
++
++ /* Charge global disable */
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_EN |
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ 0);
++
++ dev_info(&bm->pdev->dev, "Not charging battery");
++ n810bm_notify_charger_pwm(bm);
++ n810bm_notify_battery_charging(bm);
++}
++
++/* Periodic check */
++static void n810bm_periodic_check_work(struct work_struct *work)
++{
++ struct n810bm *bm = container_of(to_delayed_work(work),
++ struct n810bm, periodic_check_work);
++ u16 status;
++ bool battery_was_present, charger_was_present;
+ int mv;
+
-+ spin_lock_irqsave(&bm->lock, flags);
++ mutex_lock(&bm->mutex);
++
++ 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 disable charging
++ }
++ }
+
-+ 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");
++ 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");
++ }
+
-+ mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL));
-+ spin_unlock_irqrestore(&bm->lock, flags);
++ if ((bm->battery_present && !bm->charger_present) ||
++ !n810bm_known_battery_present(bm)){
++ /* We're draining the battery */
++ mv = n810bm_measure_batt_voltage(bm);
++ if (mv < 0) {
++ n810bm_emergency(bm,
++ "check: Failed to measure voltage");
++ }
++ if (mv < N810BM_MIN_VOLTAGE_THRES) {
++ n810bm_emergency(bm,
++ "check: Minimum voltage threshold reached");
++ }
++ }
+
-+ return;
++ if (bm->charger_present && n810bm_known_battery_present(bm)) {
++ /* Known battery and charger are connected */
++ if (bm->charger_enabled) {
++ /* Charger is enabled */
++ if (!lipocharge_is_charging(&bm->charger)) {
++ //TODO start charging, if battery is below some threshold
++ n810bm_start_charge(bm);
++ }
++ }
++ }
++
++ if (lipocharge_is_charging(&bm->charger) && !bm->charger_present) {
++ /* Charger was unplugged. */
++ n810bm_stop_charge(bm);
++ }
++
++ mutex_unlock(&bm->mutex);
++ schedule_delayed_work(&bm->periodic_check_work,
++ round_jiffies_relative(N810BM_CHECK_INTERVAL));
+}
+
+static void n810bm_adc_irq_handler(unsigned long data)
+
+ retu_ack_irq(RETU_INT_ADCS);
+ //TODO
-+printk("n810bm: ADC timer triggered\n");
++dev_info(&bm->pdev->dev, "ADC interrupt triggered\n");
+}
+
-+static ssize_t n810bm_attr_charge_show(struct device *dev,
-+ struct device_attribute *attr,
-+ char *buf)
++static void n810bm_tahvo_current_measure_work(struct work_struct *work)
+{
-+ struct platform_device *pdev = to_platform_device(dev);
-+ struct n810bm *bm = platform_get_drvdata(pdev);
-+ int err = -ENODEV;
-+ ssize_t count = 0;
++ struct n810bm *bm = container_of(work, struct n810bm, currmeas_irq_work);
++ int res, ma, mv, temp;
++
++ mutex_lock(&bm->mutex);
++ if (!lipocharge_is_charging(&bm->charger))
++ goto out_unlock;
++
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ TAHVO_REG_CHGCTL_PWMOVR);
++ ma = n810bm_measure_batt_current(bm);
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO);
++ msleep(10);
++ mv = n810bm_measure_batt_voltage(bm);
++ tahvo_maskset(bm, TAHVO_REG_CHGCTL,
++ TAHVO_REG_CHGCTL_PWMOVR |
++ TAHVO_REG_CHGCTL_PWMOVRZERO,
++ 0);
++ temp = n810bm_measure_batt_temp(bm);
++ if (WARN_ON(mv < 0))
++ goto out_unlock;
++ if (WARN_ON(temp < 0))
++ goto out_unlock;
++
++ if (bm->verbose_charge_log) {
++ dev_info(&bm->pdev->dev,
++ "Battery charge state: %d mV, %d mA (%s)",
++ mv, ma,
++ (ma <= 0) ? "discharging" : "charging");
++ }
++ res = lipocharge_update_state(&bm->charger, mv, ma, temp);
++ if (res) {
++ if (res > 0)
++ dev_info(&bm->pdev->dev, "Battery fully charged");
++ n810bm_stop_charge(bm);
++ }
++out_unlock:
++ mutex_unlock(&bm->mutex);
++}
++
++static void n810bm_tahvo_current_measure_irq_handler(unsigned long data)
++{
++ struct n810bm *bm = (struct n810bm *)data;
++
++ tahvo_ack_irq(TAHVO_INT_BATCURR);
++ schedule_work(&bm->currmeas_irq_work);
++}
++
++#define DEFINE_ATTR_NOTIFY(attr_name) \
++ void n810bm_notify_##attr_name(struct n810bm *bm) \
++ { \
++ set_bit(N810BM_NOTIFY_##attr_name, &bm->notify_flags); \
++ wmb(); \
++ schedule_work(&bm->notify_work); \
++ }
++
++#define DEFINE_SHOW_INT_FUNC(name, member) \
++ static ssize_t n810bm_attr_##name##_show(struct device *dev, \
++ struct device_attribute *attr, \
++ char *buf) \
++ { \
++ struct n810bm *bm = device_to_n810bm(dev); \
++ ssize_t count; \
++ \
++ mutex_lock(&bm->mutex); \
++ count = snprintf(buf, PAGE_SIZE, "%d\n", (int)(bm->member)); \
++ mutex_unlock(&bm->mutex); \
++ \
++ return count; \
++ }
++
++#define DEFINE_STORE_INT_FUNC(name, member) \
++ static ssize_t n810bm_attr_##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; \
++ \
++ mutex_lock(&bm->mutex); \
++ err = strict_strtol(buf, 0, &val); \
++ if (!err) \
++ bm->member = (typeof(bm->member))val; \
++ mutex_unlock(&bm->mutex); \
++ \
++ return err ? err : count; \
++ }
++
++#define DEFINE_ATTR_SHOW_INT(name, member) \
++ DEFINE_SHOW_INT_FUNC(name, member) \
++ static DEVICE_ATTR(name, S_IRUGO, \
++ n810bm_attr_##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, S_IRUGO | S_IWUSR, \
++ n810bm_attr_##name##_show, \
++ n810bm_attr_##name##_store);
++
++DEFINE_ATTR_SHOW_INT(battery_present, battery_present);
++DEFINE_ATTR_SHOW_INT(charger_present, charger_present);
++DEFINE_ATTR_SHOW_INT(charger_pwm, active_current_pwm);
++static DEFINE_ATTR_NOTIFY(charger_pwm);
++DEFINE_ATTR_SHOW_STORE_INT(charger_enable, charger_enabled);
++DEFINE_ATTR_SHOW_STORE_INT(charger_verbose, verbose_charge_log);
++
++static ssize_t n810bm_attr_battery_charging(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct n810bm *bm = device_to_n810bm(dev);
++ ssize_t count;
++
++ mutex_lock(&bm->mutex);
++ count = snprintf(buf, PAGE_SIZE, "%d\n",
++ (int)lipocharge_is_charging(&bm->charger));
++ mutex_unlock(&bm->mutex);
++
++ return count;
++}
++static DEVICE_ATTR(battery_charging, S_IRUGO,
++ n810bm_attr_battery_charging, NULL);
++static DEFINE_ATTR_NOTIFY(battery_charging);
++
++static ssize_t n810bm_attr_battery_level_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct n810bm *bm = device_to_n810bm(dev);
++ ssize_t count = -ENODEV;
+ int millivolt;
+
-+ spin_lock_irq(&bm->lock);
-+ millivolt = n810bm_measure_batt_voltage(bm);
++ mutex_lock(&bm->mutex);
++ if (!bm->battery_present || lipocharge_is_charging(&bm->charger))
++ millivolt = 0;
++ else
++ 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);
++ mutex_unlock(&bm->mutex);
+
-+ return err ? err : count;
++ return count;
+}
-+static DEVICE_ATTR(batt_charge, 0444, n810bm_attr_charge_show, NULL);
++static DEVICE_ATTR(battery_level, S_IRUGO,
++ n810bm_attr_battery_level_show, NULL);
+
-+static ssize_t n810bm_attr_capacity_show(struct device *dev,
-+ struct device_attribute *attr,
-+ char *buf)
++static ssize_t n810bm_attr_battery_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);
++ struct n810bm *bm = device_to_n810bm(dev);
+ ssize_t count;
++ int capacity = 0;
+
-+ spin_lock_irq(&bm->lock);
-+ count = snprintf(buf, PAGE_SIZE, "%u\n",
-+ (unsigned int)bm->capacity);
-+ spin_unlock_irq(&bm->lock);
++ mutex_lock(&bm->mutex);
++ if (n810bm_known_battery_present(bm))
++ capacity = (int)bm->capacity;
++ count = snprintf(buf, PAGE_SIZE, "%d\n", capacity);
++ mutex_unlock(&bm->mutex);
+
+ return count;
+}
-+static DEVICE_ATTR(batt_capacity, 0444, n810bm_attr_capacity_show, NULL);
++static DEVICE_ATTR(battery_capacity, S_IRUGO,
++ n810bm_attr_battery_capacity_show, NULL);
++
++static ssize_t n810bm_attr_battery_temp_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct n810bm *bm = device_to_n810bm(dev);
++ ssize_t count = -ENODEV;
++ int k;
++
++ mutex_lock(&bm->mutex);
++ k = n810bm_measure_batt_temp(bm);
++ if (k >= 0)
++ count = snprintf(buf, PAGE_SIZE, "%d\n", k);
++ mutex_unlock(&bm->mutex);
++
++ return count;
++}
++static DEVICE_ATTR(battery_temp, S_IRUGO,
++ n810bm_attr_battery_temp_show, NULL);
++
++static ssize_t n810bm_attr_charger_voltage_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct n810bm *bm = device_to_n810bm(dev);
++ ssize_t count = -ENODEV;
++ int mv = 0;
++
++ mutex_lock(&bm->mutex);
++ if (bm->charger_present)
++ mv = n810bm_measure_charger_voltage(bm);
++ if (mv >= 0)
++ count = snprintf(buf, PAGE_SIZE, "%d\n", mv);
++ mutex_unlock(&bm->mutex);
++
++ return count;
++}
++static DEVICE_ATTR(charger_voltage, S_IRUGO,
++ n810bm_attr_charger_voltage_show, NULL);
++
++static ssize_t n810bm_attr_backup_battery_voltage_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct n810bm *bm = device_to_n810bm(dev);
++ ssize_t count = -ENODEV;
++ int mv;
++
++ mutex_lock(&bm->mutex);
++ mv = n810bm_measure_backup_batt_voltage(bm);
++ if (mv >= 0)
++ count = snprintf(buf, PAGE_SIZE, "%d\n", mv);
++ mutex_unlock(&bm->mutex);
++
++ return count;
++}
++static DEVICE_ATTR(backup_battery_voltage, S_IRUGO,
++ n810bm_attr_backup_battery_voltage_show, NULL);
++
++static ssize_t n810bm_attr_battery_current_show(struct device *dev,
++ struct device_attribute *attr,
++ char *buf)
++{
++ struct n810bm *bm = device_to_n810bm(dev);
++ ssize_t count = -ENODEV;
++ int ma = 0;
++
++ mutex_lock(&bm->mutex);
++ if (bm->battery_present)
++ ma = n810bm_measure_batt_current_async(bm);
++ count = snprintf(buf, PAGE_SIZE, "%d\n", ma);
++ mutex_unlock(&bm->mutex);
++
++ return count;
++}
++static DEVICE_ATTR(battery_current, S_IRUGO,
++ n810bm_attr_battery_current_show, NULL);
++
++static const struct device_attribute *n810bm_attrs[] = {
++ &dev_attr_battery_present,
++ &dev_attr_battery_level,
++ &dev_attr_battery_charging,
++ &dev_attr_battery_current,
++ &dev_attr_battery_capacity,
++ &dev_attr_battery_temp,
++ &dev_attr_backup_battery_voltage,
++ &dev_attr_charger_present,
++ &dev_attr_charger_verbose,
++ &dev_attr_charger_voltage,
++ &dev_attr_charger_enable,
++ &dev_attr_charger_pwm,
++};
++
++static void n810bm_notify_work(struct work_struct *work)
++{
++ struct n810bm *bm = container_of(work, struct n810bm, notify_work);
++ unsigned long notify_flags;
++
++ notify_flags = xchg(&bm->notify_flags, 0);
++ mb();
++
++#define do_notify(attr_name) \
++ do { \
++ if (notify_flags & (1 << N810BM_NOTIFY_##attr_name)) { \
++ sysfs_notify(&bm->pdev->dev.kobj, NULL, \
++ dev_attr_##attr_name.attr.name); \
++ } \
++ } while (0)
++
++ do_notify(battery_charging);
++ do_notify(charger_pwm);
++}
++
++static int n810bm_charger_set_current_pwm(struct lipocharge *c,
++ unsigned int duty_cycle)
++{
++ struct n810bm *bm = container_of(c, struct n810bm, charger);
++ int err = -EINVAL;
++
++ WARN_ON(!mutex_is_locked(&bm->mutex));
++ if (WARN_ON(duty_cycle > 0xFF))
++ goto out;
++ if (WARN_ON(!bm->charger_enabled))
++ goto out;
++ if (WARN_ON(!bm->battery_present || !bm->charger_present))
++ goto out;
++
++ if (duty_cycle != bm->active_current_pwm) {
++ bm->active_current_pwm = duty_cycle;
++ tahvo_write(bm, TAHVO_REG_CHGCURR, duty_cycle);
++ n810bm_notify_charger_pwm(bm);
++ }
++
++ err = 0;
++out:
++
++ return err;
++}
++
++static void n810bm_charger_emergency(struct lipocharge *c)
++{
++ struct n810bm *bm = container_of(c, struct n810bm, charger);
++
++ n810bm_emergency(bm, "Battery charger fault");
++}
+
+static void n810bm_hw_exit(struct n810bm *bm)
+{
++ n810bm_stop_charge(bm);
+ retu_write(bm, RETU_REG_ADCSCR, 0);
+}
+
+static int n810bm_hw_init(struct n810bm *bm)
+{
-+ retu_write(bm, RETU_REG_ADCSCR, 0);
++ int err;
++
++ err = n810bm_check_adc_sanity(bm);
++ if (err)
++ return err;
++
++ n810bm_stop_charge(bm);
++
++ return 0;
++}
++
++static void n810bm_cancel_and_flush_work(struct n810bm *bm)
++{
++ cancel_delayed_work_sync(&bm->periodic_check_work);
++ cancel_work_sync(&bm->notify_work);
++ cancel_work_sync(&bm->currmeas_irq_work);
++ flush_scheduled_work();
++}
++
++static int n810bm_device_init(struct n810bm *bm)
++{
++ int attr_index;
++ int err;
++
++ bm->charger.rate = LIPORATE_p6C;
++ bm->charger.top_voltage = 4100;
++ bm->charger.duty_cycle_max = 0xFF;
++ bm->charger.set_current_pwm = n810bm_charger_set_current_pwm;
++ bm->charger.emergency = n810bm_charger_emergency;
++ lipocharge_init(&bm->charger, &bm->pdev->dev);
+
-+ bm->capacity = n810bm_read_batt_capacity(bm);
-+ if (bm->capacity == N810BM_CAP_UNKNOWN) {
-+ dev_err(&bm->pdev->dev, "Unknown battery detected");
-+ return -ENODEV;
++ err = n810bm_hw_init(bm);
++ if (err)
++ 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;
++ tahvo_disable_irq(TAHVO_INT_BATCURR);
++
++ schedule_delayed_work(&bm->periodic_check_work,
++ round_jiffies_relative(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:
++ n810bm_cancel_and_flush_work(bm);
++
++ 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);
++ for (i = 0; i < ARRAY_SIZE(n810bm_attrs); i++)
++ device_remove_file(&bm->pdev->dev, n810bm_attrs[i]);
++
++ n810bm_cancel_and_flush_work(bm);
++
++ n810bm_hw_exit(bm);
++
++ 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 err_release;
++ }
++ 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 err_release;
++ }
++
++ err = n810bm_parse_pmm_block(bm, fw);
++ if (err)
++ goto err_release;
++ release_firmware(fw);
++
++ err = n810bm_device_init(bm);
++ if (err) {
++ dev_err(&bm->pdev->dev,
++ "Failed to initialized battery management (%d)", err);
++ goto error;
++ }
++
++ return;
++err_release:
++ release_firmware(fw);
++error:
++ return;
+}
+
+static int __devinit n810bm_probe(struct platform_device *pdev)
+ 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)
++ mutex_init(&bm->mutex);
++ INIT_DELAYED_WORK(&bm->periodic_check_work, n810bm_periodic_check_work);
++ INIT_WORK(&bm->notify_work, n810bm_notify_work);
++ INIT_WORK(&bm->currmeas_irq_work, n810bm_tahvo_current_measure_work);
++
++ 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 = 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;
+}
+
+{
+ 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);
++ n810bm_device_exit(bm);
+
+ kfree(bm);
+ platform_set_drvdata(pdev, NULL);
+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-rc1/drivers/cbus/retu.c
+Index: linux-2.6.37.1/drivers/cbus/retu.c
===================================================================
---- linux-2.6.37-rc1.orig/drivers/cbus/retu.c 2010-11-06 17:28:21.812000054 +0100
-+++ linux-2.6.37-rc1/drivers/cbus/retu.c 2010-11-06 17:28:21.872000001 +0100
+--- linux-2.6.37.1.orig/drivers/cbus/retu.c 2011-02-19 20:26:01.251340770 +0100
++++ linux-2.6.37.1/drivers/cbus/retu.c 2011-02-19 20:26:01.529318528 +0100
@@ -85,10 +85,10 @@
*
* This function writes a value to the specified register
}
void retu_set_clear_reg_bits(int reg, u16 set, u16 clear)
-Index: linux-2.6.37-rc1/drivers/cbus/retu.h
+@@ -459,6 +459,7 @@
+ EXPORT_SYMBOL(retu_ack_irq);
+ EXPORT_SYMBOL(retu_read_reg);
+ EXPORT_SYMBOL(retu_write_reg);
++EXPORT_SYMBOL(retu_read_adc);
+
+ subsys_initcall(retu_init);
+ module_exit(retu_exit);
+Index: linux-2.6.37.1/drivers/cbus/retu.h
===================================================================
---- linux-2.6.37-rc1.orig/drivers/cbus/retu.h 2010-11-06 17:28:21.812000054 +0100
-+++ linux-2.6.37-rc1/drivers/cbus/retu.h 2010-11-06 17:28:21.872000001 +0100
-@@ -39,6 +39,7 @@
- #define RETU_REG_CC2 0x0e /* Common control register 2 */
+--- linux-2.6.37.1.orig/drivers/cbus/retu.h 2011-02-19 20:26:01.252340690 +0100
++++ linux-2.6.37.1/drivers/cbus/retu.h 2011-02-19 20:26:01.530318448 +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 */
-@@ -58,7 +59,7 @@
+ #define RETU_REG_MAX 0x1f
+@@ -57,8 +59,25 @@
+
#define MAX_RETU_IRQ_HANDLERS 16
++/* ADC channels */
++#define RETU_ADC_GND 0x00 /* Ground */
++#define RETU_ADC_BSI 0x01 /* Battery Size Indicator */
++#define RETU_ADC_BATTEMP 0x02 /* Battery temperature */
++#define RETU_ADC_CHGVOLT 0x03 /* Charger voltage */
++#define RETU_ADC_HEADSET 0x04 /* Headset detection */
++#define RETU_ADC_HOOKDET 0x05 /* Hook detection */
++#define RETU_ADC_RFGP 0x06 /* RF GP */
++#define RETU_ADC_WBTX 0x07 /* Wideband Tx detection */
++#define RETU_ADC_BATTVOLT 0x08 /* Battery voltage measurement */
++#define RETU_ADC_GND2 0x09 /* Ground */
++#define RETU_ADC_LIGHTSENS 0x0A /* Light sensor */
++#define RETU_ADC_LIGHTTEMP 0x0B /* Light sensor temperature */
++#define RETU_ADC_BKUPVOLT 0x0C /* Backup battery voltage */
++#define RETU_ADC_TEMP 0x0D /* RETU temperature */
++
++
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
+Index: linux-2.6.37.1/arch/arm/mach-omap2/board-n8x0.c
===================================================================
---- linux-2.6.37-rc1.orig/arch/arm/mach-omap2/board-n8x0.c 2010-11-06 17:28:21.796000362 +0100
-+++ linux-2.6.37-rc1/arch/arm/mach-omap2/board-n8x0.c 2010-11-06 17:28:21.873000001 +0100
-@@ -899,6 +899,17 @@
+--- linux-2.6.37.1.orig/arch/arm/mach-omap2/board-n8x0.c 2011-02-19 20:26:01.201344770 +0100
++++ linux-2.6.37.1/arch/arm/mach-omap2/board-n8x0.c 2011-02-19 20:26:01.531318368 +0100
+@@ -907,6 +907,17 @@
ARRAY_SIZE(n8x0_gpio_switches));
}
static void __init n8x0_init_machine(void)
{
omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAC);
-@@ -925,6 +936,8 @@
+@@ -933,6 +944,8 @@
n8x0_onenand_init();
n8x0_mmc_init();
n8x0_usb_init();
}
MACHINE_START(NOKIA_N800, "Nokia N800")
-Index: linux-2.6.37-rc1/drivers/cbus/lipocharge.c
+Index: linux-2.6.37.1/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-06 17:28:21.873000001 +0100
-@@ -0,0 +1,63 @@
++++ linux-2.6.37.1/drivers/cbus/lipocharge.c 2011-02-19 20:26:01.531318368 +0100
+@@ -0,0 +1,183 @@
+/*
+ * Generic LIPO battery charger
+ *
-+ * Copyright (c) 2010 Michael Buesch <mb@bu3sch.de>
++ * Copyright (c) 2010-2011 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
+ * GNU General Public License for more details.
+ */
+
++#define DEBUG
++
+#include "lipocharge.h"
+
+#include <linux/slab.h>
+
+
-+static void lipocharge_timer(unsigned long data)
-+{
-+ struct lipocharge *c = (struct lipocharge *)data;
++/* Hysteresis constants */
++#define CURRENT_HYST 30 /* mA */
++#define VOLTAGE_HYST 10 /* mV */
+
-+ spin_lock(&c->lock);
-+ //TODO
-+ spin_unlock(&c->lock);
-+}
++/* Threshold constants */
++#define FINISH_CURRENT_PERCENT 3
+
-+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);
++/* Returns the requested first-stage charge current in mA */
++static inline unsigned int get_stage1_charge_current(struct lipocharge *c)
++{
++ /* current = (capacity * C) */
++ return c->capacity * c->rate / 1000;
++}
+
-+ return c;
++void lipocharge_init(struct lipocharge *c, struct device *dev)
++{
++ c->dev = dev;
++ c->state = LIPO_IDLE;
+}
+
-+void lipocharge_free(struct lipocharge *c)
++void lipocharge_exit(struct lipocharge *c)
+{
-+ kfree(c);
++ c->state = LIPO_IDLE;
+}
+
+int lipocharge_start(struct lipocharge *c)
+{
-+ if (!c->set_current || !c->get_voltage ||
-+ !c->finished || !c->emergency)
++ int err;
++
++ if (c->state != LIPO_IDLE)
++ return -EBUSY;
++ if (!c->set_current_pwm || !c->emergency)
+ return -EINVAL;
+ if (!c->top_voltage || c->top_voltage > 4200)
+ return -EINVAL;
-+ //TODO
++
++ c->active_duty_cycle = 0;
++ err = c->set_current_pwm(c, c->active_duty_cycle);
++ if (err)
++ return err;
++ c->state = LIPO_FIRST_STAGE;
++
++ return 0;
+}
+
+void lipocharge_stop(struct lipocharge *c)
+{
-+ del_timer_sync(&c->timer);
-+ //TODO
++ if (c->state == LIPO_IDLE)
++ return;
++ c->state = LIPO_IDLE;
+}
-Index: linux-2.6.37-rc1/drivers/cbus/lipocharge.h
++
++static int lipocharge_increase_current(struct lipocharge *c,
++ unsigned int inc_permille)
++{
++ int old_pwm, new_pwm;
++
++ if (c->active_duty_cycle >= c->duty_cycle_max)
++ return 0;
++
++ old_pwm = c->active_duty_cycle;
++ new_pwm = old_pwm + (c->duty_cycle_max * inc_permille / 1000);
++ new_pwm = min(new_pwm, (int)c->duty_cycle_max);
++ c->active_duty_cycle = new_pwm;
++
++ dev_dbg(c->dev, "lipo: Increasing duty_cycle by "
++ "%u permille (0x%02X -> 0x%02X)",
++ inc_permille, old_pwm, new_pwm);
++
++ return c->set_current_pwm(c, c->active_duty_cycle);
++}
++
++static int lipocharge_decrease_current(struct lipocharge *c,
++ unsigned int dec_permille)
++{
++ int old_pwm, new_pwm;
++
++ if (c->active_duty_cycle <= 0)
++ return 0;
++
++ old_pwm = c->active_duty_cycle;
++ new_pwm = old_pwm - (c->duty_cycle_max * dec_permille / 1000);
++ new_pwm = max(0, new_pwm);
++ c->active_duty_cycle = new_pwm;
++
++ dev_dbg(c->dev, "lipo: Decreasing duty_cycle by "
++ "%u permille (0x%02X -> 0x%02X)",
++ dec_permille, old_pwm, new_pwm);
++
++ return c->set_current_pwm(c, c->active_duty_cycle);
++}
++
++/** lipocharge_update_state - Update the charge state
++ * @c: The context.
++ * @voltage_mV: The measured battery voltage.
++ * @current_mA: The measured charge current.
++ * negative -> drain.
++ * positive -> charge.
++ * @temp_K: Battery temperature in K.
++ *
++ * Returns 0 on success, -1 on error.
++ * Returns 1, if the charging process is finished.
++ */
++int lipocharge_update_state(struct lipocharge *c,
++ unsigned int voltage_mV,
++ int current_mA,
++ unsigned int temp_K)
++{
++ int requested_current, current_diff;
++ int err;
++ unsigned int permille;
++
++ //TODO temp
++
++restart:
++ switch (c->state) {
++ case LIPO_IDLE:
++ dev_err(c->dev, "%s: called while idle", __func__);
++ return -EINVAL;
++ case LIPO_FIRST_STAGE: /* Constant current */
++//printk("GOT %u %d %u\n", voltage_mV, current_mA, temp_K);
++ if (voltage_mV >= c->top_voltage) {
++ /* Float voltage reached.
++ * Switch charger mode to "constant current" */
++ c->state = LIPO_SECOND_STAGE;
++ dev_dbg(c->dev, "Switched to second charging stage.");
++ goto restart;
++ }
++ /* Float voltage not reached, yet.
++ * Try to get the requested constant current. */
++ requested_current = get_stage1_charge_current(c);
++ if (current_mA < 0)
++ current_mA = 0;
++ current_diff = requested_current - current_mA;
++ if (abs(requested_current - current_mA) > CURRENT_HYST) {
++ if (current_diff > 0) {
++ /* Increase current */
++ permille = current_diff * 1000 / requested_current;
++ permille /= 2;
++ err = lipocharge_increase_current(c, permille);
++ if (err)
++ return err;
++ } else {
++ /* Decrease current */
++ permille = (-current_diff) * 1000 / requested_current;
++ permille /= 2;
++ err = lipocharge_decrease_current(c, permille);
++ if (err)
++ return err;
++ }
++ }
++ break;
++ case LIPO_SECOND_STAGE: /* Constant voltage */
++ //TODO
++ break;
++ }
++
++ return 0;
++}
+Index: linux-2.6.37.1/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-06 17:28:21.873000001 +0100
-@@ -0,0 +1,50 @@
++++ linux-2.6.37.1/drivers/cbus/lipocharge.h 2011-02-19 20:26:01.531318368 +0100
+@@ -0,0 +1,60 @@
+#ifndef LIPOCHARGE_H_
+#define LIPOCHARGE_H_
+
-+#include <linux/timer.h>
-+#include <linux/spinlock.h>
++#include <linux/types.h>
++#include <linux/device.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(a,b) (((a) * 1000) + ((b) * 100))
++#define LIPORATE_p6C LIPORATE(0,6) /* 0.6C */
++
++enum lipocharge_state {
++ LIPO_IDLE, /* Not charging */
++ LIPO_FIRST_STAGE, /* Charging: constant current */
++ LIPO_SECOND_STAGE, /* Charging: constant voltage */
++};
+
+/** struct lipocharge - A generic LIPO charger
+ *
+ * @capacity: Battery capacity in mAh.
+ * @rate: Charge rate.
+ * @top_voltage: Fully charged voltage, in mV.
++ * @duty_cycle_max: Max value for duty_cycle.
+ *
-+ * @set_current: Set the charge current, in mA.
-+ * @get_voltage: Get the battery voltage, in mV.
-+ *
++ * @set_charge_current: Set the charge current PWM duty cycle.
+ * @emergency: Something went wrong. Force shutdown.
-+ *
-+ * @priv: opaque pointer.
+ */
-+struct lipocharge
-+{
++struct lipocharge {
+ unsigned int capacity;
+ unsigned int rate;
+ unsigned int top_voltage;
++ unsigned int duty_cycle_max;
+
-+ int (*set_current)(struct lipocharge *c, unsigned int ma);
-+ int (*get_voltage)(struct lipocharge *c, unsigned int *mv);
-+
-+ void (*finished)(struct lipocharge *c);
++ int (*set_current_pwm)(struct lipocharge *c, unsigned int duty_cycle);
+ void (*emergency)(struct lipocharge *c);
+
-+ void *priv;
-+
+ /* internal */
-+ spinlock_t lock;
-+ struct timer_list timer;
++ struct device *dev;
++ enum lipocharge_state state;
++ unsigned int active_duty_cycle;
++
++ //TODO implement timer to cut power after maximum charge time.
+};
+
-+struct lipocharge * lipocharge_alloc(gfp_t gfp);
-+void lipocharge_free(struct lipocharge *c);
++void lipocharge_init(struct lipocharge *c, struct device *dev);
++void lipocharge_exit(struct lipocharge *c);
+
+int lipocharge_start(struct lipocharge *c);
+void lipocharge_stop(struct lipocharge *c);
+
++int lipocharge_update_state(struct lipocharge *c,
++ unsigned int voltage_mV,
++ int current_mA,
++ unsigned int temp_K);
++
++static inline bool lipocharge_is_charging(struct lipocharge *c)
++{
++ return (c->state != LIPO_IDLE);
++}
++
+#endif /* LIPOCHARGE_H_ */
-Index: linux-2.6.37-rc1/drivers/cbus/tahvo.h
+Index: linux-2.6.37.1/drivers/cbus/tahvo.h
===================================================================
---- linux-2.6.37-rc1.orig/drivers/cbus/tahvo.h 2010-11-06 17:28:21.813000041 +0100
-+++ linux-2.6.37-rc1/drivers/cbus/tahvo.h 2010-11-06 17:28:21.873000001 +0100
-@@ -30,8 +30,14 @@
+--- linux-2.6.37.1.orig/drivers/cbus/tahvo.h 2011-02-19 20:26:01.256340370 +0100
++++ linux-2.6.37.1/drivers/cbus/tahvo.h 2011-02-19 20:26:01.532318288 +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 0%/100% duty cycle. */
++#define TAHVO_REG_CHGCTL_PWMOVRZERO 0x0008 /* If set, PWM override is 0% (If unset -> 100%) */
++#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.1/drivers/cbus/tahvo.c
+===================================================================
+--- linux-2.6.37.1.orig/drivers/cbus/tahvo.c 2011-02-19 20:26:01.256340370 +0100
++++ linux-2.6.37.1/drivers/cbus/tahvo.c 2011-02-19 20:26:01.532318288 +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);
+ }
+
+ /**
+Index: linux-2.6.37.1/drivers/cbus/cbus.c
+===================================================================
+--- linux-2.6.37.1.orig/drivers/cbus/cbus.c 2011-02-19 20:26:01.249340930 +0100
++++ linux-2.6.37.1/drivers/cbus/cbus.c 2011-02-19 20:26:01.533318208 +0100
+@@ -31,6 +31,7 @@
+ #include <linux/gpio.h>
+ #include <linux/platform_device.h>
+ #include <linux/slab.h>
++#include <linux/reboot.h>
+
+ #include <asm/io.h>
+ #include <asm/mach-types.h>
+@@ -301,6 +302,13 @@
+ }
+ module_exit(cbus_bus_exit);
+
++void cbus_emergency(void)
++{
++ machine_power_off();
++ panic("cbus: Failed to halt machine in emergency state\n");
++}
++EXPORT_SYMBOL(cbus_emergency);
++
+ MODULE_DESCRIPTION("CBUS serial protocol");
+ MODULE_LICENSE("GPL");
+ MODULE_AUTHOR("Juha Yrjölä");
+Index: linux-2.6.37.1/drivers/cbus/cbus.h
+===================================================================
+--- linux-2.6.37.1.orig/drivers/cbus/cbus.h 2011-02-19 20:26:01.250340850 +0100
++++ linux-2.6.37.1/drivers/cbus/cbus.h 2011-02-19 20:26:01.533318208 +0100
+@@ -33,4 +33,6 @@
+ extern int cbus_read_reg(struct cbus_host *host, int dev, int reg);
+ extern int cbus_write_reg(struct cbus_host *host, int dev, int reg, u16 val);
+
++NORET_TYPE void cbus_emergency(void) ATTRIB_NORET;
++
+ #endif /* __DRIVERS_CBUS_CBUS_H */
projects / openwrt.git / blobdiff