target/linux/omap24xx/patches-2.6.35/900-n810-battery-management.patch

   1 ---
   2  arch/arm/mach-omap2/board-n8x0.c |   13 +
   3  drivers/cbus/Kconfig             |   12 +
   4  drivers/cbus/Makefile            |    1
   5  drivers/cbus/n810bm.c            |  396 +++++++++++++++++++++++++++++++++++++++
   6  drivers/cbus/retu.c              |    4
   7  drivers/cbus/retu.h              |    2
   8  6 files changed, 425 insertions(+), 3 deletions(-)
   9
  10 --- linux-2.6.35.3.orig/drivers/cbus/Kconfig
  11 +++ linux-2.6.35.3/drivers/cbus/Kconfig
  12 @@ -94,4 +94,16 @@ config CBUS_RETU_HEADSET
  13           to Retu/Vilma. Detection state and events are exposed through
  14           sysfs.
  15
  16 +config N810BM
  17 +       depends on CBUS_RETU && CBUS_TAHVO
  18 +       tristate "Nokia n810 battery management"
  19 +       ---help---
  20 +         Nokia n810 device battery management.
  21 +
  22 +         WARNING: This driver is based on reverse engineered information.
  23 +         It is possibly dangerous to use this software.
  24 +         Use this software at your own risk!
  25 +
  26 +         If unsure, say N.
  27 +
  28  endmenu
  29 --- linux-2.6.35.3.orig/drivers/cbus/Makefile
  30 +++ linux-2.6.35.3/drivers/cbus/Makefile
  31 @@ -12,3 +12,4 @@ obj-$(CONFIG_CBUS_RETU_WDT)   += retu-wdt.
  32  obj-$(CONFIG_CBUS_TAHVO_USER)  += tahvo-user.o
  33  obj-$(CONFIG_CBUS_RETU_USER)   += retu-user.o
  34  obj-$(CONFIG_CBUS_RETU_HEADSET)        += retu-headset.o
  35 +obj-$(CONFIG_N810BM)           += n810bm.o
  36 --- /dev/null
  37 +++ linux-2.6.35.3/drivers/cbus/n810bm.c
  38 @@ -0,0 +1,396 @@
  39 +/*
  40 + *   Nokia n810 battery management
  41 + *
  42 + *   WARNING: This driver is based on reverse engineered information.
  43 + *            It is possibly dangerous to use this software.
  44 + *            Use this software at your own risk!
  45 + *
  46 + *   Copyright (c) 2010 Michael Buesch <mb@bu3sch.de>
  47 + *
  48 + *   This program is free software; you can redistribute it and/or
  49 + *   modify it under the terms of the GNU General Public License
  50 + *   as published by the Free Software Foundation; either version 2
  51 + *   of the License, or (at your option) any later version.
  52 + *
  53 + *   This program is distributed in the hope that it will be useful,
  54 + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  55 + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  56 + *   GNU General Public License for more details.
  57 + */
  58 +
  59 +#include <linux/module.h>
  60 +#include <linux/device.h>
  61 +#include <linux/platform_device.h>
  62 +#include <linux/slab.h>
  63 +#include <linux/spinlock.h>
  64 +#include <linux/timer.h>
  65 +#include <linux/reboot.h>
  66 +
  67 +#include "retu.h"
  68 +#include "tahvo.h"
  69 +
  70 +
  71 +#define N810BM_CHECK_INTERVAL          (HZ * 5)
  72 +#define N810BM_MIN_VOLTAGE_THRES       3400 /* Absolute minimum voltage threshold */
  73 +/* FIXME: Not sure about the actual value of the low threshold, yet.
  74 + * We must give userspace a chance to detect undervoltage and perform
  75 + * a clean shutdown, before we flip the big switch. */
  76 +
  77 +
  78 +/* Battery related retu ADC channels */
  79 +#define RETU_ADC_BSI           0x01 /* Battery Size Indicator */
  80 +#define RETU_ADC_BATTVOLT      0x08 /* Battery voltage measurement */
  81 +
  82 +/* RETU_ADC_BSI
  83 + * The battery size indicator ADC measures the resistance between
  84 + * the battery BSI pin and ground. This is used to detect the battery
  85 + * capacity, as the BSI resistor is related to capacity.
  86 + *
  87 + * Manually measured lookup table.
  88 + * Hard to measure, thus not very accurate.
  89 + *
  90 + * Resistance  |  ADC value
  91 + * ========================
  92 + * 120k        |  0x3AC
  93 + * 110k        |  0x37C
  94 + * 100k        |  0x351
  95 + *  90k        |  0x329
  96 + */
  97 +
  98 +/* RETU_ADC_BATTVOLT
  99 + * Manually measured lookup table.
 100 + * Hard to measure, thus not very accurate.
 101 + *
 102 + * Voltage  |  ADC value
 103 + * =====================
 104 + * 2.80V    |  0x037
 105 + * 2.90V    |  0x05E
 106 + * 3.00V    |  0x090
 107 + * 3.10V    |  0x0A4
 108 + * 3.20V    |  0x0CC
 109 + * 3.30V    |  0x0EF
 110 + * 3.40V    |  0x115
 111 + * 3.50V    |  0x136
 112 + * 3.60V    |  0x15C
 113 + * 3.70V    |  0x187
 114 + * 3.80V    |  0x1A5
 115 + * 3.90V    |  0x1C9
 116 + * 4.00V    |  0x1ED
 117 + * 4.10V    |  0x212
 118 + * 4.20V    |  0x236
 119 + */
 120 +
 121 +
 122 +enum n810bm_capacity {
 123 +       N810BM_CAP_UNKNOWN      = 0,
 124 +       N810BM_CAP_1500MAH      = 1500, /* 1500 mAh battery */
 125 +};
 126 +
 127 +struct n810bm {
 128 +       struct platform_device *pdev;
 129 +       enum n810bm_capacity capacity;
 130 +       struct timer_list check_timer;
 131 +       spinlock_t lock;
 132 +};
 133 +
 134 +
 135 +static NORET_TYPE void n810bm_emergency(struct n810bm *bm, const char *message) ATTRIB_NORET;
 136 +static void n810bm_emergency(struct n810bm *bm, const char *message)
 137 +{
 138 +       printk(KERN_EMERG "Nokia n810 battery management fatal fault: %s\n", message);
 139 +       /* Force a hard shutdown. */
 140 +       machine_power_off();
 141 +       panic("n810bm: Failed to halt machine in emergency state\n");
 142 +}
 143 +
 144 +#if 0
 145 +static u16 retu_read(struct n810bm *bm, unsigned int reg)
 146 +{
 147 +       int ret;
 148 +       unsigned long flags;
 149 +
 150 +       spin_lock_irqsave(&retu_lock, flags);
 151 +       ret = retu_read_reg(reg);
 152 +       spin_unlock_irqrestore(&retu_lock, flags);
 153 +       if (ret < 0 || ret > 0xFFFF)
 154 +               n810bm_emergency(bm, "retu_read");
 155 +
 156 +       return ret;
 157 +}
 158 +#endif
 159 +
 160 +static void retu_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set)
 161 +{
 162 +       int ret;
 163 +       unsigned long flags;
 164 +       u16 value;
 165 +
 166 +       spin_lock_irqsave(&retu_lock, flags);
 167 +       if (~mask) {
 168 +               ret = retu_read_reg(reg);
 169 +               if (ret < 0 || ret > 0xFFFF)
 170 +                       goto fatal_unlock;
 171 +               value = ret;
 172 +       } else
 173 +               value = 0;
 174 +       value &= ~mask;
 175 +       value |= set;
 176 +       ret = retu_write_reg(reg, value);
 177 +       if (ret)
 178 +               goto fatal_unlock;
 179 +       spin_unlock_irqrestore(&retu_lock, flags);
 180 +
 181 +       return;
 182 +
 183 +fatal_unlock:
 184 +       spin_unlock_irqrestore(&retu_lock, flags);
 185 +       n810bm_emergency(bm, "retu_maskset");
 186 +}
 187 +
 188 +static inline void retu_write(struct n810bm *bm, unsigned int reg, u16 value)
 189 +{
 190 +       return retu_maskset(bm, reg, 0xFFFF, value);
 191 +}
 192 +
 193 +static int retu_adc_average(struct n810bm *bm, unsigned int chan,
 194 +                           unsigned int nr_passes)
 195 +{
 196 +       unsigned int i, value = 0;
 197 +       int ret;
 198 +
 199 +       if (WARN_ON(!nr_passes))
 200 +               return 0;
 201 +       for (i = 0; i < nr_passes; i++) {
 202 +               ret = retu_read_adc(chan);
 203 +               if (ret < 0)
 204 +                       return ret;
 205 +               value += ret;
 206 +       }
 207 +       value /= nr_passes;
 208 +
 209 +       return value;
 210 +}
 211 +
 212 +/* Measure the battery voltage. Returns the value in mV (or negative value on error). */
 213 +static int n810bm_measure_batt_voltage(struct n810bm *bm)
 214 +{
 215 +       int adc;
 216 +       unsigned int mv;
 217 +       const unsigned int scale = 1000;
 218 +
 219 +       adc = retu_adc_average(bm, RETU_ADC_BATTVOLT, 5);
 220 +       if (adc < 0)
 221 +               return adc;
 222 +       if (adc <= 0x37)
 223 +               return 2800;
 224 +       mv = 2800 + ((adc - 0x37) * (((4200 - 2800) * scale) / (0x236 - 0x37))) / scale;
 225 +
 226 +       return mv;
 227 +}
 228 +
 229 +/* Read the battery capacity via BSI pin. */
 230 +static enum n810bm_capacity n810bm_read_batt_capacity(struct n810bm *bm)
 231 +{
 232 +       int adc;
 233 +       const unsigned int hyst = 16;
 234 +
 235 +       adc = retu_adc_average(bm, RETU_ADC_BSI, 5);
 236 +       if (adc < 0)
 237 +               return N810BM_CAP_UNKNOWN;
 238 +
 239 +       if (adc >= 0x3AC - hyst && adc <= 0x3AC + hyst)
 240 +               return N810BM_CAP_1500MAH;
 241 +
 242 +       return N810BM_CAP_UNKNOWN;
 243 +}
 244 +
 245 +struct mv2p {
 246 +       unsigned int mv;
 247 +       unsigned int p;
 248 +};
 249 +
 250 +/* Convert a battery voltage (in mV) to percentage. */
 251 +static unsigned int n810bm_mvolt2percent(unsigned int mv)
 252 +{
 253 +       /* FIXME: Create a correct table. */
 254 +       static const struct mv2p table[] = {
 255 +               { .mv = 4200, .p = 100, },
 256 +               { .mv = 4150, .p = 90, },
 257 +               { .mv = 4100, .p = 80, },
 258 +               { .mv = 4050, .p = 70, },
 259 +               { .mv = 4000, .p = 60, },
 260 +               { .mv = 3950, .p = 50, },
 261 +               { .mv = 3900, .p = 40, },
 262 +               { .mv = 3850, .p = 30, },
 263 +               { .mv = 3800, .p = 20, },
 264 +               { .mv = 3750, .p = 10, },
 265 +               { .mv = 3700, .p = 0, },
 266 +       };
 267 +       const struct mv2p *e;
 268 +       unsigned int i;
 269 +
 270 +       for (i = 0; i < ARRAY_SIZE(table); i++) {
 271 +               e = &table[i];
 272 +               if (mv >= e->mv)
 273 +                       return e->p;
 274 +       }
 275 +
 276 +       return 0;
 277 +}
 278 +
 279 +static void n810bm_check_timer(unsigned long data)
 280 +{
 281 +       struct n810bm *bm = (struct n810bm *)data;
 282 +       unsigned long flags;
 283 +       int mv;
 284 +
 285 +       spin_lock_irqsave(&bm->lock, flags);
 286 +
 287 +       mv = n810bm_measure_batt_voltage(bm);
 288 +       if (mv < 0)
 289 +               n810bm_emergency(bm, "check timer: Failed to measure");
 290 +       if (mv < N810BM_MIN_VOLTAGE_THRES)
 291 +               n810bm_emergency(bm, "check timer: Minimum voltage threshold reached");
 292 +
 293 +       mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL));
 294 +       spin_unlock_irqrestore(&bm->lock, flags);
 295 +
 296 +       return;
 297 +}
 298 +
 299 +static ssize_t n810bm_attr_charge_show(struct device *dev,
 300 +                                      struct device_attribute *attr,
 301 +                                      char *buf)
 302 +{
 303 +       struct platform_device *pdev = to_platform_device(dev);
 304 +       struct n810bm *bm = platform_get_drvdata(pdev);
 305 +       int err = -ENODEV;
 306 +       ssize_t count = 0;
 307 +       int millivolt;
 308 +
 309 +       spin_lock_irq(&bm->lock);
 310 +       millivolt = n810bm_measure_batt_voltage(bm);
 311 +       if (millivolt >= 0) {
 312 +               count = snprintf(buf, PAGE_SIZE, "%u\n",
 313 +                                n810bm_mvolt2percent(millivolt));
 314 +               err = 0;
 315 +       }
 316 +       spin_unlock_irq(&bm->lock);
 317 +
 318 +       return err ? err : count;
 319 +}
 320 +static DEVICE_ATTR(batt_charge, 0444, n810bm_attr_charge_show, NULL);
 321 +
 322 +static ssize_t n810bm_attr_capacity_show(struct device *dev,
 323 +                                        struct device_attribute *attr,
 324 +                                        char *buf)
 325 +{
 326 +       struct platform_device *pdev = to_platform_device(dev);
 327 +       struct n810bm *bm = platform_get_drvdata(pdev);
 328 +       ssize_t count;
 329 +
 330 +       spin_lock_irq(&bm->lock);
 331 +       count = snprintf(buf, PAGE_SIZE, "%u\n",
 332 +                        (unsigned int)bm->capacity);
 333 +       spin_unlock_irq(&bm->lock);
 334 +
 335 +       return count;
 336 +}
 337 +static DEVICE_ATTR(batt_capacity, 0444, n810bm_attr_capacity_show, NULL);
 338 +
 339 +static void n810bm_hw_exit(struct n810bm *bm)
 340 +{
 341 +       retu_write(bm, RETU_REG_ADCSCR, 0);
 342 +}
 343 +
 344 +static int n810bm_hw_init(struct n810bm *bm)
 345 +{
 346 +       retu_write(bm, RETU_REG_ADCSCR, 0);
 347 +
 348 +       bm->capacity = n810bm_read_batt_capacity(bm);
 349 +       if (bm->capacity == N810BM_CAP_UNKNOWN) {
 350 +               dev_err(&bm->pdev->dev, "Unknown battery detected");
 351 +               return -ENODEV;
 352 +       }
 353 +       dev_info(&bm->pdev->dev, "Detected %u mAh battery\n",
 354 +                (unsigned int)bm->capacity);
 355 +
 356 +       return 0;
 357 +}
 358 +
 359 +static int __devinit n810bm_probe(struct platform_device *pdev)
 360 +{
 361 +       struct n810bm *bm;
 362 +       int err;
 363 +
 364 +       bm = kzalloc(sizeof(*bm), GFP_KERNEL);
 365 +       if (!bm)
 366 +               return -ENOMEM;
 367 +       bm->pdev = pdev;
 368 +       platform_set_drvdata(pdev, bm);
 369 +       spin_lock_init(&bm->lock);
 370 +       setup_timer(&bm->check_timer, n810bm_check_timer, (unsigned long)bm);
 371 +
 372 +       err = n810bm_hw_init(bm);
 373 +       if (err)
 374 +               goto err_free;
 375 +       err = device_create_file(&pdev->dev, &dev_attr_batt_charge);
 376 +       if (err)
 377 +               goto err_exit;
 378 +       err = device_create_file(&pdev->dev, &dev_attr_batt_capacity);
 379 +       if (err)
 380 +               goto err_rem_charge;
 381 +
 382 +       mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL));
 383 +
 384 +       dev_info(&pdev->dev, "Battery management initialized");
 385 +
 386 +       return 0;
 387 +
 388 +err_rem_charge:
 389 +       device_remove_file(&pdev->dev, &dev_attr_batt_charge);
 390 +err_exit:
 391 +       n810bm_hw_exit(bm);
 392 +err_free:
 393 +       kfree(bm);
 394 +       platform_set_drvdata(pdev, NULL);
 395 +       return err;
 396 +}
 397 +
 398 +static int __devexit n810bm_remove(struct platform_device *pdev)
 399 +{
 400 +       struct n810bm *bm = platform_get_drvdata(pdev);
 401 +
 402 +       del_timer_sync(&bm->check_timer);
 403 +       device_remove_file(&pdev->dev, &dev_attr_batt_capacity);
 404 +       device_remove_file(&pdev->dev, &dev_attr_batt_charge);
 405 +       n810bm_hw_exit(bm);
 406 +
 407 +       kfree(bm);
 408 +       platform_set_drvdata(pdev, NULL);
 409 +
 410 +       return 0;
 411 +}
 412 +
 413 +static struct platform_driver n810bm_driver = {
 414 +       .remove         = __devexit_p(n810bm_remove),
 415 +       .driver         = {
 416 +               .name   = "n810bm",
 417 +       }
 418 +};
 419 +
 420 +static int __init n810bm_modinit(void)
 421 +{
 422 +       return platform_driver_probe(&n810bm_driver, n810bm_probe);
 423 +}
 424 +module_init(n810bm_modinit);
 425 +
 426 +static void __exit n810bm_modexit(void)
 427 +{
 428 +       platform_driver_unregister(&n810bm_driver);
 429 +}
 430 +module_exit(n810bm_modexit);
 431 +
 432 +MODULE_DESCRIPTION("Nokia n810 battery management");
 433 +MODULE_LICENSE("GPL");
 434 +MODULE_AUTHOR("Michael Buesch");
 435 --- linux-2.6.35.3.orig/drivers/cbus/retu.c
 436 +++ linux-2.6.35.3/drivers/cbus/retu.c
 437 @@ -85,10 +85,10 @@ int retu_read_reg(int reg)
 438   *
 439   * This function writes a value to the specified register
 440   */
 441 -void retu_write_reg(int reg, u16 val)
 442 +int retu_write_reg(int reg, u16 val)
 443  {
 444         BUG_ON(!retu_initialized);
 445 -       cbus_write_reg(cbus_host, RETU_ID, reg, val);
 446 +       return cbus_write_reg(cbus_host, RETU_ID, reg, val);
 447  }
 448
 449  void retu_set_clear_reg_bits(int reg, u16 set, u16 clear)
 450 --- linux-2.6.35.3.orig/drivers/cbus/retu.h
 451 +++ linux-2.6.35.3/drivers/cbus/retu.h
 452 @@ -58,7 +58,7 @@
 453  #define        MAX_RETU_IRQ_HANDLERS   16
 454
 455  int retu_read_reg(int reg);
 456 -void retu_write_reg(int reg, u16 val);
 457 +int retu_write_reg(int reg, u16 val);
 458  void retu_set_clear_reg_bits(int reg, u16 set, u16 clear);
 459  int retu_read_adc(int channel);
 460  int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
 461 --- linux-2.6.35.3.orig/arch/arm/mach-omap2/board-n8x0.c
 462 +++ linux-2.6.35.3/arch/arm/mach-omap2/board-n8x0.c
 463 @@ -875,6 +875,17 @@ extern void n8x0_blizzard_init(void);
 464  #define n8x0_blizzard_init() 0
 465  #endif
 466
 467 +static struct platform_device n810_bm_device = {
 468 +       .name           = "n810bm",
 469 +       .id             = -1,
 470 +};
 471 +
 472 +static void __init n810_bm_init(void)
 473 +{
 474 +       if (platform_device_register(&n810_bm_device))
 475 +               BUG();
 476 +}
 477 +
 478  static void __init n8x0_init_machine(void)
 479  {
 480         platform_device_register(&n8x0_cbus_device);
 481 @@ -901,6 +912,8 @@ static void __init n8x0_init_machine(voi
 482         n8x0_onenand_init();
 483         n8x0_mmc_init();
 484         n8x0_usb_init();
 485 +
 486 +       n810_bm_init();
 487  }
 488
 489  MACHINE_START(NOKIA_N800, "Nokia N800")