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.1/drivers/cbus/Kconfig
  14 ===================================================================
  15 --- linux-2.6.37.1.orig/drivers/cbus/Kconfig    2011-02-19 20:26:01.282338290 +0100
  16 +++ linux-2.6.37.1/drivers/cbus/Kconfig 2011-02-19 20:26:01.526318768 +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.1/drivers/cbus/Makefile
  31 ===================================================================
  32 --- linux-2.6.37.1.orig/drivers/cbus/Makefile   2011-02-19 20:26:01.250340850 +0100
  33 +++ linux-2.6.37.1/drivers/cbus/Makefile        2011-02-19 20:26:01.526318768 +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.1/drivers/cbus/n810bm_main.c
  42 ===================================================================
  43 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  44 +++ linux-2.6.37.1/drivers/cbus/n810bm_main.c   2011-02-20 17:50:58.807801112 +0100
  45 @@ -0,0 +1,1583 @@
  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/mutex.h>
  73 +#include <linux/timer.h>
  74 +#include <linux/firmware.h>
  75 +#include <linux/bitops.h>
  76 +#include <linux/workqueue.h>
  77 +#include <linux/delay.h>
  78 +
  79 +#include "cbus.h"
  80 +#include "retu.h"
  81 +#include "tahvo.h"
  82 +#include "lipocharge.h"
  83 +
  84 +
  85 +#define N810BM_PMM_BLOCK_FILENAME      "n810-cal-bme-pmm.fw"
  86 +#define N810BM_PMM_BLOCK_SIZE          0x600
  87 +#define N810BM_PMM_GROUP_SIZE          0x200
  88 +#define N810BM_PMM_ELEM_SIZE           0x10
  89 +
  90 +#define N810BM_CHECK_INTERVAL          (HZ * 2)
  91 +#define N810BM_MIN_VOLTAGE_THRES       3200 /* Absolute minimum voltage threshold */
  92 +
  93 +
  94 +/* RETU_ADC_BSI
  95 + * The battery size indicator ADC measures the resistance between
  96 + * the battery BSI pin and ground. This is used to detect the battery
  97 + * capacity, as the BSI resistor is related to capacity.
  98 + *
  99 + * Manually measured lookup table.
 100 + * Hard to measure, thus not very accurate.
 101 + *
 102 + * Resistance  |  ADC value
 103 + * ========================
 104 + * 120k        |  0x3AC
 105 + * 110k        |  0x37C
 106 + * 100k        |  0x351
 107 + *  90k        |  0x329
 108 + */
 109 +
 110 +/* RETU_ADC_BATTVOLT
 111 + * Manually measured lookup table.
 112 + * Hard to measure, thus not very accurate.
 113 + *
 114 + * Voltage  |  ADC value
 115 + * =====================
 116 + * 2.80V    |  0x037
 117 + * 2.90V    |  0x05E
 118 + * 3.00V    |  0x090
 119 + * 3.10V    |  0x0A4
 120 + * 3.20V    |  0x0CC
 121 + * 3.30V    |  0x0EF
 122 + * 3.40V    |  0x115
 123 + * 3.50V    |  0x136
 124 + * 3.60V    |  0x15C
 125 + * 3.70V    |  0x187
 126 + * 3.80V    |  0x1A5
 127 + * 3.90V    |  0x1C9
 128 + * 4.00V    |  0x1ED
 129 + * 4.10V    |  0x212
 130 + * 4.20V    |  0x236
 131 + */
 132 +
 133 +
 134 +/* PMM block ADC IDs */
 135 +enum n810bm_pmm_adc_id {
 136 +       N810BM_PMM_ADC_BATVOLT          = 0x01, /* Battery voltage */
 137 +       N810BM_PMM_ADC_CHGVOLT          = 0x02, /* Charger voltage */
 138 +       N810BM_PMM_ADC_GND2             = 0x03, /* Ground 0V */
 139 +       N810BM_PMM_ADC_BSI              = 0x04, /* Battery size indicator */
 140 +       N810BM_PMM_ADC_BATTEMP          = 0x05, /* Battery temperature */
 141 +       N810BM_PMM_ADC_HEADSET          = 0x06, /* Headset detection */
 142 +       N810BM_PMM_ADC_HOOKDET          = 0x07, /* Hook detection */
 143 +       N810BM_PMM_ADC_LIGHTSENS        = 0x08, /* Light sensor */
 144 +       N810BM_PMM_ADC_BATCURR          = 0x0E, /* Battery current */
 145 +       N810BM_PMM_ADC_BKUPVOLT         = 0x13, /* Backup battery voltage */
 146 +       N810BM_PMM_ADC_LIGHTTEMP        = 0x14, /* Light sensor temperature */
 147 +       N810BM_PMM_ADC_RFGP             = 0x15, /* RF GP */
 148 +       N810BM_PMM_ADC_WBTX             = 0x16, /* Wideband TX detection */
 149 +       N810BM_PMM_ADC_RETUTEMP         = 0x17, /* RETU chip temperature */
 150 +       N810BM_PMM_ADC_0xFE             = 0xFE,
 151 +};
 152 +
 153 +struct n810bm_adc_calib {
 154 +       enum n810bm_pmm_adc_id id;
 155 +       u8 flags;
 156 +       u8 adc_groupnr;
 157 +       u32 field1;
 158 +       u32 field2;
 159 +       u16 field3;
 160 +       u16 field4;
 161 +};
 162 +
 163 +struct n810bm_calib {
 164 +       struct n810bm_adc_calib adc[25];
 165 +};
 166 +
 167 +enum n810bm_capacity {
 168 +       N810BM_CAP_UNKNOWN      = -1,
 169 +       N810BM_CAP_NONE         = 0,
 170 +       N810BM_CAP_1500MAH      = 1500, /* 1500 mAh battery */
 171 +};
 172 +
 173 +enum n810bm_notify_flags {
 174 +       N810BM_NOTIFY_battery_charging,
 175 +       N810BM_NOTIFY_charger_pwm,
 176 +};
 177 +
 178 +struct n810bm {
 179 +       bool battery_present;                   /* A battery is inserted */
 180 +       bool charger_present;                   /* The charger is connected */
 181 +       enum n810bm_capacity capacity;          /* The capacity of the inserted battery (if any) */
 182 +
 183 +       bool charger_enabled;                   /* Want to charge? */
 184 +       struct lipocharge charger;              /* Charger subsystem */
 185 +       unsigned int active_current_pwm;        /* Active value of TAHVO_REG_CHGCURR */
 186 +       int current_measure_enabled;            /* Current measure enable refcount */
 187 +
 188 +       struct platform_device *pdev;
 189 +       struct n810bm_calib calib;              /* Calibration data */
 190 +
 191 +       bool verbose_charge_log;                /* Verbose charge logging */
 192 +
 193 +       unsigned long notify_flags;
 194 +       struct work_struct notify_work;
 195 +       struct work_struct currmeas_irq_work;
 196 +       struct delayed_work periodic_check_work;
 197 +
 198 +       bool initialized;                       /* The hardware was initialized */
 199 +       struct mutex mutex;
 200 +};
 201 +
 202 +static void n810bm_notify_battery_charging(struct n810bm *bm);
 203 +static void n810bm_notify_charger_pwm(struct n810bm *bm);
 204 +
 205 +
 206 +static inline struct n810bm * device_to_n810bm(struct device *dev)
 207 +{
 208 +       struct platform_device *pdev = to_platform_device(dev);
 209 +       struct n810bm *bm = platform_get_drvdata(pdev);
 210 +
 211 +       return bm;
 212 +}
 213 +
 214 +static inline bool n810bm_known_battery_present(struct n810bm *bm)
 215 +{
 216 +       return bm->battery_present &&
 217 +              bm->capacity != N810BM_CAP_UNKNOWN &&
 218 +              bm->capacity != N810BM_CAP_NONE;
 219 +}
 220 +
 221 +static NORET_TYPE void n810bm_emergency(struct n810bm *bm, const char *message) ATTRIB_NORET;
 222 +static void n810bm_emergency(struct n810bm *bm, const char *message)
 223 +{
 224 +       printk(KERN_EMERG "n810 battery management fatal fault: %s\n", message);
 225 +       cbus_emergency();
 226 +}
 227 +
 228 +static u16 tahvo_read(struct n810bm *bm, unsigned int reg)
 229 +{
 230 +       int ret;
 231 +       unsigned long flags;
 232 +
 233 +       spin_lock_irqsave(&tahvo_lock, flags);
 234 +       ret = tahvo_read_reg(reg);
 235 +       spin_unlock_irqrestore(&tahvo_lock, flags);
 236 +       if (ret < 0 || ret > 0xFFFF)
 237 +               n810bm_emergency(bm, "tahvo_read");
 238 +
 239 +       return ret;
 240 +}
 241 +
 242 +static void tahvo_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set)
 243 +{
 244 +       int ret;
 245 +       unsigned long flags;
 246 +       u16 value;
 247 +
 248 +       spin_lock_irqsave(&tahvo_lock, flags);
 249 +       if (~mask) {
 250 +               ret = tahvo_read_reg(reg);
 251 +               if (ret < 0 || ret > 0xFFFF)
 252 +                       goto fatal_unlock;
 253 +               value = ret;
 254 +       } else
 255 +               value = 0;
 256 +       value &= ~mask;
 257 +       value |= set;
 258 +       ret = tahvo_write_reg(reg, value);
 259 +       if (ret)
 260 +               goto fatal_unlock;
 261 +       spin_unlock_irqrestore(&tahvo_lock, flags);
 262 +
 263 +       return;
 264 +
 265 +fatal_unlock:
 266 +       spin_unlock_irqrestore(&tahvo_lock, flags);
 267 +       n810bm_emergency(bm, "tahvo_maskset");
 268 +}
 269 +
 270 +static inline void tahvo_write(struct n810bm *bm, unsigned int reg, u16 value)
 271 +{
 272 +       tahvo_maskset(bm, reg, 0xFFFF, value);
 273 +}
 274 +
 275 +static inline void tahvo_set(struct n810bm *bm, unsigned int reg, u16 mask)
 276 +{
 277 +       tahvo_maskset(bm, reg, mask, mask);
 278 +}
 279 +
 280 +static inline void tahvo_clear(struct n810bm *bm, unsigned int reg, u16 mask)
 281 +{
 282 +       tahvo_maskset(bm, reg, mask, 0);
 283 +}
 284 +
 285 +static u16 retu_read(struct n810bm *bm, unsigned int reg)
 286 +{
 287 +       int ret;
 288 +       unsigned long flags;
 289 +
 290 +       spin_lock_irqsave(&retu_lock, flags);
 291 +       ret = retu_read_reg(reg);
 292 +       spin_unlock_irqrestore(&retu_lock, flags);
 293 +       if (ret < 0 || ret > 0xFFFF)
 294 +               n810bm_emergency(bm, "retu_read");
 295 +
 296 +       return ret;
 297 +}
 298 +
 299 +static void retu_maskset(struct n810bm *bm, unsigned int reg, u16 mask, u16 set)
 300 +{
 301 +       int ret;
 302 +       unsigned long flags;
 303 +       u16 value;
 304 +
 305 +       spin_lock_irqsave(&retu_lock, flags);
 306 +       if (~mask) {
 307 +               ret = retu_read_reg(reg);
 308 +               if (ret < 0 || ret > 0xFFFF)
 309 +                       goto fatal_unlock;
 310 +               value = ret;
 311 +       } else
 312 +               value = 0;
 313 +       value &= ~mask;
 314 +       value |= set;
 315 +       ret = retu_write_reg(reg, value);
 316 +       if (ret)
 317 +               goto fatal_unlock;
 318 +       spin_unlock_irqrestore(&retu_lock, flags);
 319 +
 320 +       return;
 321 +
 322 +fatal_unlock:
 323 +       spin_unlock_irqrestore(&retu_lock, flags);
 324 +       n810bm_emergency(bm, "retu_maskset");
 325 +}
 326 +
 327 +static inline void retu_write(struct n810bm *bm, unsigned int reg, u16 value)
 328 +{
 329 +       retu_maskset(bm, reg, 0xFFFF, value);
 330 +}
 331 +
 332 +static int retu_adc_average(struct n810bm *bm, unsigned int chan,
 333 +                           unsigned int nr_passes)
 334 +{
 335 +       unsigned int i, value = 0;
 336 +       int ret;
 337 +
 338 +       if (WARN_ON(!nr_passes))
 339 +               return 0;
 340 +       for (i = 0; i < nr_passes; i++) {
 341 +               ret = retu_read_adc(chan);
 342 +               if (ret < 0)
 343 +                       return ret;
 344 +               value += ret;
 345 +       }
 346 +       value /= nr_passes;
 347 +
 348 +       return value;
 349 +}
 350 +
 351 +static struct n810bm_adc_calib * n810bm_get_adc_calib(struct n810bm *bm,
 352 +                                               enum n810bm_pmm_adc_id id)
 353 +{
 354 +       unsigned int index = 0;
 355 +       struct n810bm_adc_calib *cal;
 356 +
 357 +       if (id != N810BM_PMM_ADC_0xFE)
 358 +               index = (unsigned int)id + 1;
 359 +       if (index >= ARRAY_SIZE(bm->calib.adc))
 360 +               return NULL;
 361 +
 362 +       cal = &bm->calib.adc[index];
 363 +       WARN_ON(cal->id && cal->id != id);
 364 +
 365 +       return cal;
 366 +}
 367 +
 368 +static int pmm_record_get(struct n810bm *bm,
 369 +                         const struct firmware *pmm_block,
 370 +                         void *buffer, size_t length,
 371 +                         unsigned int group, unsigned int element, unsigned int offset)
 372 +{
 373 +       const u8 *pmm_area = pmm_block->data;
 374 +       u8 active_group_mask;
 375 +
 376 +       if (pmm_block->size != N810BM_PMM_BLOCK_SIZE)
 377 +               return -EINVAL;
 378 +       if (group >= N810BM_PMM_BLOCK_SIZE / N810BM_PMM_GROUP_SIZE)
 379 +               return -EINVAL;
 380 +       if (element >= N810BM_PMM_GROUP_SIZE / N810BM_PMM_ELEM_SIZE)
 381 +               return -EINVAL;
 382 +       if (offset >= N810BM_PMM_ELEM_SIZE || length > N810BM_PMM_ELEM_SIZE ||
 383 +           length + offset > N810BM_PMM_ELEM_SIZE)
 384 +               return -EINVAL;
 385 +
 386 +       active_group_mask = pmm_area[16];
 387 +       if (!(active_group_mask & (1 << group))) {
 388 +               dev_dbg(&bm->pdev->dev, "pwm_record_get: Requested group %u, "
 389 +                       "but group is not active", group);
 390 +               return -ENOENT;
 391 +       }
 392 +
 393 +       memcpy(buffer,
 394 +              pmm_area + group * N810BM_PMM_GROUP_SIZE
 395 +                       + element * N810BM_PMM_ELEM_SIZE
 396 +                       + offset,
 397 +              length);
 398 +
 399 +       return 0;
 400 +}
 401 +
 402 +/* PMM block group 1 element */
 403 +struct group1_element {
 404 +       u8 id;
 405 +       u8 flags;
 406 +       u8 adc_groupnr;
 407 +       u8 _padding;
 408 +       __le32 field1;
 409 +       __le32 field2;
 410 +} __packed;
 411 +
 412 +static int extract_group1_elem(struct n810bm *bm,
 413 +                              const struct firmware *pmm_block,
 414 +                              const enum n810bm_pmm_adc_id *pmm_adc_ids, size_t nr_pmm_adc_ids,
 415 +                              u32 field1_mask, u32 field2_mask)
 416 +{
 417 +       struct group1_element elem;
 418 +       int err;
 419 +       unsigned int i, element_nr;
 420 +       struct n810bm_adc_calib *adc_calib;
 421 +
 422 +       for (i = 0; i < nr_pmm_adc_ids; i++) {
 423 +               element_nr = (unsigned int)(pmm_adc_ids[i]) + 3;
 424 +
 425 +               err = pmm_record_get(bm, pmm_block, &elem, sizeof(elem),
 426 +                                    1, element_nr, 0);
 427 +               if (err)
 428 +                       continue;
 429 +               adc_calib = n810bm_get_adc_calib(bm, elem.id);
 430 +               if (!adc_calib) {
 431 +                       dev_err(&bm->pdev->dev, "extract_group1_elem: "
 432 +                               "Could not get calib element for 0x%02X",
 433 +                               elem.id);
 434 +                       return -EINVAL;
 435 +               }
 436 +
 437 +               if (adc_calib->flags == elem.flags) {
 438 +                       adc_calib->field1 = le32_to_cpu(elem.field1) & field1_mask;
 439 +                       adc_calib->field2 = le32_to_cpu(elem.field2) & field2_mask;
 440 +               } else {
 441 +                       dev_dbg(&bm->pdev->dev, "extract_group1_elem: "
 442 +                               "Not extracting fields due to flags mismatch: "
 443 +                               "0x%02X vs 0x%02X",
 444 +                               adc_calib->flags, elem.flags);
 445 +               }
 446 +       }
 447 +
 448 +       return 0;
 449 +}
 450 +
 451 +static int n810bm_parse_pmm_group1(struct n810bm *bm,
 452 +                                  const struct firmware *pmm_block)
 453 +{
 454 +       struct n810bm_adc_calib *adc_calib;
 455 +       struct group1_element elem;
 456 +       int err;
 457 +
 458 +       static const enum n810bm_pmm_adc_id pmm_adc_ids_1[] = {
 459 +               N810BM_PMM_ADC_BATVOLT,
 460 +               N810BM_PMM_ADC_CHGVOLT,
 461 +               N810BM_PMM_ADC_BKUPVOLT,
 462 +               N810BM_PMM_ADC_BATCURR,
 463 +       };
 464 +       static const enum n810bm_pmm_adc_id pmm_adc_ids_2[] = {
 465 +               N810BM_PMM_ADC_BSI,
 466 +       };
 467 +       static const enum n810bm_pmm_adc_id pmm_adc_ids_3[] = {
 468 +               N810BM_PMM_ADC_BATTEMP,
 469 +       };
 470 +
 471 +       /* Parse element 2 */
 472 +       err = pmm_record_get(bm, pmm_block, &elem, sizeof(elem),
 473 +                            1, 2, 0);
 474 +       if (err) {
 475 +               dev_err(&bm->pdev->dev,
 476 +                       "PMM: Failed to get group 1 / element 2");
 477 +               return err;
 478 +       }
 479 +       if (elem.id == N810BM_PMM_ADC_0xFE && elem.flags == 0x05) {
 480 +               adc_calib = n810bm_get_adc_calib(bm, elem.id);
 481 +               if (!adc_calib) {
 482 +                       dev_err(&bm->pdev->dev,
 483 +                               "calib extract: Failed to get 0xFE calib");
 484 +                       return -EINVAL;
 485 +               }
 486 +               adc_calib->id = elem.id;
 487 +               adc_calib->flags = elem.flags;
 488 +               adc_calib->field1 = le32_to_cpu(elem.field1);
 489 +               adc_calib->field2 = le32_to_cpu(elem.field2);
 490 +       }
 491 +
 492 +       err = extract_group1_elem(bm, pmm_block,
 493 +                                 pmm_adc_ids_1, ARRAY_SIZE(pmm_adc_ids_1),
 494 +                                 0xFFFFFFFF, 0xFFFFFFFF);
 495 +       if (err)
 496 +               return err;
 497 +       err = extract_group1_elem(bm, pmm_block,
 498 +                                 pmm_adc_ids_2, ARRAY_SIZE(pmm_adc_ids_2),
 499 +                                 0xFFFFFFFF, 0);
 500 +       if (err)
 501 +               return err;
 502 +       err = extract_group1_elem(bm, pmm_block,
 503 +                                 pmm_adc_ids_3, ARRAY_SIZE(pmm_adc_ids_3),
 504 +                                 0xFFFFFFFF, 0x0000FFFF);
 505 +       if (err)
 506 +               return err;
 507 +
 508 +       return 0;
 509 +}
 510 +
 511 +static int n810bm_parse_pmm_group2(struct n810bm *bm,
 512 +                                  const struct firmware *pmm_block)
 513 +{
 514 +       dev_err(&bm->pdev->dev, "TODO: CAL BME PMM group 2 parser not implemented, yet");
 515 +       return -EOPNOTSUPP;
 516 +}
 517 +
 518 +static void n810bm_adc_calib_set_defaults(struct n810bm *bm)
 519 +{
 520 +       struct n810bm_adc_calib *adc_calib;
 521 +       unsigned int i;
 522 +
 523 +       static const struct n810bm_adc_calib defaults[] = {
 524 +               /* ADC group-nr 0 */
 525 +               {
 526 +                       .id             = N810BM_PMM_ADC_HEADSET,
 527 +                       .flags          = 0x00,
 528 +                       .adc_groupnr    = 0,
 529 +               }, {
 530 +                       .id             = N810BM_PMM_ADC_HOOKDET,
 531 +                       .flags          = 0x00,
 532 +                       .adc_groupnr    = 0,
 533 +               }, {
 534 +                       .id             = N810BM_PMM_ADC_RFGP,
 535 +                       .flags          = 0x00,
 536 +                       .adc_groupnr    = 0,
 537 +               }, {
 538 +                       .id             = N810BM_PMM_ADC_LIGHTSENS,
 539 +                       .flags          = 0x00,
 540 +                       .adc_groupnr    = 0,
 541 +               }, {
 542 +                       .id             = N810BM_PMM_ADC_WBTX,
 543 +                       .flags          = 0x00,
 544 +                       .adc_groupnr    = 0,
 545 +               }, {
 546 +                       .id             = N810BM_PMM_ADC_RETUTEMP,
 547 +                       .flags          = 0x00,
 548 +                       .adc_groupnr    = 0,
 549 +               }, {
 550 +                       .id             = N810BM_PMM_ADC_GND2,
 551 +                       .flags          = 0x00,
 552 +                       .adc_groupnr    = 0,
 553 +               },
 554 +               /* ADC group-nr 1 */
 555 +               {
 556 +                       .id             = N810BM_PMM_ADC_0xFE,
 557 +                       .flags          = 0x05,
 558 +                       .adc_groupnr    = 1,
 559 +                       .field1         = (u32)-2,
 560 +                       .field2         = 13189,
 561 +               }, {
 562 +                       .id             = N810BM_PMM_ADC_BATVOLT,
 563 +                       .flags          = 0x01,
 564 +                       .adc_groupnr    = 1,
 565 +                       .field1         = 2527,
 566 +                       .field2         = 21373,
 567 +               }, {
 568 +                       .id             = N810BM_PMM_ADC_CHGVOLT,
 569 +                       .flags          = 0x01,
 570 +                       .adc_groupnr    = 1,
 571 +                       .field1         = 0,
 572 +                       .field2         = 129848,
 573 +               }, {
 574 +                       .id             = N810BM_PMM_ADC_BKUPVOLT,
 575 +                       .flags          = 0x01,
 576 +                       .adc_groupnr    = 1,
 577 +                       .field1         = 0,
 578 +                       .field2         = 20000,
 579 +               }, {
 580 +                       .id             = N810BM_PMM_ADC_BATCURR,
 581 +                       .flags          = 0x06,
 582 +                       .adc_groupnr    = 1,
 583 +                       .field1         = 0,
 584 +                       .field2         = 9660,
 585 +               },
 586 +               /* ADC group-nr 2 */
 587 +               {
 588 +                       .id             = N810BM_PMM_ADC_BSI,
 589 +                       .flags          = 0x02,
 590 +                       .adc_groupnr    = 2,
 591 +                       .field1         = 1169,
 592 +                       .field2         = 0,
 593 +               },
 594 +               /* ADC group-nr 3 */
 595 +               {
 596 +                       .id             = N810BM_PMM_ADC_BATTEMP,
 597 +                       .flags          = 0x03,
 598 +                       .adc_groupnr    = 3,
 599 +                       .field1         = 265423000,
 600 +                       .field2         = 298,
 601 +               },
 602 +               /* ADC group-nr 4 */
 603 +               {
 604 +                       .id             = N810BM_PMM_ADC_LIGHTTEMP,
 605 +                       .flags          = 0x04,
 606 +                       .adc_groupnr    = 4,
 607 +                       .field1         = 19533778,
 608 +                       .field2         = 308019670,
 609 +                       .field3         = 4700,
 610 +                       .field4         = 2500,
 611 +               },
 612 +       };
 613 +
 614 +       /* Clear the array */
 615 +       memset(&bm->calib.adc, 0, sizeof(bm->calib.adc));
 616 +       for (i = 0; i < ARRAY_SIZE(bm->calib.adc); i++)
 617 +               bm->calib.adc[i].flags = 0xFF;
 618 +
 619 +       /* Copy the defaults */
 620 +       for (i = 0; i < ARRAY_SIZE(defaults); i++) {
 621 +               adc_calib = n810bm_get_adc_calib(bm, defaults[i].id);
 622 +               if (WARN_ON(!adc_calib))
 623 +                       continue;
 624 +               *adc_calib = defaults[i];
 625 +       }
 626 +}
 627 +
 628 +static int n810bm_parse_pmm_block(struct n810bm *bm,
 629 +                                 const struct firmware *pmm_block)
 630 +{
 631 +       u8 byte;
 632 +       int err;
 633 +       unsigned int i, count;
 634 +       struct n810bm_adc_calib *adc_calib;
 635 +
 636 +       /* Initialize to defaults */
 637 +       n810bm_adc_calib_set_defaults(bm);
 638 +
 639 +       /* Parse the PMM data */
 640 +       err = pmm_record_get(bm, pmm_block, &byte, sizeof(byte),
 641 +                            1, 0, 0); /* group 1 / element 0 */
 642 +       err |= (byte != 0x01);
 643 +       err |= pmm_record_get(bm, pmm_block, &byte, sizeof(byte),
 644 +                             1, 1, 0); /* group 1 / element 1 */
 645 +       err |= (byte != 0x01);
 646 +       if (err)
 647 +               err = n810bm_parse_pmm_group2(bm, pmm_block);
 648 +       else
 649 +               err = n810bm_parse_pmm_group1(bm, pmm_block);
 650 +       if (err)
 651 +               return err;
 652 +
 653 +       /* Sanity checks */
 654 +       for (i = 0, count = 0; i < ARRAY_SIZE(bm->calib.adc); i++) {
 655 +               adc_calib = &bm->calib.adc[i];
 656 +               if (adc_calib->flags == 0xFF)
 657 +                       continue;
 658 +               switch (adc_calib->id) {
 659 +               case N810BM_PMM_ADC_BATVOLT:
 660 +                       if (adc_calib->field1 < 2400 ||
 661 +                           adc_calib->field1 > 2700)
 662 +                               goto value_check_fail;
 663 +                       if (adc_calib->field2 < 20000 ||
 664 +                           adc_calib->field2 > 23000)
 665 +                               goto value_check_fail;
 666 +                       count++;
 667 +                       break;
 668 +               case N810BM_PMM_ADC_BSI:
 669 +                       if (adc_calib->field1 < 1100 ||
 670 +                           adc_calib->field1 > 1300)
 671 +                               goto value_check_fail;
 672 +                       count++;
 673 +                       break;
 674 +               case N810BM_PMM_ADC_BATCURR:
 675 +                       if (adc_calib->field2 < 7000 ||
 676 +                           adc_calib->field2 > 12000)
 677 +                               goto value_check_fail;
 678 +                       count++;
 679 +                       break;
 680 +               case N810BM_PMM_ADC_0xFE:
 681 +                       if ((s32)adc_calib->field1 > 14 ||
 682 +                           (s32)adc_calib->field1 < -14)
 683 +                               goto value_check_fail;
 684 +                       if (adc_calib->field2 < 13000 ||
 685 +                           adc_calib->field2 > 13350)
 686 +                               goto value_check_fail;
 687 +                       count++;
 688 +                       break;
 689 +               case N810BM_PMM_ADC_CHGVOLT:
 690 +               case N810BM_PMM_ADC_BATTEMP:
 691 +               case N810BM_PMM_ADC_BKUPVOLT:
 692 +                       count++;
 693 +                       break;
 694 +               case N810BM_PMM_ADC_GND2:
 695 +               case N810BM_PMM_ADC_HOOKDET:
 696 +               case N810BM_PMM_ADC_LIGHTSENS:
 697 +               case N810BM_PMM_ADC_HEADSET:
 698 +               case N810BM_PMM_ADC_LIGHTTEMP:
 699 +               case N810BM_PMM_ADC_RFGP:
 700 +               case N810BM_PMM_ADC_WBTX:
 701 +               case N810BM_PMM_ADC_RETUTEMP:
 702 +                       break;
 703 +               }
 704 +               dev_dbg(&bm->pdev->dev,
 705 +                       "ADC 0x%02X calib: 0x%02X 0x%02X 0x%08X 0x%08X 0x%04X 0x%04X",
 706 +                       adc_calib->id, adc_calib->flags, adc_calib->adc_groupnr,
 707 +                       adc_calib->field1, adc_calib->field2,
 708 +                       adc_calib->field3, adc_calib->field4);
 709 +       }
 710 +       if (count != 7) {
 711 +               dev_err(&bm->pdev->dev, "PMM sanity check: Did not find "
 712 +                       "all required values (count=%u)", count);
 713 +               goto check_fail;
 714 +       }
 715 +
 716 +       return 0;
 717 +
 718 +value_check_fail:
 719 +       dev_err(&bm->pdev->dev, "PMM image sanity check failed "
 720 +               "(id=%02X, field1=%08X, field2=%08X)",
 721 +               adc_calib->id, adc_calib->field1, adc_calib->field2);
 722 +check_fail:
 723 +       return -EILSEQ;
 724 +}
 725 +
 726 +/* Set the current measure timer that triggers on Tahvo IRQ 7
 727 + * An interval of zero disables the timer. */
 728 +static void n810bm_set_current_measure_timer(struct n810bm *bm,
 729 +                                            u16 millisec_interval)
 730 +{
 731 +       u16 value = millisec_interval;
 732 +
 733 +       if (value <= 0xF905) {
 734 +               value = ((u64)0x10624DD3 * (u64)(value + 0xF9)) >> 32;
 735 +               value /= 16;
 736 +       } else
 737 +               value = 0xFF;
 738 +
 739 +       tahvo_write(bm, TAHVO_REG_BATCURRTIMER, value & 0xFF);
 740 +
 741 +       tahvo_set(bm, TAHVO_REG_CHGCTL,
 742 +                 TAHVO_REG_CHGCTL_CURTIMRST);
 743 +       tahvo_clear(bm, TAHVO_REG_CHGCTL,
 744 +                   TAHVO_REG_CHGCTL_CURTIMRST);
 745 +
 746 +       if (millisec_interval)
 747 +               tahvo_enable_irq(TAHVO_INT_BATCURR);
 748 +       else
 749 +               tahvo_disable_irq(TAHVO_INT_BATCURR);
 750 +
 751 +       //TODO also do a software timer for safety.
 752 +}
 753 +
 754 +static void n810bm_enable_current_measure(struct n810bm *bm)
 755 +{
 756 +       WARN_ON(bm->current_measure_enabled < 0);
 757 +       if (!bm->current_measure_enabled) {
 758 +               /* Enable the current measurement circuitry */
 759 +               tahvo_set(bm, TAHVO_REG_CHGCTL,
 760 +                         TAHVO_REG_CHGCTL_CURMEAS);
 761 +               dev_dbg(&bm->pdev->dev,
 762 +                       "Current measurement circuitry enabled");
 763 +       }
 764 +       bm->current_measure_enabled++;
 765 +}
 766 +
 767 +static void n810bm_disable_current_measure(struct n810bm *bm)
 768 +{
 769 +       bm->current_measure_enabled--;
 770 +       WARN_ON(bm->current_measure_enabled < 0);
 771 +       if (!bm->current_measure_enabled) {
 772 +               /* Disable the current measurement circuitry */
 773 +               tahvo_clear(bm, TAHVO_REG_CHGCTL,
 774 +                           TAHVO_REG_CHGCTL_CURMEAS);
 775 +               dev_dbg(&bm->pdev->dev,
 776 +                       "Current measurement circuitry disabled");
 777 +       }
 778 +}
 779 +
 780 +/* Measure the actual battery current. Returns a signed value in mA.
 781 + * Does only work, if current measurement was enabled. */
 782 +static int n810bm_measure_batt_current(struct n810bm *bm)
 783 +{
 784 +       u16 retval;
 785 +       int adc = 0, ma, i;
 786 +
 787 +       if (WARN_ON(bm->current_measure_enabled <= 0))
 788 +               return 0;
 789 +       for (i = 0; i < 3; i++) {
 790 +               retval = tahvo_read(bm, TAHVO_REG_BATCURR);
 791 +               adc += (s16)retval; /* Value is signed */
 792 +       }
 793 +       adc /= 3;
 794 +
 795 +       //TODO convert to mA
 796 +       ma = adc;
 797 +
 798 +       return ma;
 799 +}
 800 +
 801 +/* Requires bm->mutex locked */
 802 +static int n810bm_measure_batt_current_async(struct n810bm *bm)
 803 +{
 804 +       int ma;
 805 +       bool charging = lipocharge_is_charging(&bm->charger);
 806 +
 807 +       n810bm_enable_current_measure(bm);
 808 +       if (!charging)
 809 +               WARN_ON(bm->active_current_pwm != 0);
 810 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
 811 +                     TAHVO_REG_CHGCTL_EN |
 812 +                     TAHVO_REG_CHGCTL_PWMOVR |
 813 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
 814 +                     TAHVO_REG_CHGCTL_EN |
 815 +                     TAHVO_REG_CHGCTL_PWMOVR |
 816 +                     (charging ? 0 : TAHVO_REG_CHGCTL_PWMOVRZERO));
 817 +       ma = n810bm_measure_batt_current(bm);
 818 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
 819 +                     TAHVO_REG_CHGCTL_EN |
 820 +                     TAHVO_REG_CHGCTL_PWMOVR |
 821 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
 822 +                     (charging ? TAHVO_REG_CHGCTL_EN : 0));
 823 +       n810bm_disable_current_measure(bm);
 824 +
 825 +       return ma;
 826 +}
 827 +
 828 +static int adc_sanity_check(struct n810bm *bm, unsigned int channel)
 829 +{
 830 +       int value;
 831 +
 832 +       value = retu_read_adc(channel);
 833 +       if (value < 0) {
 834 +               dev_err(&bm->pdev->dev, "Failed to read GND ADC channel %u",
 835 +                       channel);
 836 +               return -EIO;
 837 +       }
 838 +       dev_dbg(&bm->pdev->dev,
 839 +               "GND ADC channel %u sanity check got value: %d",
 840 +               channel, value);
 841 +       if (value > 5) {
 842 +               n810bm_emergency(bm, "GND ADC sanity check failed");
 843 +               return -EIO;
 844 +       }
 845 +
 846 +       return 0;
 847 +}
 848 +
 849 +static int n810bm_check_adc_sanity(struct n810bm *bm)
 850 +{
 851 +       int err;
 852 +
 853 +       /* Discard one conversion */
 854 +       retu_write(bm, RETU_REG_ADCSCR, 0);
 855 +       retu_read_adc(RETU_ADC_GND2);
 856 +
 857 +       err = adc_sanity_check(bm, RETU_ADC_GND2);
 858 +       if (err)
 859 +               return err;
 860 +
 861 +       return 0;
 862 +}
 863 +
 864 +/* Measure the battery voltage. Returns the value in mV (or negative value on error). */
 865 +static int n810bm_measure_batt_voltage(struct n810bm *bm)
 866 +{
 867 +       int adc;
 868 +       unsigned int mv;
 869 +       const unsigned int scale = 1000;
 870 +
 871 +       adc = retu_adc_average(bm, RETU_ADC_BATTVOLT, 5);
 872 +       if (adc < 0)
 873 +               return adc;
 874 +       if (adc <= 0x37)
 875 +               return 2800;
 876 +       mv = 2800 + ((adc - 0x37) * (((4200 - 2800) * scale) / (0x236 - 0x37))) / scale;
 877 +
 878 +       //TODO compensate for power consumption
 879 +       //TODO honor calibration values
 880 +
 881 +       return mv;
 882 +}
 883 +
 884 +/* Measure the charger voltage. Returns the value in mV (or negative value on error). */
 885 +static int n810bm_measure_charger_voltage(struct n810bm *bm)
 886 +{
 887 +       int adc;
 888 +       unsigned int mv;
 889 +
 890 +       adc = retu_adc_average(bm, RETU_ADC_CHGVOLT, 5);
 891 +       if (adc < 0)
 892 +               return adc;
 893 +       //TODO convert to mV
 894 +       mv = adc;
 895 +
 896 +       return mv;
 897 +}
 898 +
 899 +/* Measure backup battery voltage. Returns the value in mV (or negative value on error). */
 900 +static int n810bm_measure_backup_batt_voltage(struct n810bm *bm)
 901 +{
 902 +       int adc;
 903 +       unsigned int mv;
 904 +
 905 +       adc = retu_adc_average(bm, RETU_ADC_BKUPVOLT, 3);
 906 +       if (adc < 0)
 907 +               return adc;
 908 +       //TODO convert to mV
 909 +       mv = adc;
 910 +
 911 +       return mv;
 912 +}
 913 +
 914 +/* Measure the battery temperature. Returns the value in K (or negative value on error). */
 915 +static int n810bm_measure_batt_temp(struct n810bm *bm)
 916 +{
 917 +       int adc;
 918 +       unsigned int k;
 919 +
 920 +       adc = retu_adc_average(bm, RETU_ADC_BATTEMP, 3);
 921 +       if (adc < 0)
 922 +               return adc;
 923 +       //TODO convert to K
 924 +       k = adc;
 925 +
 926 +       return k;
 927 +}
 928 +
 929 +/* Read the battery capacity via BSI pin. */
 930 +static enum n810bm_capacity n810bm_read_batt_capacity(struct n810bm *bm)
 931 +{
 932 +       int adc;
 933 +       const unsigned int hyst = 20;
 934 +
 935 +       adc = retu_adc_average(bm, RETU_ADC_BSI, 5);
 936 +       if (adc < 0) {
 937 +               dev_err(&bm->pdev->dev, "Failed to read BSI ADC");
 938 +               return N810BM_CAP_UNKNOWN;
 939 +       }
 940 +
 941 +       if (adc >= 0x3B5 - hyst && adc <= 0x3B5 + hyst)
 942 +               return N810BM_CAP_1500MAH;
 943 +
 944 +       dev_err(&bm->pdev->dev, "Capacity indicator 0x%X unknown", adc);
 945 +
 946 +       return N810BM_CAP_UNKNOWN;
 947 +}
 948 +
 949 +/* Convert a battery voltage (in mV) to percentage. */
 950 +static unsigned int n810bm_mvolt2percent(unsigned int mv)
 951 +{
 952 +       const unsigned int minv = 3700;
 953 +       const unsigned int maxv = 4150;
 954 +       unsigned int percent;
 955 +
 956 +       mv = clamp(mv, minv, maxv);
 957 +       percent = (mv - minv) * 100 / (maxv - minv);
 958 +
 959 +       return percent;
 960 +}
 961 +
 962 +static void n810bm_start_charge(struct n810bm *bm)
 963 +{
 964 +       int err;
 965 +
 966 +       WARN_ON(!bm->battery_present);
 967 +       WARN_ON(!bm->charger_present);
 968 +
 969 +       /* Set PWM to zero */
 970 +       bm->active_current_pwm = 0;
 971 +       tahvo_write(bm, TAHVO_REG_CHGCURR, bm->active_current_pwm);
 972 +
 973 +       /* Charge global enable */
 974 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
 975 +                     TAHVO_REG_CHGCTL_EN |
 976 +                     TAHVO_REG_CHGCTL_PWMOVR |
 977 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
 978 +                     TAHVO_REG_CHGCTL_EN);
 979 +
 980 +       WARN_ON((int)bm->capacity <= 0);
 981 +       bm->charger.capacity = bm->capacity;
 982 +       err = lipocharge_start(&bm->charger);
 983 +       WARN_ON(err);
 984 +
 985 +       /* Initialize current measurement circuitry */
 986 +       n810bm_enable_current_measure(bm);
 987 +       n810bm_set_current_measure_timer(bm, 250);
 988 +
 989 +       dev_info(&bm->pdev->dev, "Charging battery");
 990 +       n810bm_notify_charger_pwm(bm);
 991 +       n810bm_notify_battery_charging(bm);
 992 +}
 993 +
 994 +static void n810bm_stop_charge(struct n810bm *bm)
 995 +{
 996 +       if (lipocharge_is_charging(&bm->charger)) {
 997 +               n810bm_set_current_measure_timer(bm, 0);
 998 +               n810bm_disable_current_measure(bm);
 999 +       }
1000 +       lipocharge_stop(&bm->charger);
1001 +
1002 +       /* Set PWM to zero */
1003 +       bm->active_current_pwm = 0;
1004 +       tahvo_write(bm, TAHVO_REG_CHGCURR, bm->active_current_pwm);
1005 +
1006 +       /* Charge global disable */
1007 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
1008 +                     TAHVO_REG_CHGCTL_EN |
1009 +                     TAHVO_REG_CHGCTL_PWMOVR |
1010 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
1011 +                     0);
1012 +
1013 +       dev_info(&bm->pdev->dev, "Not charging battery");
1014 +       n810bm_notify_charger_pwm(bm);
1015 +       n810bm_notify_battery_charging(bm);
1016 +}
1017 +
1018 +/* Periodic check */
1019 +static void n810bm_periodic_check_work(struct work_struct *work)
1020 +{
1021 +       struct n810bm *bm = container_of(to_delayed_work(work),
1022 +                                        struct n810bm, periodic_check_work);
1023 +       u16 status;
1024 +       bool battery_was_present, charger_was_present;
1025 +       int mv;
1026 +
1027 +       mutex_lock(&bm->mutex);
1028 +
1029 +       status = retu_read(bm, RETU_REG_STATUS);
1030 +       battery_was_present = bm->battery_present;
1031 +       charger_was_present = bm->charger_present;
1032 +       bm->battery_present = !!(status & RETU_REG_STATUS_BATAVAIL);
1033 +       bm->charger_present = !!(status & RETU_REG_STATUS_CHGPLUG);
1034 +
1035 +       if (bm->battery_present != battery_was_present) {
1036 +               /* Battery state changed */
1037 +               if (bm->battery_present) {
1038 +                       bm->capacity = n810bm_read_batt_capacity(bm);
1039 +                       if (bm->capacity == N810BM_CAP_UNKNOWN) {
1040 +                               dev_err(&bm->pdev->dev, "Unknown battery detected");
1041 +                       } else {
1042 +                               dev_info(&bm->pdev->dev, "Detected %u mAh battery",
1043 +                                        (unsigned int)bm->capacity);
1044 +                       }
1045 +               } else {
1046 +                       bm->capacity = N810BM_CAP_NONE;
1047 +                       dev_info(&bm->pdev->dev, "The main battery was removed");
1048 +                       //TODO disable charging
1049 +               }
1050 +       }
1051 +
1052 +       if (bm->charger_present != charger_was_present) {
1053 +               /* Charger state changed */
1054 +               dev_info(&bm->pdev->dev, "The charger was %s",
1055 +                        bm->charger_present ? "plugged in" : "removed");
1056 +       }
1057 +
1058 +       if ((bm->battery_present && !bm->charger_present) ||
1059 +           !n810bm_known_battery_present(bm)){
1060 +               /* We're draining the battery */
1061 +               mv = n810bm_measure_batt_voltage(bm);
1062 +               if (mv < 0) {
1063 +                       n810bm_emergency(bm,
1064 +                               "check: Failed to measure voltage");
1065 +               }
1066 +               if (mv < N810BM_MIN_VOLTAGE_THRES) {
1067 +                       n810bm_emergency(bm,
1068 +                               "check: Minimum voltage threshold reached");
1069 +               }
1070 +       }
1071 +
1072 +       if (bm->charger_present && n810bm_known_battery_present(bm)) {
1073 +               /* Known battery and charger are connected */
1074 +               if (bm->charger_enabled) {
1075 +                       /* Charger is enabled */
1076 +                       if (!lipocharge_is_charging(&bm->charger)) {
1077 +                               //TODO start charging, if battery is below some threshold
1078 +                               n810bm_start_charge(bm);
1079 +                       }
1080 +               }
1081 +       }
1082 +
1083 +       if (lipocharge_is_charging(&bm->charger) && !bm->charger_present) {
1084 +               /* Charger was unplugged. */
1085 +               n810bm_stop_charge(bm);
1086 +       }
1087 +
1088 +       mutex_unlock(&bm->mutex);
1089 +       schedule_delayed_work(&bm->periodic_check_work,
1090 +                             round_jiffies_relative(N810BM_CHECK_INTERVAL));
1091 +}
1092 +
1093 +static void n810bm_adc_irq_handler(unsigned long data)
1094 +{
1095 +       struct n810bm *bm = (struct n810bm *)data;
1096 +
1097 +       retu_ack_irq(RETU_INT_ADCS);
1098 +       //TODO
1099 +dev_info(&bm->pdev->dev, "ADC interrupt triggered\n");
1100 +}
1101 +
1102 +static void n810bm_tahvo_current_measure_work(struct work_struct *work)
1103 +{
1104 +       struct n810bm *bm = container_of(work, struct n810bm, currmeas_irq_work);
1105 +       int res, ma, mv, temp;
1106 +
1107 +       mutex_lock(&bm->mutex);
1108 +       if (!lipocharge_is_charging(&bm->charger))
1109 +               goto out_unlock;
1110 +
1111 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
1112 +                     TAHVO_REG_CHGCTL_PWMOVR |
1113 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
1114 +                     TAHVO_REG_CHGCTL_PWMOVR);
1115 +       ma = n810bm_measure_batt_current(bm);
1116 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
1117 +                     TAHVO_REG_CHGCTL_PWMOVR |
1118 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
1119 +                     TAHVO_REG_CHGCTL_PWMOVR |
1120 +                     TAHVO_REG_CHGCTL_PWMOVRZERO);
1121 +       msleep(10);
1122 +       mv = n810bm_measure_batt_voltage(bm);
1123 +       tahvo_maskset(bm, TAHVO_REG_CHGCTL,
1124 +                     TAHVO_REG_CHGCTL_PWMOVR |
1125 +                     TAHVO_REG_CHGCTL_PWMOVRZERO,
1126 +                     0);
1127 +       temp = n810bm_measure_batt_temp(bm);
1128 +       if (WARN_ON(mv < 0))
1129 +               goto out_unlock;
1130 +       if (WARN_ON(temp < 0))
1131 +               goto out_unlock;
1132 +
1133 +       if (bm->verbose_charge_log) {
1134 +               dev_info(&bm->pdev->dev,
1135 +                        "Battery charge state: %d mV, %d mA (%s)",
1136 +                        mv, ma,
1137 +                        (ma <= 0) ? "discharging" : "charging");
1138 +       }
1139 +       res = lipocharge_update_state(&bm->charger, mv, ma, temp);
1140 +       if (res) {
1141 +               if (res > 0)
1142 +                       dev_info(&bm->pdev->dev, "Battery fully charged");
1143 +               n810bm_stop_charge(bm);
1144 +       }
1145 +out_unlock:
1146 +       mutex_unlock(&bm->mutex);
1147 +}
1148 +
1149 +static void n810bm_tahvo_current_measure_irq_handler(unsigned long data)
1150 +{
1151 +       struct n810bm *bm = (struct n810bm *)data;
1152 +
1153 +       tahvo_ack_irq(TAHVO_INT_BATCURR);
1154 +       schedule_work(&bm->currmeas_irq_work);
1155 +}
1156 +
1157 +#define DEFINE_ATTR_NOTIFY(attr_name)                                          \
1158 +       void n810bm_notify_##attr_name(struct n810bm *bm)                       \
1159 +       {                                                                       \
1160 +               set_bit(N810BM_NOTIFY_##attr_name, &bm->notify_flags);          \
1161 +               wmb();                                                          \
1162 +               schedule_work(&bm->notify_work);                                \
1163 +       }
1164 +
1165 +#define DEFINE_SHOW_INT_FUNC(name, member)                                     \
1166 +       static ssize_t n810bm_attr_##name##_show(struct device *dev,            \
1167 +                                                struct device_attribute *attr, \
1168 +                                                char *buf)                     \
1169 +       {                                                                       \
1170 +               struct n810bm *bm = device_to_n810bm(dev);                      \
1171 +               ssize_t count;                                                  \
1172 +                                                                               \
1173 +               mutex_lock(&bm->mutex);                                         \
1174 +               count = snprintf(buf, PAGE_SIZE, "%d\n", (int)(bm->member));    \
1175 +               mutex_unlock(&bm->mutex);                                       \
1176 +                                                                               \
1177 +               return count;                                                   \
1178 +       }
1179 +
1180 +#define DEFINE_STORE_INT_FUNC(name, member)                                    \
1181 +       static ssize_t n810bm_attr_##name##_store(struct device *dev,           \
1182 +                                                 struct device_attribute *attr,\
1183 +                                                 const char *buf, size_t count)\
1184 +       {                                                                       \
1185 +               struct n810bm *bm = device_to_n810bm(dev);                      \
1186 +               long val;                                                       \
1187 +               int err;                                                        \
1188 +                                                                               \
1189 +               mutex_lock(&bm->mutex);                                         \
1190 +               err = strict_strtol(buf, 0, &val);                              \
1191 +               if (!err)                                                       \
1192 +                       bm->member = (typeof(bm->member))val;                   \
1193 +               mutex_unlock(&bm->mutex);                                       \
1194 +                                                                               \
1195 +               return err ? err : count;                                       \
1196 +       }
1197 +
1198 +#define DEFINE_ATTR_SHOW_INT(name, member)                                     \
1199 +       DEFINE_SHOW_INT_FUNC(name, member)                                      \
1200 +       static DEVICE_ATTR(name, S_IRUGO,                                       \
1201 +                          n810bm_attr_##name##_show, NULL);
1202 +
1203 +#define DEFINE_ATTR_SHOW_STORE_INT(name, member)                               \
1204 +       DEFINE_SHOW_INT_FUNC(name, member)                                      \
1205 +       DEFINE_STORE_INT_FUNC(name, member)                                     \
1206 +       static DEVICE_ATTR(name, S_IRUGO | S_IWUSR,                             \
1207 +                          n810bm_attr_##name##_show,                           \
1208 +                          n810bm_attr_##name##_store);
1209 +
1210 +DEFINE_ATTR_SHOW_INT(battery_present, battery_present);
1211 +DEFINE_ATTR_SHOW_INT(charger_present, charger_present);
1212 +DEFINE_ATTR_SHOW_INT(charger_pwm, active_current_pwm);
1213 +static DEFINE_ATTR_NOTIFY(charger_pwm);
1214 +DEFINE_ATTR_SHOW_STORE_INT(charger_enable, charger_enabled);
1215 +DEFINE_ATTR_SHOW_STORE_INT(charger_verbose, verbose_charge_log);
1216 +
1217 +static ssize_t n810bm_attr_battery_charging(struct device *dev,
1218 +                                           struct device_attribute *attr,
1219 +                                           char *buf)
1220 +{
1221 +       struct n810bm *bm = device_to_n810bm(dev);
1222 +       ssize_t count;
1223 +
1224 +       mutex_lock(&bm->mutex);
1225 +       count = snprintf(buf, PAGE_SIZE, "%d\n",
1226 +                        (int)lipocharge_is_charging(&bm->charger));
1227 +       mutex_unlock(&bm->mutex);
1228 +
1229 +       return count;
1230 +}
1231 +static DEVICE_ATTR(battery_charging, S_IRUGO,
1232 +                  n810bm_attr_battery_charging, NULL);
1233 +static DEFINE_ATTR_NOTIFY(battery_charging);
1234 +
1235 +static ssize_t n810bm_attr_battery_level_show(struct device *dev,
1236 +                                             struct device_attribute *attr,
1237 +                                             char *buf)
1238 +{
1239 +       struct n810bm *bm = device_to_n810bm(dev);
1240 +       ssize_t count = -ENODEV;
1241 +       int millivolt;
1242 +
1243 +       mutex_lock(&bm->mutex);
1244 +       if (!bm->battery_present || lipocharge_is_charging(&bm->charger))
1245 +               millivolt = 0;
1246 +       else
1247 +               millivolt = n810bm_measure_batt_voltage(bm);
1248 +       if (millivolt >= 0) {
1249 +               count = snprintf(buf, PAGE_SIZE, "%u\n",
1250 +                                n810bm_mvolt2percent(millivolt));
1251 +       }
1252 +       mutex_unlock(&bm->mutex);
1253 +
1254 +       return count;
1255 +}
1256 +static DEVICE_ATTR(battery_level, S_IRUGO,
1257 +                  n810bm_attr_battery_level_show, NULL);
1258 +
1259 +static ssize_t n810bm_attr_battery_capacity_show(struct device *dev,
1260 +                                                struct device_attribute *attr,
1261 +                                                char *buf)
1262 +{
1263 +       struct n810bm *bm = device_to_n810bm(dev);
1264 +       ssize_t count;
1265 +       int capacity = 0;
1266 +
1267 +       mutex_lock(&bm->mutex);
1268 +       if (n810bm_known_battery_present(bm))
1269 +               capacity = (int)bm->capacity;
1270 +       count = snprintf(buf, PAGE_SIZE, "%d\n", capacity);
1271 +       mutex_unlock(&bm->mutex);
1272 +
1273 +       return count;
1274 +}
1275 +static DEVICE_ATTR(battery_capacity, S_IRUGO,
1276 +                  n810bm_attr_battery_capacity_show, NULL);
1277 +
1278 +static ssize_t n810bm_attr_battery_temp_show(struct device *dev,
1279 +                                            struct device_attribute *attr,
1280 +                                            char *buf)
1281 +{
1282 +       struct n810bm *bm = device_to_n810bm(dev);
1283 +       ssize_t count = -ENODEV;
1284 +       int k;
1285 +
1286 +       mutex_lock(&bm->mutex);
1287 +       k = n810bm_measure_batt_temp(bm);
1288 +       if (k >= 0)
1289 +               count = snprintf(buf, PAGE_SIZE, "%d\n", k);
1290 +       mutex_unlock(&bm->mutex);
1291 +
1292 +       return count;
1293 +}
1294 +static DEVICE_ATTR(battery_temp, S_IRUGO,
1295 +                  n810bm_attr_battery_temp_show, NULL);
1296 +
1297 +static ssize_t n810bm_attr_charger_voltage_show(struct device *dev,
1298 +                                               struct device_attribute *attr,
1299 +                                               char *buf)
1300 +{
1301 +       struct n810bm *bm = device_to_n810bm(dev);
1302 +       ssize_t count = -ENODEV;
1303 +       int mv = 0;
1304 +
1305 +       mutex_lock(&bm->mutex);
1306 +       if (bm->charger_present)
1307 +               mv = n810bm_measure_charger_voltage(bm);
1308 +       if (mv >= 0)
1309 +               count = snprintf(buf, PAGE_SIZE, "%d\n", mv);
1310 +       mutex_unlock(&bm->mutex);
1311 +
1312 +       return count;
1313 +}
1314 +static DEVICE_ATTR(charger_voltage, S_IRUGO,
1315 +                  n810bm_attr_charger_voltage_show, NULL);
1316 +
1317 +static ssize_t n810bm_attr_backup_battery_voltage_show(struct device *dev,
1318 +                                                      struct device_attribute *attr,
1319 +                                                      char *buf)
1320 +{
1321 +       struct n810bm *bm = device_to_n810bm(dev);
1322 +       ssize_t count = -ENODEV;
1323 +       int mv;
1324 +
1325 +       mutex_lock(&bm->mutex);
1326 +       mv = n810bm_measure_backup_batt_voltage(bm);
1327 +       if (mv >= 0)
1328 +               count = snprintf(buf, PAGE_SIZE, "%d\n", mv);
1329 +       mutex_unlock(&bm->mutex);
1330 +
1331 +       return count;
1332 +}
1333 +static DEVICE_ATTR(backup_battery_voltage, S_IRUGO,
1334 +                  n810bm_attr_backup_battery_voltage_show, NULL);
1335 +
1336 +static ssize_t n810bm_attr_battery_current_show(struct device *dev,
1337 +                                               struct device_attribute *attr,
1338 +                                               char *buf)
1339 +{
1340 +       struct n810bm *bm = device_to_n810bm(dev);
1341 +       ssize_t count = -ENODEV;
1342 +       int ma = 0;
1343 +
1344 +       mutex_lock(&bm->mutex);
1345 +       if (bm->battery_present)
1346 +               ma = n810bm_measure_batt_current_async(bm);
1347 +       count = snprintf(buf, PAGE_SIZE, "%d\n", ma);
1348 +       mutex_unlock(&bm->mutex);
1349 +
1350 +       return count;
1351 +}
1352 +static DEVICE_ATTR(battery_current, S_IRUGO,
1353 +                  n810bm_attr_battery_current_show, NULL);
1354 +
1355 +static const struct device_attribute *n810bm_attrs[] = {
1356 +       &dev_attr_battery_present,
1357 +       &dev_attr_battery_level,
1358 +       &dev_attr_battery_charging,
1359 +       &dev_attr_battery_current,
1360 +       &dev_attr_battery_capacity,
1361 +       &dev_attr_battery_temp,
1362 +       &dev_attr_backup_battery_voltage,
1363 +       &dev_attr_charger_present,
1364 +       &dev_attr_charger_verbose,
1365 +       &dev_attr_charger_voltage,
1366 +       &dev_attr_charger_enable,
1367 +       &dev_attr_charger_pwm,
1368 +};
1369 +
1370 +static void n810bm_notify_work(struct work_struct *work)
1371 +{
1372 +       struct n810bm *bm = container_of(work, struct n810bm, notify_work);
1373 +       unsigned long notify_flags;
1374 +
1375 +       notify_flags = xchg(&bm->notify_flags, 0);
1376 +       mb();
1377 +
1378 +#define do_notify(attr_name)                                           \
1379 +       do {                                                            \
1380 +               if (notify_flags & (1 << N810BM_NOTIFY_##attr_name)) {  \
1381 +                       sysfs_notify(&bm->pdev->dev.kobj, NULL,         \
1382 +                                    dev_attr_##attr_name.attr.name);   \
1383 +               }                                                       \
1384 +       } while (0)
1385 +
1386 +       do_notify(battery_charging);
1387 +       do_notify(charger_pwm);
1388 +}
1389 +
1390 +static int n810bm_charger_set_current_pwm(struct lipocharge *c,
1391 +                                         unsigned int duty_cycle)
1392 +{
1393 +       struct n810bm *bm = container_of(c, struct n810bm, charger);
1394 +       int err = -EINVAL;
1395 +
1396 +       WARN_ON(!mutex_is_locked(&bm->mutex));
1397 +       if (WARN_ON(duty_cycle > 0xFF))
1398 +               goto out;
1399 +       if (WARN_ON(!bm->charger_enabled))
1400 +               goto out;
1401 +       if (WARN_ON(!bm->battery_present || !bm->charger_present))
1402 +               goto out;
1403 +
1404 +       if (duty_cycle != bm->active_current_pwm) {
1405 +               bm->active_current_pwm = duty_cycle;
1406 +               tahvo_write(bm, TAHVO_REG_CHGCURR, duty_cycle);
1407 +               n810bm_notify_charger_pwm(bm);
1408 +       }
1409 +
1410 +       err = 0;
1411 +out:
1412 +
1413 +       return err;
1414 +}
1415 +
1416 +static void n810bm_charger_emergency(struct lipocharge *c)
1417 +{
1418 +       struct n810bm *bm = container_of(c, struct n810bm, charger);
1419 +
1420 +       n810bm_emergency(bm, "Battery charger fault");
1421 +}
1422 +
1423 +static void n810bm_hw_exit(struct n810bm *bm)
1424 +{
1425 +       n810bm_stop_charge(bm);
1426 +       retu_write(bm, RETU_REG_ADCSCR, 0);
1427 +}
1428 +
1429 +static int n810bm_hw_init(struct n810bm *bm)
1430 +{
1431 +       int err;
1432 +
1433 +       err = n810bm_check_adc_sanity(bm);
1434 +       if (err)
1435 +               return err;
1436 +
1437 +       n810bm_stop_charge(bm);
1438 +
1439 +       return 0;
1440 +}
1441 +
1442 +static void n810bm_cancel_and_flush_work(struct n810bm *bm)
1443 +{
1444 +       cancel_delayed_work_sync(&bm->periodic_check_work);
1445 +       cancel_work_sync(&bm->notify_work);
1446 +       cancel_work_sync(&bm->currmeas_irq_work);
1447 +       flush_scheduled_work();
1448 +}
1449 +
1450 +static int n810bm_device_init(struct n810bm *bm)
1451 +{
1452 +       int attr_index;
1453 +       int err;
1454 +
1455 +       bm->charger.rate = LIPORATE_p6C;
1456 +       bm->charger.top_voltage = 4100;
1457 +       bm->charger.duty_cycle_max = 0xFF;
1458 +       bm->charger.set_current_pwm = n810bm_charger_set_current_pwm;
1459 +       bm->charger.emergency = n810bm_charger_emergency;
1460 +       lipocharge_init(&bm->charger, &bm->pdev->dev);
1461 +
1462 +       err = n810bm_hw_init(bm);
1463 +       if (err)
1464 +               goto error;
1465 +       for (attr_index = 0; attr_index < ARRAY_SIZE(n810bm_attrs); attr_index++) {
1466 +               err = device_create_file(&bm->pdev->dev, n810bm_attrs[attr_index]);
1467 +               if (err)
1468 +                       goto err_unwind_attrs;
1469 +       }
1470 +       err = retu_request_irq(RETU_INT_ADCS,
1471 +                              n810bm_adc_irq_handler,
1472 +                              (unsigned long)bm, "n810bm");
1473 +       if (err)
1474 +               goto err_unwind_attrs;
1475 +       err = tahvo_request_irq(TAHVO_INT_BATCURR,
1476 +                               n810bm_tahvo_current_measure_irq_handler,
1477 +                               (unsigned long)bm, "n810bm");
1478 +       if (err)
1479 +               goto err_free_retu_irq;
1480 +       tahvo_disable_irq(TAHVO_INT_BATCURR);
1481 +
1482 +       schedule_delayed_work(&bm->periodic_check_work,
1483 +                             round_jiffies_relative(N810BM_CHECK_INTERVAL));
1484 +
1485 +       bm->initialized = 1;
1486 +       dev_info(&bm->pdev->dev, "Battery management initialized");
1487 +
1488 +       return 0;
1489 +
1490 +err_free_retu_irq:
1491 +       retu_free_irq(RETU_INT_ADCS);
1492 +err_unwind_attrs:
1493 +       for (attr_index--; attr_index >= 0; attr_index--)
1494 +               device_remove_file(&bm->pdev->dev, n810bm_attrs[attr_index]);
1495 +/*err_exit:*/
1496 +       n810bm_hw_exit(bm);
1497 +error:
1498 +       n810bm_cancel_and_flush_work(bm);
1499 +
1500 +       return err;
1501 +}
1502 +
1503 +static void n810bm_device_exit(struct n810bm *bm)
1504 +{
1505 +       int i;
1506 +
1507 +       if (!bm->initialized)
1508 +               return;
1509 +
1510 +       lipocharge_exit(&bm->charger);
1511 +       tahvo_free_irq(TAHVO_INT_BATCURR);
1512 +       retu_free_irq(RETU_INT_ADCS);
1513 +       for (i = 0; i < ARRAY_SIZE(n810bm_attrs); i++)
1514 +               device_remove_file(&bm->pdev->dev, n810bm_attrs[i]);
1515 +
1516 +       n810bm_cancel_and_flush_work(bm);
1517 +
1518 +       n810bm_hw_exit(bm);
1519 +
1520 +       bm->initialized = 0;
1521 +}
1522 +
1523 +static void n810bm_pmm_block_found(const struct firmware *fw, void *context)
1524 +{
1525 +       struct n810bm *bm = context;
1526 +       int err;
1527 +
1528 +       if (!fw) {
1529 +               dev_err(&bm->pdev->dev,
1530 +                       "CAL PMM block image file not found");
1531 +               goto err_release;
1532 +       }
1533 +       if (fw->size != N810BM_PMM_BLOCK_SIZE ||
1534 +           memcmp(fw->data, "BME-PMM-BLOCK01", 15) != 0) {
1535 +               dev_err(&bm->pdev->dev,
1536 +                       "CAL PMM block image file has an invalid format");
1537 +               goto err_release;
1538 +       }
1539 +
1540 +       err = n810bm_parse_pmm_block(bm, fw);
1541 +       if (err)
1542 +               goto err_release;
1543 +       release_firmware(fw);
1544 +
1545 +       err = n810bm_device_init(bm);
1546 +       if (err) {
1547 +               dev_err(&bm->pdev->dev,
1548 +                       "Failed to initialized battery management (%d)", err);
1549 +               goto error;
1550 +       }
1551 +
1552 +       return;
1553 +err_release:
1554 +       release_firmware(fw);
1555 +error:
1556 +       return;
1557 +}
1558 +
1559 +static int __devinit n810bm_probe(struct platform_device *pdev)
1560 +{
1561 +       struct n810bm *bm;
1562 +       int err;
1563 +
1564 +       bm = kzalloc(sizeof(*bm), GFP_KERNEL);
1565 +       if (!bm)
1566 +               return -ENOMEM;
1567 +       bm->pdev = pdev;
1568 +       platform_set_drvdata(pdev, bm);
1569 +       mutex_init(&bm->mutex);
1570 +       INIT_DELAYED_WORK(&bm->periodic_check_work, n810bm_periodic_check_work);
1571 +       INIT_WORK(&bm->notify_work, n810bm_notify_work);
1572 +       INIT_WORK(&bm->currmeas_irq_work, n810bm_tahvo_current_measure_work);
1573 +
1574 +       dev_info(&bm->pdev->dev, "Requesting CAL BME PMM block firmware file "
1575 +                N810BM_PMM_BLOCK_FILENAME);
1576 +       err = request_firmware_nowait(THIS_MODULE, 1,
1577 +                                     N810BM_PMM_BLOCK_FILENAME,
1578 +                                     &bm->pdev->dev, GFP_KERNEL,
1579 +                                     bm, n810bm_pmm_block_found);
1580 +       if (err) {
1581 +               dev_err(&bm->pdev->dev,
1582 +                       "Failed to request CAL PMM block image file (%d)", err);
1583 +               goto err_free;
1584 +       }
1585 +
1586 +       return 0;
1587 +
1588 +err_free:
1589 +       kfree(bm);
1590 +
1591 +       return err;
1592 +}
1593 +
1594 +static int __devexit n810bm_remove(struct platform_device *pdev)
1595 +{
1596 +       struct n810bm *bm = platform_get_drvdata(pdev);
1597 +
1598 +       n810bm_device_exit(bm);
1599 +
1600 +       kfree(bm);
1601 +       platform_set_drvdata(pdev, NULL);
1602 +
1603 +       return 0;
1604 +}
1605 +
1606 +static struct platform_driver n810bm_driver = {
1607 +       .remove         = __devexit_p(n810bm_remove),
1608 +       .driver         = {
1609 +               .name   = "n810bm",
1610 +       }
1611 +};
1612 +
1613 +static int __init n810bm_modinit(void)
1614 +{
1615 +       return platform_driver_probe(&n810bm_driver, n810bm_probe);
1616 +}
1617 +module_init(n810bm_modinit);
1618 +
1619 +static void __exit n810bm_modexit(void)
1620 +{
1621 +       platform_driver_unregister(&n810bm_driver);
1622 +}
1623 +module_exit(n810bm_modexit);
1624 +
1625 +MODULE_DESCRIPTION("Nokia n810 battery management");
1626 +MODULE_FIRMWARE(N810BM_PMM_BLOCK_FILENAME);
1627 +MODULE_LICENSE("GPL");
1628 +MODULE_AUTHOR("Michael Buesch");
1629 Index: linux-2.6.37.1/drivers/cbus/retu.c
1630 ===================================================================
1631 --- linux-2.6.37.1.orig/drivers/cbus/retu.c     2011-02-19 20:26:01.251340770 +0100
1632 +++ linux-2.6.37.1/drivers/cbus/retu.c  2011-02-19 20:26:01.529318528 +0100
1633 @@ -85,10 +85,10 @@
1634   *
1635   * This function writes a value to the specified register
1636   */
1637 -void retu_write_reg(int reg, u16 val)
1638 +int retu_write_reg(int reg, u16 val)
1639  {
1640         BUG_ON(!retu_initialized);
1641 -       cbus_write_reg(cbus_host, RETU_ID, reg, val);
1642 +       return cbus_write_reg(cbus_host, RETU_ID, reg, val);
1643  }
1644
1645  void retu_set_clear_reg_bits(int reg, u16 set, u16 clear)
1646 @@ -459,6 +459,7 @@
1647  EXPORT_SYMBOL(retu_ack_irq);
1648  EXPORT_SYMBOL(retu_read_reg);
1649  EXPORT_SYMBOL(retu_write_reg);
1650 +EXPORT_SYMBOL(retu_read_adc);
1651
1652  subsys_initcall(retu_init);
1653  module_exit(retu_exit);
1654 Index: linux-2.6.37.1/drivers/cbus/retu.h
1655 ===================================================================
1656 --- linux-2.6.37.1.orig/drivers/cbus/retu.h     2011-02-19 20:26:01.252340690 +0100
1657 +++ linux-2.6.37.1/drivers/cbus/retu.h  2011-02-19 20:26:01.530318448 +0100
1658 @@ -40,6 +40,8 @@
1659  #define RETU_REG_CTRL_CLR      0x0f    /* Regulator clear register */
1660  #define RETU_REG_CTRL_SET      0x10    /* Regulator set register */
1661  #define RETU_REG_STATUS                0x16    /* Status register */
1662 +#define  RETU_REG_STATUS_BATAVAIL      0x0100 /* Battery available */
1663 +#define  RETU_REG_STATUS_CHGPLUG       0x1000 /* Charger is plugged in */
1664  #define RETU_REG_WATCHDOG      0x17    /* Watchdog register */
1665  #define RETU_REG_AUDTXR                0x18    /* Audio Codec Tx register */
1666  #define RETU_REG_MAX           0x1f
1667 @@ -57,8 +59,25 @@
1668
1669  #define        MAX_RETU_IRQ_HANDLERS   16
1670
1671 +/* ADC channels */
1672 +#define RETU_ADC_GND           0x00 /* Ground */
1673 +#define RETU_ADC_BSI           0x01 /* Battery Size Indicator */
1674 +#define RETU_ADC_BATTEMP       0x02 /* Battery temperature */
1675 +#define RETU_ADC_CHGVOLT       0x03 /* Charger voltage */
1676 +#define RETU_ADC_HEADSET       0x04 /* Headset detection */
1677 +#define RETU_ADC_HOOKDET       0x05 /* Hook detection */
1678 +#define RETU_ADC_RFGP          0x06 /* RF GP */
1679 +#define RETU_ADC_WBTX          0x07 /* Wideband Tx detection */
1680 +#define RETU_ADC_BATTVOLT      0x08 /* Battery voltage measurement */
1681 +#define RETU_ADC_GND2          0x09 /* Ground */
1682 +#define RETU_ADC_LIGHTSENS     0x0A /* Light sensor */
1683 +#define RETU_ADC_LIGHTTEMP     0x0B /* Light sensor temperature */
1684 +#define RETU_ADC_BKUPVOLT      0x0C /* Backup battery voltage */
1685 +#define RETU_ADC_TEMP          0x0D /* RETU temperature */
1686 +
1687 +
1688  int retu_read_reg(int reg);
1689 -void retu_write_reg(int reg, u16 val);
1690 +int retu_write_reg(int reg, u16 val);
1691  void retu_set_clear_reg_bits(int reg, u16 set, u16 clear);
1692  int retu_read_adc(int channel);
1693  int retu_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
1694 Index: linux-2.6.37.1/arch/arm/mach-omap2/board-n8x0.c
1695 ===================================================================
1696 --- linux-2.6.37.1.orig/arch/arm/mach-omap2/board-n8x0.c        2011-02-19 20:26:01.201344770 +0100
1697 +++ linux-2.6.37.1/arch/arm/mach-omap2/board-n8x0.c     2011-02-19 20:26:01.531318368 +0100
1698 @@ -907,6 +907,17 @@
1699                                     ARRAY_SIZE(n8x0_gpio_switches));
1700  }
1701
1702 +static struct platform_device n810_bm_device = {
1703 +       .name           = "n810bm",
1704 +       .id             = -1,
1705 +};
1706 +
1707 +static void __init n810_bm_init(void)
1708 +{
1709 +       if (platform_device_register(&n810_bm_device))
1710 +               BUG();
1711 +}
1712 +
1713  static void __init n8x0_init_machine(void)
1714  {
1715         omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAC);
1716 @@ -933,6 +944,8 @@
1717         n8x0_onenand_init();
1718         n8x0_mmc_init();
1719         n8x0_usb_init();
1720 +
1721 +       n810_bm_init();
1722  }
1723
1724  MACHINE_START(NOKIA_N800, "Nokia N800")
1725 Index: linux-2.6.37.1/drivers/cbus/lipocharge.c
1726 ===================================================================
1727 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1728 +++ linux-2.6.37.1/drivers/cbus/lipocharge.c    2011-02-19 20:26:01.531318368 +0100
1729 @@ -0,0 +1,183 @@
1730 +/*
1731 + *   Generic LIPO battery charger
1732 + *
1733 + *   Copyright (c) 2010-2011 Michael Buesch <mb@bu3sch.de>
1734 + *
1735 + *   This program is free software; you can redistribute it and/or
1736 + *   modify it under the terms of the GNU General Public License
1737 + *   as published by the Free Software Foundation; either version 2
1738 + *   of the License, or (at your option) any later version.
1739 + *
1740 + *   This program is distributed in the hope that it will be useful,
1741 + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
1742 + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1743 + *   GNU General Public License for more details.
1744 + */
1745 +
1746 +#define DEBUG
1747 +
1748 +#include "lipocharge.h"
1749 +
1750 +#include <linux/slab.h>
1751 +
1752 +
1753 +/* Hysteresis constants */
1754 +#define CURRENT_HYST           30 /* mA */
1755 +#define VOLTAGE_HYST           10 /* mV */
1756 +
1757 +/* Threshold constants */
1758 +#define FINISH_CURRENT_PERCENT 3
1759 +
1760 +
1761 +/* Returns the requested first-stage charge current in mA */
1762 +static inline unsigned int get_stage1_charge_current(struct lipocharge *c)
1763 +{
1764 +       /* current = (capacity * C) */
1765 +       return c->capacity * c->rate / 1000;
1766 +}
1767 +
1768 +void lipocharge_init(struct lipocharge *c, struct device *dev)
1769 +{
1770 +       c->dev = dev;
1771 +       c->state = LIPO_IDLE;
1772 +}
1773 +
1774 +void lipocharge_exit(struct lipocharge *c)
1775 +{
1776 +       c->state = LIPO_IDLE;
1777 +}
1778 +
1779 +int lipocharge_start(struct lipocharge *c)
1780 +{
1781 +       int err;
1782 +
1783 +       if (c->state != LIPO_IDLE)
1784 +               return -EBUSY;
1785 +       if (!c->set_current_pwm || !c->emergency)
1786 +               return -EINVAL;
1787 +       if (!c->top_voltage || c->top_voltage > 4200)
1788 +               return -EINVAL;
1789 +
1790 +       c->active_duty_cycle = 0;
1791 +       err = c->set_current_pwm(c, c->active_duty_cycle);
1792 +       if (err)
1793 +               return err;
1794 +       c->state = LIPO_FIRST_STAGE;
1795 +
1796 +       return 0;
1797 +}
1798 +
1799 +void lipocharge_stop(struct lipocharge *c)
1800 +{
1801 +       if (c->state == LIPO_IDLE)
1802 +               return;
1803 +       c->state = LIPO_IDLE;
1804 +}
1805 +
1806 +static int lipocharge_increase_current(struct lipocharge *c,
1807 +                                      unsigned int inc_permille)
1808 +{
1809 +       int old_pwm, new_pwm;
1810 +
1811 +       if (c->active_duty_cycle >= c->duty_cycle_max)
1812 +               return 0;
1813 +
1814 +       old_pwm = c->active_duty_cycle;
1815 +       new_pwm = old_pwm + (c->duty_cycle_max * inc_permille / 1000);
1816 +       new_pwm = min(new_pwm, (int)c->duty_cycle_max);
1817 +       c->active_duty_cycle = new_pwm;
1818 +
1819 +       dev_dbg(c->dev, "lipo: Increasing duty_cycle by "
1820 +               "%u permille (0x%02X -> 0x%02X)",
1821 +               inc_permille, old_pwm, new_pwm);
1822 +
1823 +       return c->set_current_pwm(c, c->active_duty_cycle);
1824 +}
1825 +
1826 +static int lipocharge_decrease_current(struct lipocharge *c,
1827 +                                      unsigned int dec_permille)
1828 +{
1829 +       int old_pwm, new_pwm;
1830 +
1831 +       if (c->active_duty_cycle <= 0)
1832 +               return 0;
1833 +
1834 +       old_pwm = c->active_duty_cycle;
1835 +       new_pwm = old_pwm - (c->duty_cycle_max * dec_permille / 1000);
1836 +       new_pwm = max(0, new_pwm);
1837 +       c->active_duty_cycle = new_pwm;
1838 +
1839 +       dev_dbg(c->dev, "lipo: Decreasing duty_cycle by "
1840 +               "%u permille (0x%02X -> 0x%02X)",
1841 +               dec_permille, old_pwm, new_pwm);
1842 +
1843 +       return c->set_current_pwm(c, c->active_duty_cycle);
1844 +}
1845 +
1846 +/** lipocharge_update_state - Update the charge state
1847 + * @c: The context.
1848 + * @voltage_mV: The measured battery voltage.
1849 + * @current_mA: The measured charge current.
1850 + *             negative -> drain.
1851 + *             positive -> charge.
1852 + * @temp_K: Battery temperature in K.
1853 + *
1854 + * Returns 0 on success, -1 on error.
1855 + * Returns 1, if the charging process is finished.
1856 + */
1857 +int lipocharge_update_state(struct lipocharge *c,
1858 +                           unsigned int voltage_mV,
1859 +                           int current_mA,
1860 +                           unsigned int temp_K)
1861 +{
1862 +       int requested_current, current_diff;
1863 +       int err;
1864 +       unsigned int permille;
1865 +
1866 +       //TODO temp
1867 +
1868 +restart:
1869 +       switch (c->state) {
1870 +       case LIPO_IDLE:
1871 +               dev_err(c->dev, "%s: called while idle", __func__);
1872 +               return -EINVAL;
1873 +       case LIPO_FIRST_STAGE:  /* Constant current */
1874 +//printk("GOT %u %d %u\n", voltage_mV, current_mA, temp_K);
1875 +               if (voltage_mV >= c->top_voltage) {
1876 +                       /* Float voltage reached.
1877 +                        * Switch charger mode to "constant current" */
1878 +                       c->state = LIPO_SECOND_STAGE;
1879 +                       dev_dbg(c->dev, "Switched to second charging stage.");
1880 +                       goto restart;
1881 +               }
1882 +               /* Float voltage not reached, yet.
1883 +                * Try to get the requested constant current. */
1884 +               requested_current = get_stage1_charge_current(c);
1885 +               if (current_mA < 0)
1886 +                       current_mA = 0;
1887 +               current_diff = requested_current - current_mA;
1888 +               if (abs(requested_current - current_mA) > CURRENT_HYST) {
1889 +                       if (current_diff > 0) {
1890 +                               /* Increase current */
1891 +                               permille = current_diff * 1000 / requested_current;
1892 +                               permille /= 2;
1893 +                               err = lipocharge_increase_current(c, permille);
1894 +                               if (err)
1895 +                                       return err;
1896 +                       } else {
1897 +                               /* Decrease current */
1898 +                               permille = (-current_diff) * 1000 / requested_current;
1899 +                               permille /= 2;
1900 +                               err = lipocharge_decrease_current(c, permille);
1901 +                               if (err)
1902 +                                       return err;
1903 +                       }
1904 +               }
1905 +               break;
1906 +       case LIPO_SECOND_STAGE: /* Constant voltage */
1907 +               //TODO
1908 +               break;
1909 +       }
1910 +
1911 +       return 0;
1912 +}
1913 Index: linux-2.6.37.1/drivers/cbus/lipocharge.h
1914 ===================================================================
1915 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1916 +++ linux-2.6.37.1/drivers/cbus/lipocharge.h    2011-02-19 20:26:01.531318368 +0100
1917 @@ -0,0 +1,60 @@
1918 +#ifndef LIPOCHARGE_H_
1919 +#define LIPOCHARGE_H_
1920 +
1921 +#include <linux/types.h>
1922 +#include <linux/device.h>
1923 +
1924 +
1925 +#define LIPORATE(a,b)  (((a) * 1000) + ((b) * 100))
1926 +#define LIPORATE_p6C   LIPORATE(0,6)   /* 0.6C */
1927 +
1928 +enum lipocharge_state {
1929 +       LIPO_IDLE,              /* Not charging */
1930 +       LIPO_FIRST_STAGE,       /* Charging: constant current */
1931 +       LIPO_SECOND_STAGE,      /* Charging: constant voltage */
1932 +};
1933 +
1934 +/** struct lipocharge - A generic LIPO charger
1935 + *
1936 + * @capacity: Battery capacity in mAh.
1937 + * @rate: Charge rate.
1938 + * @top_voltage: Fully charged voltage, in mV.
1939 + * @duty_cycle_max: Max value for duty_cycle.
1940 + *
1941 + * @set_charge_current: Set the charge current PWM duty cycle.
1942 + * @emergency: Something went wrong. Force shutdown.
1943 + */
1944 +struct lipocharge {
1945 +       unsigned int capacity;
1946 +       unsigned int rate;
1947 +       unsigned int top_voltage;
1948 +       unsigned int duty_cycle_max;
1949 +
1950 +       int (*set_current_pwm)(struct lipocharge *c, unsigned int duty_cycle);
1951 +       void (*emergency)(struct lipocharge *c);
1952 +
1953 +       /* internal */
1954 +       struct device *dev;
1955 +       enum lipocharge_state state;
1956 +       unsigned int active_duty_cycle;
1957 +
1958 +       //TODO implement timer to cut power after maximum charge time.
1959 +};
1960 +
1961 +void lipocharge_init(struct lipocharge *c, struct device *dev);
1962 +void lipocharge_exit(struct lipocharge *c);
1963 +
1964 +int lipocharge_start(struct lipocharge *c);
1965 +void lipocharge_stop(struct lipocharge *c);
1966 +
1967 +int lipocharge_update_state(struct lipocharge *c,
1968 +                           unsigned int voltage_mV,
1969 +                           int current_mA,
1970 +                           unsigned int temp_K);
1971 +
1972 +static inline bool lipocharge_is_charging(struct lipocharge *c)
1973 +{
1974 +       return (c->state != LIPO_IDLE);
1975 +}
1976 +
1977 +#endif /* LIPOCHARGE_H_ */
1978 Index: linux-2.6.37.1/drivers/cbus/tahvo.h
1979 ===================================================================
1980 --- linux-2.6.37.1.orig/drivers/cbus/tahvo.h    2011-02-19 20:26:01.256340370 +0100
1981 +++ linux-2.6.37.1/drivers/cbus/tahvo.h 2011-02-19 20:26:01.532318288 +0100
1982 @@ -30,17 +30,28 @@
1983  #define TAHVO_REG_IDR          0x01    /* Interrupt ID */
1984  #define TAHVO_REG_IDSR         0x02    /* Interrupt status */
1985  #define TAHVO_REG_IMR          0x03    /* Interrupt mask */
1986 +#define TAHVO_REG_CHGCURR      0x04    /* Charge current control PWM (8-bit) */
1987  #define TAHVO_REG_LEDPWMR      0x05    /* LED PWM */
1988  #define TAHVO_REG_USBR         0x06    /* USB control */
1989 +#define TAHVO_REG_CHGCTL       0x08    /* Charge control register */
1990 +#define  TAHVO_REG_CHGCTL_EN           0x0001  /* Global charge enable */
1991 +#define  TAHVO_REG_CHGCTL_PWMOVR       0x0004  /* PWM override. Force charge PWM to 0%/100% duty cycle. */
1992 +#define  TAHVO_REG_CHGCTL_PWMOVRZERO   0x0008  /* If set, PWM override is 0% (If unset -> 100%) */
1993 +#define  TAHVO_REG_CHGCTL_CURMEAS      0x0040  /* Enable battery current measurement. */
1994 +#define  TAHVO_REG_CHGCTL_CURTIMRST    0x0080  /* Current measure timer reset. */
1995 +#define TAHVO_REG_BATCURRTIMER 0x0c    /* Battery current measure timer (8-bit) */
1996 +#define TAHVO_REG_BATCURR      0x0d    /* Battery (dis)charge current (signed 16-bit) */
1997 +
1998  #define TAHVO_REG_MAX          0x0d
1999
2000  /* Interrupt sources */
2001  #define TAHVO_INT_VBUSON       0
2002 +#define TAHVO_INT_BATCURR      7 /* Battery current measure timer */
2003
2004  #define MAX_TAHVO_IRQ_HANDLERS 8
2005
2006  int tahvo_read_reg(int reg);
2007 -void tahvo_write_reg(int reg, u16 val);
2008 +int tahvo_write_reg(int reg, u16 val);
2009  void tahvo_set_clear_reg_bits(int reg, u16 set, u16 clear);
2010  int tahvo_request_irq(int id, void *irq_handler, unsigned long arg, char *name);
2011  void tahvo_free_irq(int id);
2012 Index: linux-2.6.37.1/drivers/cbus/tahvo.c
2013 ===================================================================
2014 --- linux-2.6.37.1.orig/drivers/cbus/tahvo.c    2011-02-19 20:26:01.256340370 +0100
2015 +++ linux-2.6.37.1/drivers/cbus/tahvo.c 2011-02-19 20:26:01.532318288 +0100
2016 @@ -85,10 +85,10 @@
2017   *
2018   * This function writes a value to the specified register
2019   */
2020 -void tahvo_write_reg(int reg, u16 val)
2021 +int tahvo_write_reg(int reg, u16 val)
2022  {
2023         BUG_ON(!tahvo_initialized);
2024 -       cbus_write_reg(cbus_host, TAHVO_ID, reg, val);
2025 +       return cbus_write_reg(cbus_host, TAHVO_ID, reg, val);
2026  }
2027
2028  /**
2029 Index: linux-2.6.37.1/drivers/cbus/cbus.c
2030 ===================================================================
2031 --- linux-2.6.37.1.orig/drivers/cbus/cbus.c     2011-02-19 20:26:01.249340930 +0100
2032 +++ linux-2.6.37.1/drivers/cbus/cbus.c  2011-02-19 20:26:01.533318208 +0100
2033 @@ -31,6 +31,7 @@
2034  #include <linux/gpio.h>
2035  #include <linux/platform_device.h>
2036  #include <linux/slab.h>
2037 +#include <linux/reboot.h>
2038
2039  #include <asm/io.h>
2040  #include <asm/mach-types.h>
2041 @@ -301,6 +302,13 @@
2042  }
2043  module_exit(cbus_bus_exit);
2044
2045 +void cbus_emergency(void)
2046 +{
2047 +       machine_power_off();
2048 +       panic("cbus: Failed to halt machine in emergency state\n");
2049 +}
2050 +EXPORT_SYMBOL(cbus_emergency);
2051 +
2052  MODULE_DESCRIPTION("CBUS serial protocol");
2053  MODULE_LICENSE("GPL");
2054  MODULE_AUTHOR("Juha Yrjölä");
2055 Index: linux-2.6.37.1/drivers/cbus/cbus.h
2056 ===================================================================
2057 --- linux-2.6.37.1.orig/drivers/cbus/cbus.h     2011-02-19 20:26:01.250340850 +0100
2058 +++ linux-2.6.37.1/drivers/cbus/cbus.h  2011-02-19 20:26:01.533318208 +0100
2059 @@ -33,4 +33,6 @@
2060  extern int cbus_read_reg(struct cbus_host *host, int dev, int reg);
2061  extern int cbus_write_reg(struct cbus_host *host, int dev, int reg, u16 val);
2062
2063 +NORET_TYPE void cbus_emergency(void) ATTRIB_NORET;
2064 +
2065  #endif /* __DRIVERS_CBUS_CBUS_H */