target/linux/s3c24xx/files-2.6.30/drivers/power/bq27000_battery.c

   1 /*
   2  * Driver for batteries with bq27000 chips inside via HDQ
   3  *
   4  * Copyright 2008 Openmoko, Inc
   5  * Andy Green <andy@openmoko.com>
   6  *
   7  * based on ds2760 driver, original copyright notice for that --->
   8  *
   9  * Copyright © 2007 Anton Vorontsov
  10  *             2004-2007 Matt Reimer
  11  *             2004 Szabolcs Gyurko
  12  *
  13  * Use consistent with the GNU GPL is permitted,
  14  * provided that this copyright notice is
  15  * preserved in its entirety in all copies and derived works.
  16  *
  17  * Author:  Anton Vorontsov <cbou@mail.ru>
  18  *          February 2007
  19  *
  20  *          Matt Reimer <mreimer@vpop.net>
  21  *          April 2004, 2005, 2007
  22  *
  23  *          Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
  24  *          September 2004
  25  */
  26
  27 #include <linux/module.h>
  28 #include <linux/param.h>
  29 #include <linux/jiffies.h>
  30 #include <linux/delay.h>
  31 #include <linux/pm.h>
  32 #include <linux/workqueue.h>
  33 #include <linux/platform_device.h>
  34 #include <linux/power_supply.h>
  35 #include <linux/bq27000_battery.h>
  36
  37 enum bq27000_regs {
  38         /* RAM regs */
  39                 /* read-write after this */
  40         BQ27000_CTRL = 0, /* Device Control Register */
  41         BQ27000_MODE, /* Device Mode Register */
  42         BQ27000_AR_L, /* At-Rate H L */
  43         BQ27000_AR_H,
  44                 /* read-only after this */
  45         BQ27000_ARTTE_L, /* At-Rate Time To Empty H L */
  46         BQ27000_ARTTE_H,
  47         BQ27000_TEMP_L, /* Reported Temperature H L */
  48         BQ27000_TEMP_H,
  49         BQ27000_VOLT_L, /* Reported Voltage H L */
  50         BQ27000_VOLT_H,
  51         BQ27000_FLAGS, /* Status Flags */
  52         BQ27000_RSOC, /* Relative State of Charge */
  53         BQ27000_NAC_L, /* Nominal Available Capacity H L */
  54         BQ27000_NAC_H,
  55         BQ27000_CACD_L, /* Discharge Compensated H L */
  56         BQ27000_CACD_H,
  57         BQ27000_CACT_L, /* Temperature Compensated H L */
  58         BQ27000_CACT_H,
  59         BQ27000_LMD_L, /* Last measured discharge H L */
  60         BQ27000_LMD_H,
  61         BQ27000_AI_L, /* Average Current H L */
  62         BQ27000_AI_H,
  63         BQ27000_TTE_L, /* Time to Empty H L */
  64         BQ27000_TTE_H,
  65         BQ27000_TTF_L, /* Time to Full H L */
  66         BQ27000_TTF_H,
  67         BQ27000_SI_L, /* Standby Current H L */
  68         BQ27000_SI_H,
  69         BQ27000_STTE_L, /* Standby Time To Empty H L */
  70         BQ27000_STTE_H,
  71         BQ27000_MLI_L, /* Max Load Current H L */
  72         BQ27000_MLI_H,
  73         BQ27000_MLTTE_L, /* Max Load Time To Empty H L */
  74         BQ27000_MLTTE_H,
  75         BQ27000_SAE_L, /* Available Energy H L */
  76         BQ27000_SAE_H,
  77         BQ27000_AP_L, /* Available Power H L */
  78         BQ27000_AP_H,
  79         BQ27000_TTECP_L, /* Time to Empty at Constant Power H L */
  80         BQ27000_TTECP_H,
  81         BQ27000_CYCL_L, /* Cycle count since learning cycle H L */
  82         BQ27000_CYCL_H,
  83         BQ27000_CYCT_L, /* Cycle Count Total H L */
  84         BQ27000_CYCT_H,
  85         BQ27000_CSOC, /* Compensated State Of Charge */
  86         /* EEPROM regs */
  87                 /* read-write after this */
  88         BQ27000_EE_EE_EN = 0x6e, /* EEPROM Program Enable */
  89         BQ27000_EE_ILMD = 0x76, /* Initial Last Measured Discharge High Byte */
  90         BQ27000_EE_SEDVF, /* Scaled EDVF Threshold */
  91         BQ27000_EE_SEDV1, /* Scaled EDV1 Threshold */
  92         BQ27000_EE_ISLC, /* Initial Standby Load Current */
  93         BQ27000_EE_DMFSD, /* Digital Magnitude Filter and Self Discharge */
  94         BQ27000_EE_TAPER, /* Aging Estimate Enable, Charge Termination Taper */
  95         BQ27000_EE_PKCFG, /* Pack Configuration Values */
  96         BQ27000_EE_IMLC, /* Initial Max Load Current or ID #3 */
  97         BQ27000_EE_DCOMP, /* Discharge rate compensation constants or ID #2 */
  98         BQ27000_EE_TCOMP, /* Temperature Compensation constants or ID #1 */
  99 };
 100
 101 enum bq27000_status_flags {
 102         BQ27000_STATUS_CHGS = 0x80, /* 1 = being charged */
 103         BQ27000_STATUS_NOACT = 0x40, /* 1 = no activity */
 104         BQ27000_STATUS_IMIN = 0x20, /* 1 = Lion taper current mode */
 105         BQ27000_STATUS_CI = 0x10, /* 1 = capacity likely  innacurate */
 106         BQ27000_STATUS_CALIP = 0x08, /* 1 = calibration in progress */
 107         BQ27000_STATUS_VDQ = 0x04, /* 1 = capacity should be accurate */
 108         BQ27000_STATUS_EDV1 = 0x02, /* 1 = end of discharge.. <6% left */
 109         BQ27000_STATUS_EDVF = 0x01, /* 1 = no, it's really empty now */
 110 };
 111
 112 #define NANOVOLTS_UNIT 3750
 113
 114 struct bq27000_bat_regs {
 115         int             ai;
 116         int             flags;
 117         int             lmd;
 118         int             rsoc;
 119         int             temp;
 120         int             tte;
 121         int             ttf;
 122         int             volt;
 123 };
 124
 125 struct bq27000_device_info {
 126         struct device *dev;
 127         struct power_supply bat;
 128         struct power_supply ac;
 129         struct power_supply usb;
 130         struct delayed_work work;
 131         struct bq27000_platform_data *pdata;
 132
 133         struct bq27000_bat_regs regs;
 134 };
 135
 136 static unsigned int cache_time = 5000;
 137 module_param(cache_time, uint, 0644);
 138 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
 139
 140 /*
 141  * reading 16 bit values over HDQ has a special hazard where the
 142  * hdq device firmware can update the 16-bit register during the time we
 143  * read the two halves.  TI document SLUS556D recommends the algorithm here
 144  * to avoid trouble
 145  */
 146
 147 static int hdq_read16(struct bq27000_device_info *di, int address)
 148 {
 149         int acc;
 150         int high;
 151         int retries = 3;
 152
 153         while (retries--) {
 154
 155                 high = (di->pdata->hdq_read)(address + 1); /* high part */
 156
 157                 if (high < 0)
 158                         return high;
 159                 acc = (di->pdata->hdq_read)(address);
 160                 if (acc < 0)
 161                         return acc;
 162
 163                 /* confirm high didn't change between reading it and low */
 164                 if (high == (di->pdata->hdq_read)(address + 1))
 165                         return (high << 8) | acc;
 166         }
 167
 168         return -ETIME;
 169 }
 170
 171 static void bq27000_battery_external_power_changed(struct power_supply *psy)
 172 {
 173         struct bq27000_device_info *di = container_of(psy, struct bq27000_device_info, bat);
 174
 175         dev_dbg(di->dev, "%s\n", __FUNCTION__);
 176         schedule_delayed_work(&di->work, 0);
 177 }
 178
 179 static int bq27000_battery_get_property(struct power_supply *psy,
 180                                        enum power_supply_property psp,
 181                                        union power_supply_propval *val)
 182 {
 183         int n;
 184         struct bq27000_device_info *di = container_of(psy, struct bq27000_device_info, bat);
 185
 186         if (di->regs.rsoc < 0 && psp != POWER_SUPPLY_PROP_PRESENT)
 187                 return -ENODEV;
 188
 189         switch (psp) {
 190         case POWER_SUPPLY_PROP_STATUS:
 191                 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 192
 193                 if (!di->pdata->get_charger_online_status)
 194                         goto use_bat;
 195                 if ((di->pdata->get_charger_online_status)()) {
 196                         /*
 197                          * charger is definitively present
 198                          * we report our state in terms of what it says it
 199                          * is doing
 200                          */
 201                         if (!di->pdata->get_charger_active_status)
 202                                 goto use_bat;
 203
 204                         if ((di->pdata->get_charger_active_status)()) {
 205                                 val->intval = POWER_SUPPLY_STATUS_CHARGING;
 206                                 break;
 207                         }
 208                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 209                         break;
 210                 }
 211
 212                 /*
 213                  * platform provided definite indication of charger presence,
 214                  * and it is telling us it isn't there... but we are on so we
 215                  * must be running from battery --->
 216                  */
 217
 218                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 219                 break;
 220
 221 use_bat:
 222                 /*
 223                  * either the charger is not connected, or the
 224                  * platform doesn't give info about charger, use battery state
 225                  * but... battery state can be out of date by 4 seconds or
 226                  * so... use the platform callbacks if possible.
 227                  */
 228
 229                 /* no real activity on the battery */
 230                 if (di->regs.ai < 2) {
 231                         if (!di->regs.ttf)
 232                                 val->intval = POWER_SUPPLY_STATUS_FULL;
 233                         else
 234                                 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 235                         break;
 236                 }
 237                 /* power is actually going in or out... */
 238                 if (di->regs.flags < 0)
 239                         return di->regs.flags;
 240                 if (di->regs.flags & BQ27000_STATUS_CHGS)
 241                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 242                 else
 243                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 244                 break;
 245         case POWER_SUPPLY_PROP_HEALTH:
 246                 val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
 247                 /* Do we have accurate readings... */
 248                 if (di->regs.flags < 0)
 249                         return di->regs.flags;
 250                 if (di->regs.flags & BQ27000_STATUS_VDQ)
 251                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 252                 break;
 253         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 254                 if (di->regs.volt < 0)
 255                         return di->regs.volt;
 256                 /* mV -> uV */
 257                 val->intval = di->regs.volt * 1000;
 258                 break;
 259         case POWER_SUPPLY_PROP_CURRENT_NOW:
 260                 if (di->regs.flags < 0)
 261                         return di->regs.flags;
 262                 if (di->regs.flags & BQ27000_STATUS_CHGS)
 263                         n = -NANOVOLTS_UNIT;
 264                 else
 265                         n = NANOVOLTS_UNIT;
 266                 if (di->regs.ai < 0)
 267                         return di->regs.ai;
 268                 val->intval = (di->regs.ai * n) / di->pdata->rsense_mohms;
 269                 break;
 270         case POWER_SUPPLY_PROP_CHARGE_FULL:
 271                 if (di->regs.lmd < 0)
 272                         return di->regs.lmd;
 273                 val->intval = (di->regs.lmd * 3570) / di->pdata->rsense_mohms;
 274                 break;
 275         case POWER_SUPPLY_PROP_TEMP:
 276                 if (di->regs.temp < 0)
 277                         return di->regs.temp;
 278                 /* K (in 0.25K units) is 273.15 up from C (in 0.1C)*/
 279                 /* 10926 = 27315 * 4 / 10 */
 280                 val->intval = (((long)di->regs.temp * 10l) - 10926) / 4;
 281                 break;
 282         case POWER_SUPPLY_PROP_TECHNOLOGY:
 283                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 284                 break;
 285         case POWER_SUPPLY_PROP_CAPACITY:
 286                 val->intval = di->regs.rsoc;
 287                 if (val->intval < 0)
 288                         return val->intval;
 289                 break;
 290         case POWER_SUPPLY_PROP_PRESENT:
 291                 val->intval = !(di->regs.rsoc < 0);
 292                 break;
 293         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 294                 if (di->regs.tte < 0)
 295                         return di->regs.tte;
 296                 val->intval = 60 * di->regs.tte;
 297                 break;
 298         case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
 299                 if (di->regs.ttf < 0)
 300                         return di->regs.ttf;
 301                 val->intval = 60 * di->regs.ttf;
 302                 break;
 303         case POWER_SUPPLY_PROP_ONLINE:
 304                 if (di->pdata->get_charger_online_status)
 305                         val->intval = (di->pdata->get_charger_online_status)();
 306                 else
 307                         return -EINVAL;
 308                 break;
 309         default:
 310                 return -EINVAL;
 311         }
 312
 313         return 0;
 314 }
 315
 316 static void bq27000_battery_work(struct work_struct *work)
 317 {
 318         struct bq27000_device_info *di =
 319                 container_of(work, struct bq27000_device_info, work.work);
 320
 321         if ((di->pdata->hdq_initialized)()) {
 322                 struct bq27000_bat_regs regs;
 323
 324                 regs.ai    = hdq_read16(di, BQ27000_AI_L);
 325                 regs.flags = (di->pdata->hdq_read)(BQ27000_FLAGS);
 326                 regs.lmd   = hdq_read16(di, BQ27000_LMD_L);
 327                 regs.rsoc  = (di->pdata->hdq_read)(BQ27000_RSOC);
 328                 regs.temp  = hdq_read16(di, BQ27000_TEMP_L);
 329                 regs.tte   = hdq_read16(di, BQ27000_TTE_L);
 330                 regs.ttf   = hdq_read16(di, BQ27000_TTF_L);
 331                 regs.volt  = hdq_read16(di, BQ27000_VOLT_L);
 332
 333                 if (memcmp (&regs, &di->regs, sizeof(regs)) != 0) {
 334                         di->regs = regs;
 335                         power_supply_changed(&di->bat);
 336                 }
 337         }
 338
 339         if (!schedule_delayed_work(&di->work, cache_time))
 340                 dev_err(di->dev, "battery service reschedule failed\n");
 341 }
 342
 343 static enum power_supply_property bq27000_battery_props[] = {
 344         POWER_SUPPLY_PROP_STATUS,
 345         POWER_SUPPLY_PROP_HEALTH,
 346         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 347         POWER_SUPPLY_PROP_CURRENT_NOW,
 348         POWER_SUPPLY_PROP_CHARGE_FULL,
 349         POWER_SUPPLY_PROP_TEMP,
 350         POWER_SUPPLY_PROP_TECHNOLOGY,
 351         POWER_SUPPLY_PROP_PRESENT,
 352         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
 353         POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
 354         POWER_SUPPLY_PROP_CAPACITY,
 355         POWER_SUPPLY_PROP_ONLINE
 356 };
 357
 358 static int bq27000_battery_probe(struct platform_device *pdev)
 359 {
 360         int retval = 0;
 361         struct bq27000_device_info *di;
 362         struct bq27000_platform_data *pdata;
 363
 364         dev_info(&pdev->dev, "BQ27000 Battery Driver (C) 2008 Openmoko, Inc\n");
 365
 366         di = kzalloc(sizeof(*di), GFP_KERNEL);
 367         if (!di) {
 368                 retval = -ENOMEM;
 369                 goto di_alloc_failed;
 370         }
 371
 372         platform_set_drvdata(pdev, di);
 373
 374         pdata = pdev->dev.platform_data;
 375         di->dev         = &pdev->dev;
 376         /* di->w1_dev        = pdev->dev.parent; */
 377         di->bat.name       = pdata->name;
 378         di->bat.type       = POWER_SUPPLY_TYPE_BATTERY;
 379         di->bat.properties     = bq27000_battery_props;
 380         di->bat.num_properties = ARRAY_SIZE(bq27000_battery_props);
 381         di->bat.get_property   = bq27000_battery_get_property;
 382         di->bat.external_power_changed =
 383                                   bq27000_battery_external_power_changed;
 384         di->bat.use_for_apm = 1;
 385         di->pdata = pdata;
 386
 387         retval = power_supply_register(&pdev->dev, &di->bat);
 388         if (retval) {
 389                 dev_err(di->dev, "failed to register battery\n");
 390                 goto batt_failed;
 391         }
 392
 393         INIT_DELAYED_WORK(&di->work, bq27000_battery_work);
 394
 395         if (!schedule_delayed_work(&di->work, 0))
 396                 dev_err(di->dev, "failed to schedule bq27000_battery_work\n");
 397
 398         return 0;
 399
 400 batt_failed:
 401         kfree(di);
 402 di_alloc_failed:
 403         return retval;
 404 }
 405
 406 static int bq27000_battery_remove(struct platform_device *pdev)
 407 {
 408         struct bq27000_device_info *di = platform_get_drvdata(pdev);
 409
 410         cancel_delayed_work(&di->work);
 411
 412         power_supply_unregister(&di->bat);
 413
 414         return 0;
 415 }
 416
 417 void bq27000_charging_state_change(struct platform_device *pdev)
 418 {
 419         struct bq27000_device_info *di = platform_get_drvdata(pdev);
 420
 421         if (!di)
 422             return;
 423 }
 424 EXPORT_SYMBOL_GPL(bq27000_charging_state_change);
 425
 426 #ifdef CONFIG_PM
 427
 428 static int bq27000_battery_suspend(struct platform_device *pdev,
 429                                   pm_message_t state)
 430 {
 431         struct bq27000_device_info *di = platform_get_drvdata(pdev);
 432
 433         cancel_delayed_work(&di->work);
 434         return 0;
 435 }
 436
 437 static int bq27000_battery_resume(struct platform_device *pdev)
 438 {
 439         struct bq27000_device_info *di = platform_get_drvdata(pdev);
 440
 441         schedule_delayed_work(&di->work, 0);
 442         return 0;
 443 }
 444
 445 #else
 446
 447 #define bq27000_battery_suspend NULL
 448 #define bq27000_battery_resume NULL
 449
 450 #endif /* CONFIG_PM */
 451
 452 static struct platform_driver bq27000_battery_driver = {
 453         .driver = {
 454                 .name = "bq27000-battery",
 455         },
 456         .probe    = bq27000_battery_probe,
 457         .remove   = bq27000_battery_remove,
 458         .suspend  = bq27000_battery_suspend,
 459         .resume   = bq27000_battery_resume,
 460 };
 461
 462 static int __init bq27000_battery_init(void)
 463 {
 464         return platform_driver_register(&bq27000_battery_driver);
 465 }
 466
 467 static void __exit bq27000_battery_exit(void)
 468 {
 469         platform_driver_unregister(&bq27000_battery_driver);
 470 }
 471
 472 module_init(bq27000_battery_init);
 473 module_exit(bq27000_battery_exit);
 474
 475 MODULE_LICENSE("GPL");
 476 MODULE_AUTHOR("Andy Green <andy@openmoko.com>");
 477 MODULE_DESCRIPTION("bq27000 battery driver");