ExternalVendorCode/openwrt
1
0
Fork 0
mirror of https://github.com/openwrt/openwrt.git synced 2024-12-23 07:22:33 +00:00
Code Issues Actions 6 Packages Projects Releases Wiki Activity
7178dc62a4
openwrt/target/linux/omap24xx/patches-2.6.36/900-n810-battery-management.patch
Michael Büsch 7178dc62a4 omap24xx: Improve n810 battery management 
SVN-Revision: 23282
2010-10-07 09:58:37 +00:00

640 lines
17 KiB
Diff
Raw Blame History

---
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(-)
--- linux-2.6.36-rc7.orig/drivers/cbus/Kconfig
+++ linux-2.6.36-rc7/drivers/cbus/Kconfig
@@ -94,4 +94,16 @@ config CBUS_RETU_HEADSET
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
--- linux-2.6.36-rc7.orig/drivers/cbus/Makefile
+++ linux-2.6.36-rc7/drivers/cbus/Makefile
@@ -12,3 +12,6 @@ obj-$(CONFIG_CBUS_RETU_WDT) += retu-wdt.
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
--- /dev/null
+++ linux-2.6.36-rc7/drivers/cbus/n810bm_main.c
@@ -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");
--- linux-2.6.36-rc7.orig/drivers/cbus/retu.c
+++ linux-2.6.36-rc7/drivers/cbus/retu.c
@@ -85,10 +85,10 @@ int retu_read_reg(int reg)
*
* 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)
--- linux-2.6.36-rc7.orig/drivers/cbus/retu.h
+++ linux-2.6.36-rc7/drivers/cbus/retu.h
@@ -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);
--- linux-2.6.36-rc7.orig/arch/arm/mach-omap2/board-n8x0.c
+++ linux-2.6.36-rc7/arch/arm/mach-omap2/board-n8x0.c
@@ -906,6 +906,17 @@ static void __init n8x0_gpio_switches_in
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);
@@ -933,6 +944,8 @@ static void __init n8x0_init_machine(voi
n8x0_onenand_init();
n8x0_mmc_init();
n8x0_usb_init();
+
+ n810_bm_init();
}
MACHINE_START(NOKIA_N800, "Nokia N800")
--- /dev/null
+++ linux-2.6.36-rc7/drivers/cbus/lipocharge.c
@@ -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
+}
--- /dev/null
+++ linux-2.6.36-rc7/drivers/cbus/lipocharge.h
@@ -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_ */
--- linux-2.6.36-rc7.orig/drivers/cbus/tahvo.h
+++ linux-2.6.36-rc7/drivers/cbus/tahvo.h
@@ -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 */
Reference in New Issue View Git Blame Copy Permalink