target/linux/s3c24xx/patches/0049-bq27000-battery-driver.patch.patch

   1 From 2bab304b10f077cb88d5b5f5bd7e50c16aac2132 Mon Sep 17 00:00:00 2001
   2 From: mokopatches <mokopatches@openmoko.org>
   3 Date: Fri, 25 Jul 2008 22:21:23 +0100
   4 Subject: [PATCH] bq27000-battery-driver.patch
   5
   6 ---
   7  arch/arm/mach-s3c2440/Kconfig      |    2 +
   8  arch/arm/mach-s3c2440/mach-gta02.c |   21 ++
   9  drivers/power/Kconfig              |    7 +-
  10  drivers/power/Makefile             |    1 +
  11  drivers/power/bq27000_battery.c    |  375 ++++++++++++++++++++++++++++++++++++
  12  include/linux/bq27000_battery.h    |   12 ++
  13  6 files changed, 417 insertions(+), 1 deletions(-)
  14  create mode 100644 drivers/power/bq27000_battery.c
  15  create mode 100644 include/linux/bq27000_battery.h
  16
  17 diff --git a/arch/arm/mach-s3c2440/Kconfig b/arch/arm/mach-s3c2440/Kconfig
  18 index 3015aaf..b417f8e 100644
  19 --- a/arch/arm/mach-s3c2440/Kconfig
  20 +++ b/arch/arm/mach-s3c2440/Kconfig
  21 @@ -79,6 +79,8 @@ config MACH_NEO1973_GTA02
  22         bool "FIC Neo1973 GSM Phone (GTA02 Hardware)"
  23         select CPU_S3C2442
  24         select SENSORS_PCF50633
  25 +       select POWER_SUPPLY
  26 +       select GTA02_HDQ
  27         help
  28            Say Y here if you are using the FIC Neo1973 GSM Phone
  29
  30 diff --git a/arch/arm/mach-s3c2440/mach-gta02.c b/arch/arm/mach-s3c2440/mach-gta02.c
  31 index cea76e7..3816ea5 100644
  32 --- a/arch/arm/mach-s3c2440/mach-gta02.c
  33 +++ b/arch/arm/mach-s3c2440/mach-gta02.c
  34 @@ -81,6 +81,8 @@
  35
  36  #include <asm/arch/fiq_ipc_gta02.h>
  37  #include "fiq_c_isr.h"
  38 +#include <linux/gta02_hdq.h>
  39 +#include <linux/bq27000_battery.h>
  40
  41  /* arbitrates which sensor IRQ owns the shared SPI bus */
  42  static spinlock_t motion_irq_lock;
  43 @@ -583,6 +585,24 @@ struct platform_device gta02_hdq_device = {
  44  };
  45  #endif
  46
  47 +/* BQ27000 Battery */
  48 +
  49 +struct bq27000_platform_data bq27000_pdata = {
  50 +       .name = "bat",
  51 +       .rsense_mohms = 20,
  52 +       .hdq_read = gta02hdq_read,
  53 +       .hdq_write = gta02hdq_write,
  54 +       .hdq_initialized = gta02hdq_initialized,
  55 +};
  56 +
  57 +struct platform_device bq27000_battery_device = {
  58 +       .name           = "bq27000-battery",
  59 +       .dev = {
  60 +               .platform_data = &bq27000_pdata,
  61 +       },
  62 +};
  63 +
  64 +
  65  /* NOR Flash */
  66
  67  #define GTA02_FLASH_BASE       0x18000000 /* GCS3 */
  68 @@ -1271,6 +1291,7 @@ static void __init gta02_machine_init(void)
  69         case GTA02v5_SYSTEM_REV:
  70         case GTA02v6_SYSTEM_REV:
  71                 platform_device_register(&gta02_hdq_device);
  72 +               platform_device_register(&bq27000_battery_device);
  73                 break;
  74         default:
  75                 break;
  76 diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
  77 index 0a4515d..feb8b0a 100644
  78 --- a/drivers/power/Kconfig
  79 +++ b/drivers/power/Kconfig
  80 @@ -49,7 +49,10 @@ config BATTERY_OLPC
  81         help
  82           Say Y to enable support for the battery on the OLPC laptop.
  83
  84 -endif # POWER_SUPPLY
  85 +config BATTERY_BQ27000_HDQ
  86 +       tristate "BQ27000 HDQ battery monitor driver"
  87 +       help
  88 +         Say Y to enable support for the battery on the Neo Freerunner
  89
  90  config GTA02_HDQ
  91         tristate "Neo Freerunner HDQ"
  92 @@ -58,3 +61,5 @@ config GTA02_HDQ
  93           Say Y to enable support for communicating with an HDQ battery
  94           on the Neo Freerunner.  You probably want to select
  95           at least BATTERY_BQ27000_HDQ as well
  96 +
  97 +endif # POWER_SUPPLY
  98 diff --git a/drivers/power/Makefile b/drivers/power/Makefile
  99 index 88f227f..d7e87ad 100644
 100 --- a/drivers/power/Makefile
 101 +++ b/drivers/power/Makefile
 102 @@ -20,5 +20,6 @@ obj-$(CONFIG_APM_POWER)               += apm_power.o
 103  obj-$(CONFIG_BATTERY_DS2760)   += ds2760_battery.o
 104  obj-$(CONFIG_BATTERY_PMU)      += pmu_battery.o
 105  obj-$(CONFIG_BATTERY_OLPC)     += olpc_battery.o
 106 +obj-$(CONFIG_BATTERY_BQ27000_HDQ)      += bq27000_battery.o
 107
 108  obj-$(CONFIG_GTA02_HDQ)                += gta02_hdq.o
 109 diff --git a/drivers/power/bq27000_battery.c b/drivers/power/bq27000_battery.c
 110 new file mode 100644
 111 index 0000000..d19186a
 112 --- /dev/null
 113 +++ b/drivers/power/bq27000_battery.c
 114 @@ -0,0 +1,375 @@
 115 +/*
 116 + * Driver for batteries with bq27000 chips inside via HDQ
 117 + *
 118 + * Copyright 2008 Openmoko, Inc
 119 + * Andy Green <andy@openmoko.com>
 120 + *
 121 + * based on ds2760 driver, original copyright notice for that --->
 122 + *
 123 + * Copyright © 2007 Anton Vorontsov
 124 + *            2004-2007 Matt Reimer
 125 + *            2004 Szabolcs Gyurko
 126 + *
 127 + * Use consistent with the GNU GPL is permitted,
 128 + * provided that this copyright notice is
 129 + * preserved in its entirety in all copies and derived works.
 130 + *
 131 + * Author:  Anton Vorontsov <cbou@mail.ru>
 132 + *         February 2007
 133 + *
 134 + *         Matt Reimer <mreimer@vpop.net>
 135 + *         April 2004, 2005, 2007
 136 + *
 137 + *         Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
 138 + *         September 2004
 139 + */
 140 +
 141 +#include <linux/module.h>
 142 +#include <linux/param.h>
 143 +#include <linux/jiffies.h>
 144 +#include <linux/delay.h>
 145 +#include <linux/pm.h>
 146 +#include <linux/platform_device.h>
 147 +#include <linux/power_supply.h>
 148 +#include <linux/bq27000_battery.h>
 149 +
 150 +enum bq27000_regs {
 151 +       /* RAM regs */
 152 +               /* read-write after this */
 153 +       BQ27000_CTRL = 0, /* Device Control Register */
 154 +       BQ27000_MODE, /* Device Mode Register */
 155 +       BQ27000_AR_L, /* At-Rate H L */
 156 +       BQ27000_AR_H,
 157 +               /* read-only after this */
 158 +       BQ27000_ARTTE_L, /* At-Rate Time To Empty H L */
 159 +       BQ27000_ARTTE_H,
 160 +       BQ27000_TEMP_L, /* Reported Temperature H L */
 161 +       BQ27000_TEMP_H,
 162 +       BQ27000_VOLT_L, /* Reported Voltage H L */
 163 +       BQ27000_VOLT_H,
 164 +       BQ27000_FLAGS, /* Status Flags */
 165 +       BQ27000_RSOC, /* Relative State of Charge */
 166 +       BQ27000_NAC_L, /* Nominal Available Capacity H L */
 167 +       BQ27000_NAC_H,
 168 +       BQ27000_CACD_L, /* Discharge Compensated H L */
 169 +       BQ27000_CACD_H,
 170 +       BQ27000_CACT_L, /* Temperature Compensated H L */
 171 +       BQ27000_CACT_H,
 172 +       BQ27000_LMD_L, /* Last measured discharge H L */
 173 +       BQ27000_LMD_H,
 174 +       BQ27000_AI_L, /* Average Current H L */
 175 +       BQ27000_AI_H,
 176 +       BQ27000_TTE_L, /* Time to Empty H L */
 177 +       BQ27000_TTE_H,
 178 +       BQ27000_TTF_L, /* Time to Full H L */
 179 +       BQ27000_TTF_H,
 180 +       BQ27000_SI_L, /* Standby Current H L */
 181 +       BQ27000_SI_H,
 182 +       BQ27000_STTE_L, /* Standby Time To Empty H L */
 183 +       BQ27000_STTE_H,
 184 +       BQ27000_MLI_L, /* Max Load Current H L */
 185 +       BQ27000_MLI_H,
 186 +       BQ27000_MLTTE_L, /* Max Load Time To Empty H L */
 187 +       BQ27000_MLTTE_H,
 188 +       BQ27000_SAE_L, /* Available Energy H L */
 189 +       BQ27000_SAE_H,
 190 +       BQ27000_AP_L, /* Available Power H L */
 191 +       BQ27000_AP_H,
 192 +       BQ27000_TTECP_L, /* Time to Empty at Constant Power H L */
 193 +       BQ27000_TTECP_H,
 194 +       BQ27000_CYCL_L, /* Cycle count since learning cycle H L */
 195 +       BQ27000_CYCL_H,
 196 +       BQ27000_CYCT_L, /* Cycle Count Total H L */
 197 +       BQ27000_CYCT_H,
 198 +       BQ27000_CSOC, /* Compensated State Of Charge */
 199 +       /* EEPROM regs */
 200 +               /* read-write after this */
 201 +       BQ27000_EE_EE_EN = 0x6e, /* EEPROM Program Enable */
 202 +       BQ27000_EE_ILMD = 0x76, /* Initial Last Measured Discharge High Byte */
 203 +       BQ27000_EE_SEDVF, /* Scaled EDVF Threshold */
 204 +       BQ27000_EE_SEDV1, /* Scaled EDV1 Threshold */
 205 +       BQ27000_EE_ISLC, /* Initial Standby Load Current */
 206 +       BQ27000_EE_DMFSD, /* Digital Magnitude Filter and Self Discharge */
 207 +       BQ27000_EE_TAPER, /* Aging Estimate Enable, Charge Termination Taper */
 208 +       BQ27000_EE_PKCFG, /* Pack Configuration Values */
 209 +       BQ27000_EE_IMLC, /* Initial Max Load Current or ID #3 */
 210 +       BQ27000_EE_DCOMP, /* Discharge rate compensation constants or ID #2 */
 211 +       BQ27000_EE_TCOMP, /* Temperature Compensation constants or ID #1 */
 212 +};
 213 +
 214 +enum bq27000_status_flags {
 215 +       BQ27000_STATUS_CHGS = 0x80, /* 1 = being charged */
 216 +       BQ27000_STATUS_NOACT = 0x40, /* 1 = no activity */
 217 +       BQ27000_STATUS_IMIN = 0x20, /* 1 = Lion taper current mode */
 218 +       BQ27000_STATUS_CI = 0x10, /* 1 = capacity likely  innacurate */
 219 +       BQ27000_STATUS_CALIP = 0x08, /* 1 = calibration in progress */
 220 +       BQ27000_STATUS_VDQ = 0x04, /* 1 = capacity should be accurate */
 221 +       BQ27000_STATUS_EDV1 = 0x02, /* 1 = end of discharge.. <6% left */
 222 +       BQ27000_STATUS_EDVF = 0x01, /* 1 = no, it's really empty now */
 223 +};
 224 +
 225 +#define NANOVOLTS_UNIT 3750
 226 +
 227 +struct bq27000_device_info {
 228 +       struct device *dev;
 229 +       struct power_supply bat;
 230 +
 231 +       int rsense_mohms;               /* from platform */
 232 +
 233 +       int (*hdq_initialized)(void); /* from platform */
 234 +       int (*hdq_read)(int); /* from platform */
 235 +       int (*hdq_write)(int, u8); /* from platform */
 236 +};
 237 +
 238 +/*
 239 + * reading 16 bit values over HDQ has a special hazard where the
 240 + * hdq device firmware can update the 16-bit register during the time we
 241 + * read the two halves.  TI document SLUS556D recommends the algorithm here
 242 + * to avoid trouble
 243 + */
 244 +
 245 +static int hdq_read16(struct bq27000_device_info *di, int address)
 246 +{
 247 +       int acc;
 248 +       int high;
 249 +       int retries = 3;
 250 +
 251 +       while (retries--) {
 252 +
 253 +               high = (di->hdq_read)(address + 1); /* high part */
 254 +
 255 +               if (high < 0)
 256 +                       return high;
 257 +               acc = (di->hdq_read)(address);
 258 +               if (acc < 0)
 259 +                       return acc;
 260 +
 261 +               /* confirm high didn't change between reading it and low */
 262 +               if (high == (di->hdq_read)(address + 1))
 263 +                       return (high << 8) | acc;
 264 +       }
 265 +
 266 +       return -ETIME;
 267 +}
 268 +
 269 +#define to_bq27000_device_info(x) container_of((x), \
 270 +                                              struct bq27000_device_info, \
 271 +                                              bat);
 272 +
 273 +static void bq27000_battery_external_power_changed(struct power_supply *psy)
 274 +{
 275 +       struct bq27000_device_info *di = to_bq27000_device_info(psy);
 276 +
 277 +       dev_dbg(di->dev, "%s\n", __FUNCTION__);
 278 +}
 279 +
 280 +static int bq27000_battery_get_property(struct power_supply *psy,
 281 +                                      enum power_supply_property psp,
 282 +                                      union power_supply_propval *val)
 283 +{
 284 +       int v, n;
 285 +       struct bq27000_device_info *di = to_bq27000_device_info(psy);
 286 +
 287 +       if (!(di->hdq_initialized)())
 288 +               return -EINVAL;
 289 +
 290 +       switch (psp) {
 291 +       case POWER_SUPPLY_PROP_STATUS:
 292 +               val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 293 +               v = hdq_read16(di, BQ27000_AI_L);
 294 +               if (v < 0)
 295 +                       return v;
 296 +               if (v < 2) { /* no real activity on the battery */
 297 +                       if (!hdq_read16(di, BQ27000_TTF_L))
 298 +                               val->intval = POWER_SUPPLY_STATUS_FULL;
 299 +                       else
 300 +                               val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 301 +                       break;
 302 +               }
 303 +               /* power is actually going in or out... */
 304 +               v = (di->hdq_read)(BQ27000_FLAGS);
 305 +               if (v < 0)
 306 +                       return v;
 307 +               if (v & BQ27000_STATUS_CHGS)
 308 +                       val->intval = POWER_SUPPLY_STATUS_CHARGING;
 309 +               else
 310 +                       val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 311 +               break;
 312 +       case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 313 +               v = hdq_read16(di, BQ27000_VOLT_L);
 314 +               if (v < 0)
 315 +                       return v;
 316 +               val->intval = v * 1000; /* mV -> uV */
 317 +               break;
 318 +       case POWER_SUPPLY_PROP_CURRENT_NOW:
 319 +               v = (di->hdq_read)(BQ27000_FLAGS);
 320 +               if (v < 0)
 321 +                       return v;
 322 +               if (v & BQ27000_STATUS_CHGS)
 323 +                       n = -NANOVOLTS_UNIT;
 324 +               else
 325 +                       n = NANOVOLTS_UNIT;
 326 +               v = hdq_read16(di, BQ27000_AI_L);
 327 +               if (v < 0)
 328 +                       return v;
 329 +               val->intval = (v * n) / di->rsense_mohms;
 330 +               break;
 331 +       case POWER_SUPPLY_PROP_CHARGE_FULL:
 332 +               v = hdq_read16(di, BQ27000_LMD_L);
 333 +               if (v < 0)
 334 +                       return v;
 335 +               val->intval = (v * 3570) / di->rsense_mohms;
 336 +               break;
 337 +       case POWER_SUPPLY_PROP_TEMP:
 338 +               v = hdq_read16(di, BQ27000_TEMP_L);
 339 +               if (v < 0)
 340 +                       return v;
 341 +               /* K (in 0.25K units) is 273.15 up from C (in 0.1C)*/
 342 +               /* 10926 = 27315 * 4 / 10 */
 343 +               val->intval = (((long)v * 10l) - 10926) / 4;
 344 +               break;
 345 +       case POWER_SUPPLY_PROP_TECHNOLOGY:
 346 +               val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 347 +               break;
 348 +       case POWER_SUPPLY_PROP_CAPACITY:
 349 +               val->intval = (di->hdq_read)(BQ27000_RSOC);
 350 +               if (val->intval < 0)
 351 +                       return val->intval;
 352 +               break;
 353 +       case POWER_SUPPLY_PROP_PRESENT:
 354 +               v = (di->hdq_read)(BQ27000_RSOC);
 355 +               val->intval = !(v < 0);
 356 +               break;
 357 +       case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 358 +               v = hdq_read16(di, BQ27000_TTE_L);
 359 +               if (v < 0)
 360 +                       return v;
 361 +               val->intval = 60 * v;
 362 +               break;
 363 +       case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
 364 +               v = hdq_read16(di, BQ27000_TTF_L);
 365 +               if (v < 0)
 366 +                       return v;
 367 +               val->intval = 60 * v;
 368 +               break;
 369 +       default:
 370 +               return -EINVAL;
 371 +       }
 372 +
 373 +       return 0;
 374 +}
 375 +
 376 +static enum power_supply_property bq27000_battery_props[] = {
 377 +       POWER_SUPPLY_PROP_STATUS,
 378 +       POWER_SUPPLY_PROP_VOLTAGE_NOW,
 379 +       POWER_SUPPLY_PROP_CURRENT_NOW,
 380 +       POWER_SUPPLY_PROP_CHARGE_FULL,
 381 +       POWER_SUPPLY_PROP_TEMP,
 382 +       POWER_SUPPLY_PROP_TECHNOLOGY,
 383 +       POWER_SUPPLY_PROP_PRESENT,
 384 +       POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
 385 +       POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
 386 +       POWER_SUPPLY_PROP_MODEL_NAME,
 387 +       POWER_SUPPLY_PROP_CAPACITY
 388 +};
 389 +
 390 +static int bq27000_battery_probe(struct platform_device *pdev)
 391 +{
 392 +       int retval = 0;
 393 +       struct bq27000_device_info *di;
 394 +       struct bq27000_platform_data *pdata;
 395 +
 396 +       dev_info(&pdev->dev, "BQ27000 Battery Driver (C) 2008 Openmoko, Inc\n");
 397 +
 398 +       di = kzalloc(sizeof(*di), GFP_KERNEL);
 399 +       if (!di) {
 400 +               retval = -ENOMEM;
 401 +               goto di_alloc_failed;
 402 +       }
 403 +
 404 +       platform_set_drvdata(pdev, di);
 405 +
 406 +       pdata = pdev->dev.platform_data;
 407 +       di->dev         = &pdev->dev;
 408 +       /* di->w1_dev        = pdev->dev.parent; */
 409 +       di->bat.name       = pdata->name;
 410 +       di->bat.type       = POWER_SUPPLY_TYPE_BATTERY;
 411 +       di->bat.properties     = bq27000_battery_props;
 412 +       di->bat.num_properties = ARRAY_SIZE(bq27000_battery_props);
 413 +       di->bat.get_property   = bq27000_battery_get_property;
 414 +       di->bat.external_power_changed =
 415 +                                 bq27000_battery_external_power_changed;
 416 +       di->hdq_read = pdata->hdq_read;
 417 +       di->hdq_write = pdata->hdq_write;
 418 +       di->rsense_mohms = pdata->rsense_mohms;
 419 +       di->hdq_initialized = pdata->hdq_initialized;
 420 +
 421 +       retval = power_supply_register(&pdev->dev, &di->bat);
 422 +       if (retval) {
 423 +               dev_err(di->dev, "failed to register battery\n");
 424 +               goto batt_failed;
 425 +       }
 426 +
 427 +       return 0;
 428 +
 429 +batt_failed:
 430 +       kfree(di);
 431 +di_alloc_failed:
 432 +       return retval;
 433 +}
 434 +
 435 +static int bq27000_battery_remove(struct platform_device *pdev)
 436 +{
 437 +       struct bq27000_device_info *di = platform_get_drvdata(pdev);
 438 +
 439 +       power_supply_unregister(&di->bat);
 440 +
 441 +       return 0;
 442 +}
 443 +
 444 +#ifdef CONFIG_PM
 445 +
 446 +static int bq27000_battery_suspend(struct platform_device *pdev,
 447 +                                 pm_message_t state)
 448 +{
 449 +       return 0;
 450 +}
 451 +
 452 +static int bq27000_battery_resume(struct platform_device *pdev)
 453 +{
 454 +       return 0;
 455 +}
 456 +
 457 +#else
 458 +
 459 +#define bq27000_battery_suspend NULL
 460 +#define bq27000_battery_resume NULL
 461 +
 462 +#endif /* CONFIG_PM */
 463 +
 464 +static struct platform_driver bq27000_battery_driver = {
 465 +       .driver = {
 466 +               .name = "bq27000-battery",
 467 +       },
 468 +       .probe    = bq27000_battery_probe,
 469 +       .remove   = bq27000_battery_remove,
 470 +       .suspend  = bq27000_battery_suspend,
 471 +       .resume   = bq27000_battery_resume,
 472 +};
 473 +
 474 +static int __init bq27000_battery_init(void)
 475 +{
 476 +       return platform_driver_register(&bq27000_battery_driver);
 477 +}
 478 +
 479 +static void __exit bq27000_battery_exit(void)
 480 +{
 481 +       platform_driver_unregister(&bq27000_battery_driver);
 482 +}
 483 +
 484 +module_init(bq27000_battery_init);
 485 +module_exit(bq27000_battery_exit);
 486 +
 487 +MODULE_LICENSE("GPL");
 488 +MODULE_AUTHOR("Andy Green <andy@openmoko.com>");
 489 +MODULE_DESCRIPTION("bq27000 battery driver");
 490 diff --git a/include/linux/bq27000_battery.h b/include/linux/bq27000_battery.h
 491 new file mode 100644
 492 index 0000000..36b4f20
 493 --- /dev/null
 494 +++ b/include/linux/bq27000_battery.h
 495 @@ -0,0 +1,12 @@
 496 +#ifndef __BQ27000_BATTERY_H__
 497 +#define __BQ27000_BATTERY_H__
 498 +
 499 +struct bq27000_platform_data {
 500 +       const char      *name;
 501 +       int             rsense_mohms;
 502 +       int (*hdq_read)(int);
 503 +       int (*hdq_write)(int, u8);
 504 +       int (*hdq_initialized)(void);
 505 +};
 506 +
 507 +#endif
 508 --
 509 1.5.6.3
 510