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

   1 ---
   2  arch/arm/mach-omap2/board-n8x0.c |   13 +
   3  drivers/cbus/Kconfig             |   12 +
   4  drivers/cbus/Makefile            |    3
   5  drivers/cbus/lipocharge.c        |   63 ++++++
   6  drivers/cbus/lipocharge.h        |   50 ++++
   7  drivers/cbus/n810bm_main.c       |  397 +++++++++++++++++++++++++++++++++++++++
   8  drivers/cbus/retu.c              |    4
   9  drivers/cbus/retu.h              |    3
  10  drivers/cbus/tahvo.h             |    6
  11  9 files changed, 548 insertions(+), 3 deletions(-)
  12
  13 Index: linux-2.6.37/drivers/cbus/Kconfig
  14 ===================================================================
  15 --- linux-2.6.37.orig/drivers/cbus/Kconfig      2011-02-06 00:24:48.502005279 +0100
  16 +++ linux-2.6.37/drivers/cbus/Kconfig   2011-02-06 00:24:48.550008091 +0100
  17 @@ -94,4 +94,12 @@
  18           to Retu/Vilma. Detection state and events are exposed through
  19           sysfs.
  20
  21 +config N810BM
  22 +       depends on CBUS_RETU && CBUS_TAHVO
  23 +       tristate "Nokia n810 battery management"
  24 +       ---help---
  25 +         Nokia n810 device battery management.
  26 +
  27 +         If unsure, say N.
  28 +
  29  endmenu
  30 Index: linux-2.6.37/drivers/cbus/Makefile
  31 ===================================================================
  32 --- linux-2.6.37.orig/drivers/cbus/Makefile     2011-02-06 00:24:48.493004751 +0100
  33 +++ linux-2.6.37/drivers/cbus/Makefile  2011-02-06 00:24:48.550008091 +0100
  34 @@ -12,3 +12,6 @@
  35  obj-$(CONFIG_CBUS_TAHVO_USER)  += tahvo-user.o
  36  obj-$(CONFIG_CBUS_RETU_USER)   += retu-user.o
  37  obj-$(CONFIG_CBUS_RETU_HEADSET)        += retu-headset.o
  38 +n810bm-y                       += n810bm_main.o
  39 +n810bm-y                       += lipocharge.o
  40 +obj-$(CONFIG_N810BM)           += n810bm.o
  41 Index: linux-2.6.37/drivers/cbus/n810bm_main.c
  42 ===================================================================
  43 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  44 +++ linux-2.6.37/drivers/cbus/n810bm_main.c     2011-02-06 13:36:49.581078785 +0100
  45 @@ -0,0 +1,959 @@
  46 +/*
  47 + *   Nokia n810 battery management
  48 + *
  49 + *   WARNING: This driver is based on unconfirmed documentation.
  50 + *            It is possibly dangerous to use this software.
  51 + *            Use this software at your own risk!
  52 + *
  53 + *   Copyright (c) 2010-2011 Michael Buesch <mb@bu3sch.de>
  54 + *
  55 + *   This program is free software; you can redistribute it and/or
  56 + *   modify it under the terms of the GNU General Public License
  57 + *   as published by the Free Software Foundation; either version 2
  58 + *   of the License, or (at your option) any later version.
  59 + *
  60 + *   This program is distributed in the hope that it will be useful,
  61 + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  62 + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  63 + *   GNU General Public License for more details.
  64 + */
  65 +
  66 +#define DEBUG
  67 +
  68 +#include <linux/module.h>
  69 +#include <linux/device.h>
  70 +#include <linux/platform_device.h>
  71 +#include <linux/slab.h>
  72 +#include <linux/spinlock.h>
  73 +#include <linux/timer.h>
  74 +#include <linux/reboot.h>
  75 +#include <linux/firmware.h>
  76 +
  77 +#include "retu.h"
  78 +#include "tahvo.h"
  79 +#include "lipocharge.h"
  80 +
  81 +
  82 +#define N810BM_PMM_BLOCK_FILENAME      "n810-cal-bme-pmm.fw"
  83 +#define N810BM_PMM_BLOCK_SIZE          0x600
  84 +
  85 +#define N810BM_CHECK_INTERVAL          (HZ * 2)
  86 +#define N810BM_MIN_VOLTAGE_THRES       3300 /* Absolute minimum voltage threshold */
  87 +
  88 +
  89 +/* RETU_ADC_BSI
  90 + * The battery size indicator ADC measures the resistance between
  91 + * the battery BSI pin and ground. This is used to detect the battery
  92 + * capacity, as the BSI resistor is related to capacity.
  93 + *
  94 + * Manually measured lookup table.
  95 + * Hard to measure, thus not very accurate.
  96 + *
  97 + * Resistance  |  ADC value
  98 + * ========================
  99 + * 120k        |  0x3AC
 100 + * 110k        |  0x37C
 101 + * 100k        |  0x351
 102 + *  90k        |  0x329
 103 + */
 104 +
 105 +/* RETU_ADC_BATTVOLT
 106 + * Manually measured lookup table.
 107 + * Hard to measure, thus not very accurate.
 108 + *
 109 + * Voltage  |  ADC value
 110 + * =====================
 111 + * 2.80V    |  0x037
 112 + * 2.90V    |  0x05E
 113 + * 3.00V    |  0x090
 114 + * 3.10V    |  0x0A4
 115 + * 3.20V    |  0x0CC
 116 + * 3.30V    |  0x0EF
 117 + * 3.40V    |  0x115
 118 + * 3.50V    |  0x136
 119 + * 3.60V    |  0x15C
 120 + * 3.70V    |  0x187
 121 + * 3.80V    |  0x1A5
 122 + * 3.90V    |  0x1C9
 123 + * 4.00V    |  0x1ED
 124 + * 4.10V    |  0x212
 125 + * 4.20V    |  0x236
 126 + */
 127 +
 128 +
 129 +enum n810bm_capacity {
 130 +       N810BM_CAP_UNKNOWN      = -1,
 131 +       N810BM_CAP_NONE         = 0,
 132 +       N810BM_CAP_1500MAH      = 1500, /* 1500 mAh battery */
 133 +};
 134 +
 135 +struct n810bm {
 136 +       bool battery_present;                   /* A battery is inserted */
 137 +       bool charger_present;                   /* The charger is connected */
 138 +       enum n810bm_capacity capacity;          /* The capacity of the inserted battery (if any) */
 139 +
 140 +       bool charger_enabled;                   /* Want to charge? */ //TODO
 141 +       struct lipocharge charger;              /* Charger subsystem */
 142 +
 143 +       struct platform_device *pdev;
 144 +       const struct firmware *pmm_block;       /* CAL PMM block */
 145 +
 146 +       struct timer_list check_timer;
 147 +
 148 +       bool initialized;                       /* The hardware was initialized */
 149 +       spinlock_t lock;
 150 +};
 151 +
 152 +
 153 +static inline struct n810bm * device_to_n810bm(struct device *dev)
 154 +{
 155 +       struct platform_device *pdev = to_platform_device(dev);
 156 +       struct n810bm *bm = platform_get_drvdata(pdev);
 157 +
 158 +       return bm;
 159 +}
 160 +
 161 +static NORET_TYPE void n810bm_emergency(struct n810bm *bm, const char *message) ATTRIB_NORET;
 162 +static void n810bm_emergency(struct n810bm *bm, const char *message)
 163 +{
 164 +       printk(KERN_EMERG "n810 battery management fatal fault: %s\n", message);
 165 +       /* Force a hard shutdown. */
 166 +       machine_power_off();
 167 +       panic("n810bm: Failed to halt machine in emergency state\n");
 168 +}
 169 +
 170 +static u16 tahvo_read(struct n810bm *bm, unsigned int reg)
 171 +{
 172 +       int ret;
 173 +       unsigned long flags;
 174 +
 175 +       spin_lock_irqsave(&tahvo_lock, flags);
 176 +       ret = tahvo_read_reg(reg);
 177 +       spin_unlock_irqrestore(&tahvo_lock, flags);
 178 +       if (ret < 0 || ret > 0xFFFF)
 179 +               n810bm_emergency(bm, "tahvo_read");
 180 +
 181 +       return ret;
 182 +}
 183 +
 184 +static void tahvo_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set)
 185 +{
 186 +       int ret;
 187 +       unsigned long flags;
 188 +       u16 value;
 189 +
 190 +       spin_lock_irqsave(&tahvo_lock, flags);
 191 +       if (~mask) {
 192 +               ret = tahvo_read_reg(reg);
 193 +               if (ret < 0 || ret > 0xFFFF)
 194 +                       goto fatal_unlock;
 195 +               value = ret;
 196 +       } else
 197 +               value = 0;
 198 +       value &= ~mask;
 199 +       value |= set;
 200 +       ret = tahvo_write_reg(reg, value);
 201 +       if (ret)
 202 +               goto fatal_unlock;
 203 +       spin_unlock_irqrestore(&tahvo_lock, flags);
 204 +
 205 +       return;
 206 +
 207 +fatal_unlock:
 208 +       spin_unlock_irqrestore(&tahvo_lock, flags);
 209 +       n810bm_emergency(bm, "tahvo_maskset");
 210 +}
 211 +
 212 +static inline void tahvo_write(struct n810bm *bm, unsigned int reg, u16 value)
 213 +{
 214 +       tahvo_maskset(bm, reg, 0xFFFF, value);
 215 +}
 216 +
 217 +static inline void tahvo_set(struct n810bm *bm, unsigned int reg, u16 mask)
 218 +{
 219 +       tahvo_maskset(bm, reg, mask, mask);
 220 +}
 221 +
 222 +static inline void tahvo_clear(struct n810bm *bm, unsigned int reg, u16 mask)
 223 +{
 224 +       tahvo_maskset(bm, reg, mask, 0);
 225 +}
 226 +
 227 +static u16 retu_read(struct n810bm *bm, unsigned int reg)
 228 +{
 229 +       int ret;
 230 +       unsigned long flags;
 231 +
 232 +       spin_lock_irqsave(&retu_lock, flags);
 233 +       ret = retu_read_reg(reg);
 234 +       spin_unlock_irqrestore(&retu_lock, flags);
 235 +       if (ret < 0 || ret > 0xFFFF)
 236 +               n810bm_emergency(bm, "retu_read");
 237 +
 238 +       return ret;
 239 +}
 240 +
 241 +static void retu_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set)
 242 +{
 243 +       int ret;
 244 +       unsigned long flags;
 245 +       u16 value;
 246 +
 247 +       spin_lock_irqsave(&retu_lock, flags);
 248 +       if (~mask) {
 249 +               ret = retu_read_reg(reg);
 250 +               if (ret < 0 || ret > 0xFFFF)
 251 +                       goto fatal_unlock;
 252 +               value = ret;
 253 +       } else
 254 +               value = 0;
 255 +       value &= ~mask;
 256 +       value |= set;
 257 +       ret = retu_write_reg(reg, value);
 258 +       if (ret)
 259 +               goto fatal_unlock;
 260 +       spin_unlock_irqrestore(&retu_lock, flags);
 261 +
 262 +       return;
 263 +
 264 +fatal_unlock:
 265 +       spin_unlock_irqrestore(&retu_lock, flags);
 266 +       n810bm_emergency(bm, "retu_maskset");
 267 +}
 268 +
 269 +static inline void retu_write(struct n810bm *bm, unsigned int reg, u16 value)
 270 +{
 271 +       retu_maskset(bm, reg, 0xFFFF, value);
 272 +}
 273 +
 274 +static int retu_adc_average(struct n810bm *bm, unsigned int chan,
 275 +                           unsigned int nr_passes)
 276 +{
 277 +       unsigned int i, value = 0;
 278 +       int ret;
 279 +
 280 +       if (WARN_ON(!nr_passes))
 281 +               return 0;
 282 +       for (i = 0; i < nr_passes; i++) {
 283 +               ret = retu_read_adc(chan);
 284 +               if (ret < 0)
 285 +                       return ret;
 286 +               value += ret;
 287 +       }
 288 +       value /= nr_passes;
 289 +
 290 +       return value;
 291 +}
 292 +
 293 +/* Set the current measure timer that triggers on Tahvo IRQ 7 */
 294 +static void n810bm_set_current_measure_timer(struct n810bm *bm,
 295 +                                            u16 millisec_interval)
 296 +{
 297 +       u16 value = millisec_interval;
 298 +
 299 +       if (value <= 0xF905) {
 300 +               value = ((u64)0x10624DD3 * (u64)(value + 0xF9)) >> 32;
 301 +               value /= 16;
 302 +       } else
 303 +               value = 0xFF;
 304 +
 305 +       tahvo_write(bm, TAHVO_REG_BATCURRTIMER, value & 0xFF);
 306 +
 307 +       tahvo_set(bm, TAHVO_REG_CHGCTL,
 308 +                 TAHVO_REG_CHGCTL_CURTIMRST);
 309 +       tahvo_clear(bm, TAHVO_REG_CHGCTL,
 310 +                   TAHVO_REG_CHGCTL_CURTIMRST);
 311 +}
 312 +
 313 +static void n810bm_enable_current_measure(struct n810bm *bm, bool slow, bool irq)
 314 +{
 315 +       u16 millisec_interval;
 316 +
 317 +       if (slow)
 318 +               millisec_interval = 1000;
 319 +       else
 320 +               millisec_interval = 250;
 321 +
 322 +       /* Enable the current measurement circuitry */
 323 +       tahvo_set(bm, TAHVO_REG_CHGCTL,
 324 +                 TAHVO_REG_CHGCTL_CURMEAS);
 325 +
 326 +       /* Setup the measurement timer */
 327 +       n810bm_set_current_measure_timer(bm, millisec_interval);
 328 +       if (irq)
 329 +               tahvo_enable_irq(TAHVO_INT_BATCURR);
 330 +
 331 +       //TODO also do a software timer for safety.
 332 +}
 333 +
 334 +static void n810bm_disable_current_measure(struct n810bm *bm)
 335 +{
 336 +       /* Disable the measurement timer */
 337 +       n810bm_set_current_measure_timer(bm, 0);
 338 +       tahvo_disable_irq(TAHVO_INT_BATCURR);
 339 +
 340 +       /* Disable the current measurement circuitry */
 341 +       tahvo_clear(bm, TAHVO_REG_CHGCTL,
 342 +                   TAHVO_REG_CHGCTL_CURMEAS);
 343 +}
 344 +
 345 +/* Measure the actual battery current. Returns a signed value in mA.
 346 + * Does only work, if current measurement was enabled. */
 347 +static int n810bm_measure_batt_current(struct n810bm *bm)
 348 +{
 349 +       u16 retval;
 350 +       int adc = 0, ma, i;
 351 +
 352 +       for (i = 0; i < 3; i++) {
 353 +               retval = tahvo_read(bm, TAHVO_REG_BATCURR);
 354 +               adc += (s16)retval; /* Value is signed */
 355 +       }
 356 +       adc /= 3;
 357 +
 358 +       //TODO convert to mA
 359 +       ma = adc;
 360 +
 361 +       return ma;
 362 +}
 363 +
 364 +static int adc_sanity_check(struct n810bm *bm, unsigned int channel)
 365 +{
 366 +       int value;
 367 +
 368 +       value = retu_read_adc(channel);
 369 +       if (value < 0) {
 370 +               dev_err(&bm->pdev->dev, "Failed to read GND ADC channel %u",
 371 +                       channel);
 372 +               return -EIO;
 373 +       }
 374 +       dev_dbg(&bm->pdev->dev,
 375 +               "GND ADC channel %u sanity check got value: %d",
 376 +               channel, value);
 377 +       if (value > 5) {
 378 +               n810bm_emergency(bm, "GND ADC sanity check failed");
 379 +               return -EIO;
 380 +       }
 381 +
 382 +       return 0;
 383 +}
 384 +
 385 +static int n810bm_check_adc_sanity(struct n810bm *bm)
 386 +{
 387 +       int err;
 388 +
 389 +       /* Discard one conversion */
 390 +       retu_write(bm, RETU_REG_ADCSCR, 0);
 391 +       retu_read_adc(RETU_ADC_GND2);
 392 +
 393 +       err = adc_sanity_check(bm, RETU_ADC_GND2);
 394 +       if (err)
 395 +               return err;
 396 +
 397 +       return 0;
 398 +}
 399 +
 400 +/* Measure the battery voltage. Returns the value in mV (or negative value on error). */
 401 +static int n810bm_measure_batt_voltage(struct n810bm *bm)
 402 +{
 403 +       int adc;
 404 +       unsigned int mv;
 405 +       const unsigned int scale = 1000;
 406 +
 407 +       adc = retu_adc_average(bm, RETU_ADC_BATTVOLT, 5);
 408 +       if (adc < 0)
 409 +               return adc;
 410 +       if (adc <= 0x37)
 411 +               return 2800;
 412 +       mv = 2800 + ((adc - 0x37) * (((4200 - 2800) * scale) / (0x236 - 0x37))) / scale;
 413 +
 414 +       return mv;
 415 +}
 416 +
 417 +/* Measure the charger voltage. Returns the value in mV (or negative value on error). */
 418 +static int n810bm_measure_charger_voltage(struct n810bm *bm)
 419 +{
 420 +       int adc;
 421 +       unsigned int mv;
 422 +
 423 +       adc = retu_adc_average(bm, RETU_ADC_CHGVOLT, 5);
 424 +       if (adc < 0)
 425 +               return adc;
 426 +       //TODO convert to mV
 427 +       mv = adc;
 428 +
 429 +       return mv;
 430 +}
 431 +
 432 +/* Measure backup battery voltage. Returns the value in mV (or negative value on error). */
 433 +static int n810bm_measure_backup_batt_voltage(struct n810bm *bm)
 434 +{
 435 +       int adc;
 436 +       unsigned int mv;
 437 +
 438 +       adc = retu_adc_average(bm, RETU_ADC_BKUPVOLT, 3);
 439 +       if (adc < 0)
 440 +               return adc;
 441 +       //TODO convert to mV
 442 +       mv = adc;
 443 +
 444 +       return mv;
 445 +}
 446 +
 447 +/* Measure the battery temperature. Returns the value in K (or negative value on error). */
 448 +static int n810bm_measure_batt_temp(struct n810bm *bm)
 449 +{
 450 +       int adc;
 451 +       unsigned int k;
 452 +
 453 +       adc = retu_adc_average(bm, RETU_ADC_BATTEMP, 3);
 454 +       if (adc < 0)
 455 +               return adc;
 456 +       //TODO convert to K
 457 +       k = adc;
 458 +
 459 +       return k;
 460 +}
 461 +
 462 +/* Read the battery capacity via BSI pin. */
 463 +static enum n810bm_capacity n810bm_read_batt_capacity(struct n810bm *bm)
 464 +{
 465 +       int adc;
 466 +       const unsigned int hyst = 20;
 467 +
 468 +       adc = retu_adc_average(bm, RETU_ADC_BSI, 5);
 469 +       if (adc < 0) {
 470 +               dev_err(&bm->pdev->dev, "Failed to read BSI ADC");
 471 +               return N810BM_CAP_UNKNOWN;
 472 +       }
 473 +
 474 +       if (adc >= 0x3B5 - hyst && adc <= 0x3B5 + hyst)
 475 +               return N810BM_CAP_1500MAH;
 476 +
 477 +       dev_err(&bm->pdev->dev, "Capacity indicator 0x%X unknown", adc);
 478 +
 479 +       return N810BM_CAP_UNKNOWN;
 480 +}
 481 +
 482 +/* Convert a battery voltage (in mV) to percentage. */
 483 +static unsigned int n810bm_mvolt2percent(unsigned int mv)
 484 +{
 485 +       const unsigned int minv = 3700;
 486 +       const unsigned int maxv = 4150;
 487 +       unsigned int percent;
 488 +
 489 +       mv = clamp(mv, minv, maxv);
 490 +       percent = (mv - minv) * 100 / (maxv - minv);
 491 +
 492 +       return percent;
 493 +}
 494 +
 495 +/* Periodic check */
 496 +static void n810bm_check_timer(unsigned long data)
 497 +{
 498 +       struct n810bm *bm = (struct n810bm *)data;
 499 +       unsigned long flags;
 500 +       u16 status;
 501 +       bool battery_was_present, charger_was_present;
 502 +       bool force_charge = 0;
 503 +       int mv;
 504 +
 505 +       spin_lock_irqsave(&bm->lock, flags);
 506 +
 507 +       status = retu_read(bm, RETU_REG_STATUS);
 508 +       battery_was_present = bm->battery_present;
 509 +       charger_was_present = bm->charger_present;
 510 +       bm->battery_present = !!(status & RETU_REG_STATUS_BATAVAIL);
 511 +       bm->charger_present = !!(status & RETU_REG_STATUS_CHGPLUG);
 512 +
 513 +       if (bm->battery_present != battery_was_present) {
 514 +               /* Battery state changed */
 515 +               if (bm->battery_present) {
 516 +                       bm->capacity = n810bm_read_batt_capacity(bm);
 517 +                       if (bm->capacity == N810BM_CAP_UNKNOWN) {
 518 +                               dev_err(&bm->pdev->dev, "Unknown battery detected");
 519 +                       } else {
 520 +                               dev_info(&bm->pdev->dev, "Detected %u mAh battery",
 521 +                                        (unsigned int)bm->capacity);
 522 +                       }
 523 +               } else {
 524 +                       bm->capacity = N810BM_CAP_NONE;
 525 +                       dev_info(&bm->pdev->dev, "The main battery was removed");
 526 +                       //TODO what do if charging?
 527 +               }
 528 +       }
 529 +
 530 +       if (bm->charger_present != charger_was_present) {
 531 +               /* Charger state changed */
 532 +               dev_info(&bm->pdev->dev, "The charger was %s",
 533 +                        bm->charger_present ? "plugged in" : "removed");
 534 +       }
 535 +
 536 +       if (bm->battery_present && !lipocharge_is_charging(&bm->charger)) {
 537 +               mv = n810bm_measure_batt_voltage(bm);
 538 +               if (mv < 0)
 539 +                       n810bm_emergency(bm, "check timer: Failed to measure");
 540 +               if (!bm->charger_present) {
 541 +                       if (mv < N810BM_MIN_VOLTAGE_THRES) {
 542 +                               n810bm_emergency(bm, "check timer: "
 543 +                                       "Minimum voltage threshold reached");
 544 +                       }
 545 +                       force_charge = 1;
 546 +               }
 547 +       }
 548 +
 549 +       if (bm->charger_present && bm->battery_present) {
 550 +               if (bm->charger_enabled || force_charge) {
 551 +                       if (!lipocharge_is_charging(&bm->charger)) {
 552 +                               //TODO start charging, if battery is below some threshold
 553 +                       }
 554 +               }
 555 +       }
 556 +
 557 +       mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL));
 558 +       spin_unlock_irqrestore(&bm->lock, flags);
 559 +
 560 +       return;
 561 +}
 562 +
 563 +static void n810bm_adc_irq_handler(unsigned long data)
 564 +{
 565 +       struct n810bm *bm = (struct n810bm *)data;
 566 +
 567 +       retu_ack_irq(RETU_INT_ADCS);
 568 +       //TODO
 569 +dev_dbg(&bm->pdev->dev, "ADC interrupt triggered\n");
 570 +}
 571 +
 572 +static void n810bm_tahvo_current_measure_irq_handler(unsigned long data)
 573 +{
 574 +       struct n810bm *bm = (struct n810bm *)data;
 575 +
 576 +       tahvo_ack_irq(TAHVO_INT_BATCURR);
 577 +       //TODO
 578 +dev_dbg(&bm->pdev->dev, "Tahvo measure IRQ triggered\n");
 579 +}
 580 +
 581 +#define DEFINE_SHOW_INT_FUNC(name, member)                                     \
 582 +       static ssize_t n810bm_##name##_show(struct device *dev,                 \
 583 +                                           struct device_attribute *attr,      \
 584 +                                           char *buf)                          \
 585 +       {                                                                       \
 586 +               struct n810bm *bm = device_to_n810bm(dev);                      \
 587 +               ssize_t count;                                                  \
 588 +                                                                               \
 589 +               spin_lock_irq(&bm->lock);                                       \
 590 +               count = snprintf(buf, PAGE_SIZE, "%d\n", (int)(bm->member));    \
 591 +               spin_unlock_irq(&bm->lock);                                     \
 592 +                                                                               \
 593 +               return count;                                                   \
 594 +       }
 595 +
 596 +#define DEFINE_STORE_INT_FUNC(name, member)                                    \
 597 +       static ssize_t n810bm_##name##_store(struct device *dev,                \
 598 +                                            struct device_attribute *attr,     \
 599 +                                            const char *buf, size_t count)     \
 600 +       {                                                                       \
 601 +               struct n810bm *bm = device_to_n810bm(dev);                      \
 602 +               long val;                                                       \
 603 +               int err;                                                        \
 604 +                                                                               \
 605 +               spin_lock_irq(&bm->lock);                                       \
 606 +               err = strict_strtol(buf, 0, &val);                              \
 607 +               if (!err)                                                       \
 608 +                       bm->member = (typeof(bm->member))val;                   \
 609 +               spin_unlock_irq(&bm->lock);                                     \
 610 +                                                                               \
 611 +               return err ? err : count;                                       \
 612 +       }
 613 +
 614 +#define DEFINE_ATTR_SHOW_INT(name, member)                                     \
 615 +       DEFINE_SHOW_INT_FUNC(name, member)                                      \
 616 +       static DEVICE_ATTR(name, 0444, n810bm_##name##_show, NULL);
 617 +
 618 +#define DEFINE_ATTR_SHOW_STORE_INT(name, member)                               \
 619 +       DEFINE_SHOW_INT_FUNC(name, member)                                      \
 620 +       DEFINE_STORE_INT_FUNC(name, member)                                     \
 621 +       static DEVICE_ATTR(name, 0644, n810bm_##name##_show,                    \
 622 +                                      n810bm_##name##_store);
 623 +
 624 +DEFINE_ATTR_SHOW_INT(batt_present, battery_present);
 625 +DEFINE_ATTR_SHOW_INT(charger_present, charger_present);
 626 +DEFINE_ATTR_SHOW_STORE_INT(charger_enable, charger_enabled);
 627 +
 628 +static ssize_t n810bm_attr_charge_show(struct device *dev,
 629 +                                      struct device_attribute *attr,
 630 +                                      char *buf)
 631 +{
 632 +       struct n810bm *bm = device_to_n810bm(dev);
 633 +       int err = -ENODEV;
 634 +       ssize_t count = 0;
 635 +       int millivolt;
 636 +
 637 +       spin_lock_irq(&bm->lock);
 638 +       if (bm->battery_present) {
 639 +               millivolt = n810bm_measure_batt_voltage(bm);
 640 +               if (millivolt >= 0) {
 641 +                       count = snprintf(buf, PAGE_SIZE, "%u\n",
 642 +                                        n810bm_mvolt2percent(millivolt));
 643 +                       err = 0;
 644 +               }
 645 +       } else {
 646 +               count = snprintf(buf, PAGE_SIZE, "no battery\n");
 647 +               err = 0;
 648 +       }
 649 +       spin_unlock_irq(&bm->lock);
 650 +
 651 +       return err ? err : count;
 652 +}
 653 +static DEVICE_ATTR(batt_charge, 0444, n810bm_attr_charge_show, NULL);
 654 +
 655 +static ssize_t n810bm_attr_capacity_show(struct device *dev,
 656 +                                        struct device_attribute *attr,
 657 +                                        char *buf)
 658 +{
 659 +       struct n810bm *bm = device_to_n810bm(dev);
 660 +       ssize_t count;
 661 +
 662 +       spin_lock_irq(&bm->lock);
 663 +       if (bm->battery_present) {
 664 +               count = snprintf(buf, PAGE_SIZE, "%d\n",
 665 +                                (int)bm->capacity);
 666 +       } else
 667 +               count = snprintf(buf, PAGE_SIZE, "no battery\n");
 668 +       spin_unlock_irq(&bm->lock);
 669 +
 670 +       return count;
 671 +}
 672 +static DEVICE_ATTR(batt_capacity, 0444, n810bm_attr_capacity_show, NULL);
 673 +
 674 +static ssize_t n810bm_attr_battemp_show(struct device *dev,
 675 +                                       struct device_attribute *attr,
 676 +                                       char *buf)
 677 +{
 678 +       struct n810bm *bm = device_to_n810bm(dev);
 679 +       ssize_t count = 0;
 680 +       int k, err = -ENODEV;
 681 +
 682 +       spin_lock_irq(&bm->lock);
 683 +       k = n810bm_measure_batt_temp(bm);
 684 +       if (k >= 0) {
 685 +               count = snprintf(buf, PAGE_SIZE, "%d\n", k);
 686 +               err = 0;
 687 +       }
 688 +       spin_unlock_irq(&bm->lock);
 689 +
 690 +       return err ? err : count;
 691 +}
 692 +static DEVICE_ATTR(batt_temp, 0444, n810bm_attr_battemp_show, NULL);
 693 +
 694 +static ssize_t n810bm_attr_charger_voltage_show(struct device *dev,
 695 +                                               struct device_attribute *attr,
 696 +                                               char *buf)
 697 +{
 698 +       struct n810bm *bm = device_to_n810bm(dev);
 699 +       ssize_t count = 0;
 700 +       int mv, err = -ENODEV;
 701 +
 702 +       spin_lock_irq(&bm->lock);
 703 +       if (bm->charger_present) {
 704 +               mv = n810bm_measure_charger_voltage(bm);
 705 +               if (mv >= 0) {
 706 +                       count = snprintf(buf, PAGE_SIZE, "%d\n", mv);
 707 +                       err = 0;
 708 +               }
 709 +       } else {
 710 +               count = snprintf(buf, PAGE_SIZE, "no charger\n");
 711 +               err = 0;
 712 +       }
 713 +       spin_unlock_irq(&bm->lock);
 714 +
 715 +       return err ? err : count;
 716 +}
 717 +static DEVICE_ATTR(charger_voltage, 0444, n810bm_attr_charger_voltage_show, NULL);
 718 +
 719 +static ssize_t n810bm_attr_backup_batt_voltage_show(struct device *dev,
 720 +                                                   struct device_attribute *attr,
 721 +                                                   char *buf)
 722 +{
 723 +       struct n810bm *bm = device_to_n810bm(dev);
 724 +       ssize_t count = 0;
 725 +       int mv, err = -ENODEV;
 726 +
 727 +       spin_lock_irq(&bm->lock);
 728 +       mv = n810bm_measure_backup_batt_voltage(bm);
 729 +       if (mv >= 0) {
 730 +               count = snprintf(buf, PAGE_SIZE, "%d\n", mv);
 731 +               err = 0;
 732 +       }
 733 +       spin_unlock_irq(&bm->lock);
 734 +
 735 +       return err ? err : count;
 736 +}
 737 +static DEVICE_ATTR(backup_batt_voltage, 0444, n810bm_attr_backup_batt_voltage_show, NULL);
 738 +
 739 +static ssize_t n810bm_attr_batt_current_show(struct device *dev,
 740 +                                            struct device_attribute *attr,
 741 +                                            char *buf)
 742 +{
 743 +       struct n810bm *bm = device_to_n810bm(dev);
 744 +       ssize_t count = 0;
 745 +       int ma;
 746 +
 747 +       spin_lock_irq(&bm->lock);
 748 +       if (bm->battery_present) {
 749 +               ma = n810bm_measure_batt_current(bm);//FIXME
 750 +               count = snprintf(buf, PAGE_SIZE, "%d\n", ma);
 751 +       } else
 752 +               count = snprintf(buf, PAGE_SIZE, "no battery\n");
 753 +       spin_unlock_irq(&bm->lock);
 754 +
 755 +       return count;
 756 +}
 757 +static DEVICE_ATTR(batt_current, 0444, n810bm_attr_batt_current_show, NULL);
 758 +
 759 +//TODO remove this
 760 +static ssize_t n810bm_attr_charger_status_show(struct device *dev,
 761 +                                              struct device_attribute *attr,
 762 +                                              char *buf)
 763 +{
 764 +       struct n810bm *bm = device_to_n810bm(dev);
 765 +       ssize_t count = 0;
 766 +       unsigned int stat;
 767 +
 768 +       spin_lock_irq(&bm->lock);
 769 +       stat = retu_read(bm, RETU_REG_STATUS);
 770 +       count = snprintf(buf, PAGE_SIZE, "0x%X\n", stat);
 771 +       spin_unlock_irq(&bm->lock);
 772 +
 773 +       return count;
 774 +}
 775 +static DEVICE_ATTR(charger_status, 0444, n810bm_attr_charger_status_show, NULL);
 776 +
 777 +//TODO remove this
 778 +static ssize_t n810bm_attr_charge_current_show(struct device *dev,
 779 +                                              struct device_attribute *attr,
 780 +                                              char *buf)
 781 +{
 782 +       struct n810bm *bm = device_to_n810bm(dev);
 783 +       ssize_t count = 0;
 784 +       unsigned int val;
 785 +
 786 +       spin_lock_irq(&bm->lock);
 787 +       val = tahvo_read(bm, TAHVO_REG_CHGCURR);
 788 +       count = snprintf(buf, PAGE_SIZE, "0x%X\n", val);
 789 +       spin_unlock_irq(&bm->lock);
 790 +
 791 +       return count;
 792 +}
 793 +
 794 +static ssize_t n810bm_attr_charge_current_store(struct device *dev,
 795 +                                               struct device_attribute *attr,
 796 +                                               const char *buf, size_t count)
 797 +{
 798 +       struct n810bm *bm = device_to_n810bm(dev);
 799 +       unsigned long val;
 800 +       int err;
 801 +
 802 +       spin_lock_irq(&bm->lock);
 803 +       err = strict_strtoul(buf, 0, &val);
 804 +       if (!err && val <= 0xFF)
 805 +               tahvo_write(bm, TAHVO_REG_CHGCURR, val);
 806 +       spin_unlock_irq(&bm->lock);
 807 +
 808 +       return err ? err : count;
 809 +}
 810 +static DEVICE_ATTR(charge_current, 0644,
 811 +                  n810bm_attr_charge_current_show,
 812 +                  n810bm_attr_charge_current_store);
 813 +
 814 +static const struct device_attribute *n810bm_attrs[] = {
 815 +       &dev_attr_batt_present,
 816 +       &dev_attr_batt_charge,
 817 +       &dev_attr_batt_current,
 818 +       &dev_attr_batt_capacity,
 819 +       &dev_attr_batt_temp,
 820 +       &dev_attr_backup_batt_voltage,
 821 +       &dev_attr_charger_present,
 822 +       &dev_attr_charger_voltage,
 823 +       &dev_attr_charger_status,
 824 +       &dev_attr_charger_enable,
 825 +       &dev_attr_charge_current,
 826 +};
 827 +
 828 +static void n810bm_hw_exit(struct n810bm *bm)
 829 +{
 830 +       retu_write(bm, RETU_REG_ADCSCR, 0);
 831 +       //TODO
 832 +}
 833 +
 834 +static int n810bm_hw_init(struct n810bm *bm)
 835 +{
 836 +       int err;
 837 +
 838 +       err = n810bm_check_adc_sanity(bm);
 839 +       if (err)
 840 +               return err;
 841 +
 842 +       return 0;
 843 +}
 844 +
 845 +static int n810bm_device_init(struct n810bm *bm)
 846 +{
 847 +       int attr_index;
 848 +       int err;
 849 +
 850 +       err = n810bm_hw_init(bm);
 851 +       if (err)
 852 +               goto error;
 853 +       for (attr_index = 0; attr_index < ARRAY_SIZE(n810bm_attrs); attr_index++) {
 854 +               err = device_create_file(&bm->pdev->dev, n810bm_attrs[attr_index]);
 855 +               if (err)
 856 +                       goto err_unwind_attrs;
 857 +       }
 858 +       err = retu_request_irq(RETU_INT_ADCS,
 859 +                              n810bm_adc_irq_handler,
 860 +                              (unsigned long)bm, "n810bm");
 861 +       if (err)
 862 +               goto err_unwind_attrs;
 863 +       err = tahvo_request_irq(TAHVO_INT_BATCURR,
 864 +                               n810bm_tahvo_current_measure_irq_handler,
 865 +                               (unsigned long)bm, "n810bm");
 866 +       if (err)
 867 +               goto err_free_retu_irq;
 868 +
 869 +       lipocharge_init(&bm->charger);
 870 +       mod_timer(&bm->check_timer, round_jiffies(jiffies + N810BM_CHECK_INTERVAL));
 871 +
 872 +       bm->initialized = 1;
 873 +       dev_info(&bm->pdev->dev, "Battery management initialized");
 874 +
 875 +       return 0;
 876 +
 877 +err_free_retu_irq:
 878 +       retu_free_irq(RETU_INT_ADCS);
 879 +err_unwind_attrs:
 880 +       for (attr_index--; attr_index >= 0; attr_index--)
 881 +               device_remove_file(&bm->pdev->dev, n810bm_attrs[attr_index]);
 882 +/*err_exit:*/
 883 +       n810bm_hw_exit(bm);
 884 +error:
 885 +       return err;
 886 +}
 887 +
 888 +static void n810bm_device_exit(struct n810bm *bm)
 889 +{
 890 +       int i;
 891 +
 892 +       if (!bm->initialized)
 893 +               return;
 894 +
 895 +       lipocharge_exit(&bm->charger);
 896 +       tahvo_free_irq(TAHVO_INT_BATCURR);
 897 +       retu_free_irq(RETU_INT_ADCS);
 898 +       del_timer_sync(&bm->check_timer);
 899 +       for (i = 0; i < ARRAY_SIZE(n810bm_attrs); i++)
 900 +               device_remove_file(&bm->pdev->dev, n810bm_attrs[i]);
 901 +       n810bm_hw_exit(bm);
 902 +       release_firmware(bm->pmm_block);
 903 +
 904 +       bm->initialized = 0;
 905 +}
 906 +
 907 +static void n810bm_pmm_block_found(const struct firmware *fw, void *context)
 908 +{
 909 +       struct n810bm *bm = context;
 910 +       int err;
 911 +
 912 +       if (!fw) {
 913 +               dev_err(&bm->pdev->dev,
 914 +                       "CAL PMM block image file not found");
 915 +               goto error;
 916 +       }
 917 +       if (fw->size != N810BM_PMM_BLOCK_SIZE ||
 918 +           memcmp(fw->data, "BME-PMM-BLOCK01", 15) != 0) {
 919 +               dev_err(&bm->pdev->dev,
 920 +                       "CAL PMM block image file has an invalid format");
 921 +               goto error;
 922 +       }
 923 +
 924 +       bm->pmm_block = fw;
 925 +       err = n810bm_device_init(bm);
 926 +       if (err) {
 927 +               dev_err(&bm->pdev->dev,
 928 +                       "Failed to initialized battery management (%d)", err);
 929 +               goto error;
 930 +       }
 931 +
 932 +       return;
 933 +error:
 934 +       release_firmware(fw);
 935 +}
 936 +
 937 +static int __devinit n810bm_probe(struct platform_device *pdev)
 938 +{
 939 +       struct n810bm *bm;
 940 +       int err;
 941 +
 942 +       bm = kzalloc(sizeof(*bm), GFP_KERNEL);
 943 +       if (!bm)
 944 +               return -ENOMEM;
 945 +       bm->pdev = pdev;
 946 +       platform_set_drvdata(pdev, bm);
 947 +       spin_lock_init(&bm->lock);
 948 +       setup_timer(&bm->check_timer, n810bm_check_timer, (unsigned long)bm);
 949 +
 950 +       dev_info(&bm->pdev->dev, "Requesting CAL BME PMM block firmware file "
 951 +                N810BM_PMM_BLOCK_FILENAME);
 952 +       err = request_firmware_nowait(THIS_MODULE, 1,
 953 +                                     N810BM_PMM_BLOCK_FILENAME,
 954 +                                     &bm->pdev->dev, GFP_KERNEL,
 955 +                                     bm, n810bm_pmm_block_found);
 956 +       if (err) {
 957 +               dev_err(&bm->pdev->dev,
 958 +                       "Failed to request CAL PMM block image file (%d)", err);
 959 +               goto err_free;
 960 +       }
 961 +
 962 +       return 0;
 963 +
 964 +err_free:
 965 +       kfree(bm);
 966 +
 967 +       return err;
 968 +}
 969 +
 970 +static int __devexit n810bm_remove(struct platform_device *pdev)
 971 +{
 972 +       struct n810bm *bm = platform_get_drvdata(pdev);
 973 +
 974 +       n810bm_device_exit(bm);
 975 +
 976 +       kfree(bm);
 977 +       platform_set_drvdata(pdev, NULL);
 978 +
 979 +       return 0;
 980 +}
 981 +
 982 +static struct platform_driver n810bm_driver = {
 983 +       .remove         = __devexit_p(n810bm_remove),
 984 +       .driver         = {
 985 +               .name   = "n810bm",
 986 +       }
 987 +};
 988 +
 989 +static int __init n810bm_modinit(void)
 990 +{
 991 +       return platform_driver_probe(&n810bm_driver, n810bm_probe);
 992 +}
 993 +module_init(n810bm_modinit);
 994 +
 995 +static void __exit n810bm_modexit(void)
 996 +{
 997 +       platform_driver_unregister(&n810bm_driver);
 998 +}
 999 +module_exit(n810bm_modexit);
1000 +
1001 +MODULE_DESCRIPTION("Nokia n810 battery management");
1002 +MODULE_FIRMWARE(N810BM_PMM_BLOCK_FILENAME);
1003 +MODULE_LICENSE("GPL");
1004 +MODULE_AUTHOR("Michael Buesch");
1005 Index: linux-2.6.37/drivers/cbus/retu.c
1006 ===================================================================
1007 --- linux-2.6.37.orig/drivers/cbus/retu.c       2011-02-06 00:24:48.493004751 +0100
1008 +++ linux-2.6.37/drivers/cbus/retu.c    2011-02-06 00:24:48.551008149 +0100
1009 @@ -85,10 +85,10 @@
1010   *
1011   * This function writes a value to the specified register
1012   */
1013 -void retu_write_reg(int reg, u16 val)
1014 +int retu_write_reg(int reg, u16 val)
1015  {
1016         BUG_ON(!retu_initialized);
1017 -       cbus_write_reg(cbus_host, RETU_ID, reg, val);
1018 +       return cbus_write_reg(cbus_host, RETU_ID, reg, val);
1019  }
1020
1021  void retu_set_clear_reg_bits(int reg, u16 set, u16 clear)
1022 Index: linux-2.6.37/drivers/cbus/retu.h
1023 ===================================================================
1024 --- linux-2.6.37.orig/drivers/cbus/retu.h       2011-02-06 00:24:48.493004751 +0100
1025 +++ linux-2.6.37/drivers/cbus/retu.h    2011-02-06 00:24:48.551008149 +0100
1026 @@ -40,6 +40,8 @@
1027  #define RETU_REG_CTRL_CLR      0x0f    /* Regulator clear register */
1028  #define RETU_REG_CTRL_SET      0x10    /* Regulator set register */
1029  #define RETU_REG_STATUS                0x16    /* Status register */
1030 +#define  RETU_REG_STATUS_BATAVAIL      0x0100 /* Battery available */
1031 +#define  RETU_REG_STATUS_CHGPLUG       0x1000 /* Charger is plugged in */
1032  #define RETU_REG_WATCHDOG      0x17    /* Watchdog register */
1033  #define RETU_REG_AUDTXR                0x18    /* Audio Codec Tx register */
1034  #define RETU_REG_MAX           0x1f
1035 @@ -57,8 +59,25 @@
1036
1037  #define        MAX_RETU_IRQ_HANDLERS   16
1038
1039 +/* ADC channels */
1040 +#define RETU_ADC_GND           0x00 /* Ground */
1041 +#define RETU_ADC_BSI           0x01 /* Battery Size Indicator */
1042 +#define RETU_ADC_BATTEMP       0x02 /* Battery temperature */
1043 +#define RETU_ADC_CHGVOLT       0x03 /* Charger voltage */
1044 +#define RETU_ADC_HEADSET       0x04 /* Headset detection */
1045 +#define RETU_ADC_HOOKDET       0x05 /* Hook detection */
1046 +#define RETU_ADC_RFGP          0x06 /* RF GP */
1047 +#define RETU_ADC_WBTX          0x07 /* Wideband Tx detection */
1048 +#define RETU_ADC_BATTVOLT      0x08 /* Battery voltage measurement */
1049 +#define RETU_ADC_GND2          0x09 /* Ground */
1050 +#define RETU_ADC_LIGHTSENS     0x0A /* Light sensor */
1051 +#define RETU_ADC_LIGHTTEMP     0x0B /* Light sensor temperature */
1052 +#define RETU_ADC_BKUPVOLT      0x0C /* Backup battery voltage */
1053 +#define RETU_ADC_TEMP          0x0D /* RETU temperature */
1054 +
1055 +
1056  int retu_read_reg(int reg);
1057 -void retu_write_reg(int reg, u16 val);
1058 +int retu_write_reg(int reg, u16 val);
1059  void retu_set_clear_reg_bits(int reg, u16 set, u16 clear);
1060  int retu_read_adc(int channel);
1061  int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
1062 Index: linux-2.6.37/arch/arm/mach-omap2/board-n8x0.c
1063 ===================================================================
1064 --- linux-2.6.37.orig/arch/arm/mach-omap2/board-n8x0.c  2011-02-06 00:24:48.478003872 +0100
1065 +++ linux-2.6.37/arch/arm/mach-omap2/board-n8x0.c       2011-02-06 00:24:48.551008149 +0100
1066 @@ -907,6 +907,17 @@
1067                                     ARRAY_SIZE(n8x0_gpio_switches));
1068  }
1069
1070 +static struct platform_device n810_bm_device = {
1071 +       .name           = "n810bm",
1072 +       .id             = -1,
1073 +};
1074 +
1075 +static void __init n810_bm_init(void)
1076 +{
1077 +       if (platform_device_register(&n810_bm_device))
1078 +               BUG();
1079 +}
1080 +
1081  static void __init n8x0_init_machine(void)
1082  {
1083         omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAC);
1084 @@ -933,6 +944,8 @@
1085         n8x0_onenand_init();
1086         n8x0_mmc_init();
1087         n8x0_usb_init();
1088 +
1089 +       n810_bm_init();
1090  }
1091
1092  MACHINE_START(NOKIA_N800, "Nokia N800")
1093 Index: linux-2.6.37/drivers/cbus/lipocharge.c
1094 ===================================================================
1095 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1096 +++ linux-2.6.37/drivers/cbus/lipocharge.c      2011-02-06 12:57:01.427475867 +0100
1097 @@ -0,0 +1,58 @@
1098 +/*
1099 + *   Generic LIPO battery charger
1100 + *
1101 + *   Copyright (c) 2010 Michael Buesch <mb@bu3sch.de>
1102 + *
1103 + *   This program is free software; you can redistribute it and/or
1104 + *   modify it under the terms of the GNU General Public License
1105 + *   as published by the Free Software Foundation; either version 2
1106 + *   of the License, or (at your option) any later version.
1107 + *
1108 + *   This program is distributed in the hope that it will be useful,
1109 + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
1110 + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1111 + *   GNU General Public License for more details.
1112 + */
1113 +
1114 +#include "lipocharge.h"
1115 +
1116 +#include <linux/slab.h>
1117 +
1118 +
1119 +static void lipocharge_timer(unsigned long data)
1120 +{
1121 +       struct lipocharge *c = (struct lipocharge *)data;
1122 +
1123 +       spin_lock(&c->lock);
1124 +       //TODO
1125 +       spin_unlock(&c->lock);
1126 +}
1127 +
1128 +void lipocharge_init(struct lipocharge *c)
1129 +{
1130 +       spin_lock_init(&c->lock);
1131 +       setup_timer(&c->timer, lipocharge_timer, (unsigned long)c);
1132 +}
1133 +
1134 +void lipocharge_exit(struct lipocharge *c)
1135 +{
1136 +}
1137 +
1138 +int lipocharge_start(struct lipocharge *c)
1139 +{
1140 +       if (!c->set_charge_current || !c->get_charge_current ||
1141 +           !c->get_voltage ||
1142 +           !c->finished || !c->emergency)
1143 +               return -EINVAL;
1144 +       if (!c->top_voltage || c->top_voltage > 4200)
1145 +               return -EINVAL;
1146 +       //TODO
1147 +
1148 +       return 0;
1149 +}
1150 +
1151 +void lipocharge_stop(struct lipocharge *c)
1152 +{
1153 +       del_timer_sync(&c->timer);
1154 +       //TODO
1155 +}
1156 Index: linux-2.6.37/drivers/cbus/lipocharge.h
1157 ===================================================================
1158 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1159 +++ linux-2.6.37/drivers/cbus/lipocharge.h      2011-02-06 12:36:29.800830614 +0100
1160 @@ -0,0 +1,55 @@
1161 +#ifndef LIPOCHARGE_H_
1162 +#define LIPOCHARGE_H_
1163 +
1164 +#include <linux/timer.h>
1165 +#include <linux/spinlock.h>
1166 +
1167 +
1168 +#define LIPORATE(a,b)  (((a) * 1000) + (b))
1169 +#define LIPORATE_1C    LIPORATE(1,0)   /* 1C */
1170 +#define LIPORATE_p8C   LIPORATE(0,8)   /* 0.8C */
1171 +#define LIPORATE_p6C   LIPORATE(0,6)   /* 0.6C */
1172 +
1173 +/** struct lipocharge - A generic LIPO charger
1174 + *
1175 + * @capacity: Battery capacity in mAh.
1176 + * @rate: Charge rate.
1177 + * @top_voltage: Fully charged voltage, in mV.
1178 + *
1179 + * @set_charge_current: Set the charge current, in mA.
1180 + * @get_charge_current: Get the battery current, in signed mA.
1181 + * @get_voltage: Get the battery voltage, in mV.
1182 + *
1183 + * @finished: Charging finished.
1184 + * @emergency: Something went wrong. Force shutdown.
1185 + */
1186 +struct lipocharge {
1187 +       unsigned int capacity;
1188 +       unsigned int rate;
1189 +       unsigned int top_voltage;
1190 +
1191 +       int (*set_charge_current)(struct lipocharge *c, unsigned int ma);
1192 +       int (*get_charge_current)(struct lipocharge *c, int *ma);
1193 +       int (*get_voltage)(struct lipocharge *c, unsigned int *mv);
1194 +
1195 +       void (*finished)(struct lipocharge *c);
1196 +       void (*emergency)(struct lipocharge *c);
1197 +
1198 +       /* internal */
1199 +       spinlock_t lock;
1200 +       struct timer_list timer;
1201 +       bool charging;
1202 +};
1203 +
1204 +void lipocharge_init(struct lipocharge *c);
1205 +void lipocharge_exit(struct lipocharge *c);
1206 +
1207 +int lipocharge_start(struct lipocharge *c);
1208 +void lipocharge_stop(struct lipocharge *c);
1209 +
1210 +static inline bool lipocharge_is_charging(struct lipocharge *c)
1211 +{
1212 +       return c->charging;
1213 +}
1214 +
1215 +#endif /* LIPOCHARGE_H_ */
1216 Index: linux-2.6.37/drivers/cbus/tahvo.h
1217 ===================================================================
1218 --- linux-2.6.37.orig/drivers/cbus/tahvo.h      2011-02-06 00:24:48.494004810 +0100
1219 +++ linux-2.6.37/drivers/cbus/tahvo.h   2011-02-06 00:24:48.551008149 +0100
1220 @@ -30,17 +30,28 @@
1221  #define TAHVO_REG_IDR          0x01    /* Interrupt ID */
1222  #define TAHVO_REG_IDSR         0x02    /* Interrupt status */
1223  #define TAHVO_REG_IMR          0x03    /* Interrupt mask */
1224 +#define TAHVO_REG_CHGCURR      0x04    /* Charge current control PWM (8-bit) */
1225  #define TAHVO_REG_LEDPWMR      0x05    /* LED PWM */
1226  #define TAHVO_REG_USBR         0x06    /* USB control */
1227 +#define TAHVO_REG_CHGCTL       0x08    /* Charge control register */
1228 +#define  TAHVO_REG_CHGCTL_EN           0x0001  /* Global charge enable */
1229 +#define  TAHVO_REG_CHGCTL_PWMOVR       0x0004  /* PWM override. Force charge PWM to 100% duty cycle. */
1230 +#define  TAHVO_REG_CHGCTL_UNK8         0x0008  /* XXX: Unknown. Written on init. */
1231 +#define  TAHVO_REG_CHGCTL_CURMEAS      0x0040  /* Enable battery current measurement. */
1232 +#define  TAHVO_REG_CHGCTL_CURTIMRST    0x0080  /* Current measure timer reset. */
1233 +#define TAHVO_REG_BATCURRTIMER 0x0c    /* Battery current measure timer (8-bit) */
1234 +#define TAHVO_REG_BATCURR      0x0d    /* Battery (dis)charge current (signed 16-bit) */
1235 +
1236  #define TAHVO_REG_MAX          0x0d
1237
1238  /* Interrupt sources */
1239  #define TAHVO_INT_VBUSON       0
1240 +#define TAHVO_INT_BATCURR      7 /* Battery current measure timer */
1241
1242  #define MAX_TAHVO_IRQ_HANDLERS 8
1243
1244  int tahvo_read_reg(int reg);
1245 -void tahvo_write_reg(int reg, u16 val);
1246 +int tahvo_write_reg(int reg, u16 val);
1247  void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear);
1248  int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
1249  void tahvo_free_irq(int id);
1250 Index: linux-2.6.37/drivers/cbus/tahvo.c
1251 ===================================================================
1252 --- linux-2.6.37.orig/drivers/cbus/tahvo.c      2011-02-06 00:24:48.494004810 +0100
1253 +++ linux-2.6.37/drivers/cbus/tahvo.c   2011-02-06 00:24:48.552008207 +0100
1254 @@ -85,10 +85,10 @@
1255   *
1256   * This function writes a value to the specified register
1257   */
1258 -void tahvo_write_reg(int reg, u16 val)
1259 +int tahvo_write_reg(int reg, u16 val)
1260  {
1261         BUG_ON(!tahvo_initialized);
1262 -       cbus_write_reg(cbus_host, TAHVO_ID, reg, val);
1263 +       return cbus_write_reg(cbus_host, TAHVO_ID, reg, val);
1264  }
1265
1266  /**