SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/power/bq27x00_battery.c

   1 /*
   2  * BQ27x00 battery driver
   3  *
   4  * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it>
   5  * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it>
   6  *
   7  * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc.
   8  *
   9  * This package is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  *
  13  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  15  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  16  *
  17  */
  18 #include <linux/module.h>
  19 #include <linux/param.h>
  20 #include <linux/jiffies.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/delay.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/power_supply.h>
  25 #include <linux/idr.h>
  26 #include <linux/i2c.h>
  27 #include <asm/unaligned.h>
  28
  29 #define DRIVER_VERSION                  "1.1.0"
  30
  31 #define BQ27x00_REG_TEMP                0x06
  32 #define BQ27x00_REG_VOLT                0x08
  33 #define BQ27x00_REG_AI                  0x14
  34 #define BQ27x00_REG_FLAGS               0x0A
  35 #define BQ27x00_REG_TTE                 0x16
  36 #define BQ27x00_REG_TTF                 0x18
  37 #define BQ27x00_REG_TTECP               0x26
  38
  39 #define BQ27000_REG_RSOC                0x0B /* Relative State-of-Charge */
  40 #define BQ27000_FLAG_CHGS               BIT(7)
  41
  42 #define BQ27500_REG_SOC                 0x2c
  43 #define BQ27500_FLAG_DSC                BIT(0)
  44 #define BQ27500_FLAG_FC                 BIT(9)
  45
  46 /* If the system has several batteries we need a different name for each
  47  * of them...
  48  */
  49 static DEFINE_IDR(battery_id);
  50 static DEFINE_MUTEX(battery_mutex);
  51
  52 struct bq27x00_device_info;
  53 struct bq27x00_access_methods {
  54         int (*read)(u8 reg, int *rt_value, int b_single,
  55                 struct bq27x00_device_info *di);
  56 };
  57
  58 enum bq27x00_chip { BQ27000, BQ27500 };
  59
  60 struct bq27x00_device_info {
  61         struct device           *dev;
  62         int                     id;
  63         struct bq27x00_access_methods   *bus;
  64         struct power_supply     bat;
  65         enum bq27x00_chip       chip;
  66
  67         struct i2c_client       *client;
  68 };
  69
  70 static enum power_supply_property bq27x00_battery_props[] = {
  71         POWER_SUPPLY_PROP_STATUS,
  72         POWER_SUPPLY_PROP_PRESENT,
  73         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  74         POWER_SUPPLY_PROP_CURRENT_NOW,
  75         POWER_SUPPLY_PROP_CAPACITY,
  76         POWER_SUPPLY_PROP_TEMP,
  77         POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
  78         POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
  79         POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
  80 };
  81
  82 /*
  83  * Common code for BQ27x00 devices
  84  */
  85
  86 static int bq27x00_read(u8 reg, int *rt_value, int b_single,
  87                         struct bq27x00_device_info *di)
  88 {
  89         return di->bus->read(reg, rt_value, b_single, di);
  90 }
  91
  92 /*
  93  * Return the battery temperature in tenths of degree Celsius
  94  * Or < 0 if something fails.
  95  */
  96 static int bq27x00_battery_temperature(struct bq27x00_device_info *di)
  97 {
  98         int ret;
  99         int temp = 0;
 100
 101         ret = bq27x00_read(BQ27x00_REG_TEMP, &temp, 0, di);
 102         if (ret) {
 103                 dev_err(di->dev, "error reading temperature\n");
 104                 return ret;
 105         }
 106
 107         if (di->chip == BQ27500)
 108                 return temp - 2731;
 109         else
 110                 return ((temp >> 2) - 273) * 10;
 111 }
 112
 113 /*
 114  * Return the battery Voltage in milivolts
 115  * Or < 0 if something fails.
 116  */
 117 static int bq27x00_battery_voltage(struct bq27x00_device_info *di)
 118 {
 119         int ret;
 120         int volt = 0;
 121
 122         ret = bq27x00_read(BQ27x00_REG_VOLT, &volt, 0, di);
 123         if (ret) {
 124                 dev_err(di->dev, "error reading voltage\n");
 125                 return ret;
 126         }
 127
 128         return volt;
 129 }
 130
 131 /*
 132  * Return the battery average current
 133  * Note that current can be negative signed as well
 134  * Or 0 if something fails.
 135  */
 136 static int bq27x00_battery_current(struct bq27x00_device_info *di)
 137 {
 138         int ret;
 139         int curr = 0;
 140         int flags = 0;
 141
 142         ret = bq27x00_read(BQ27x00_REG_AI, &curr, 0, di);
 143         if (ret) {
 144                 dev_err(di->dev, "error reading current\n");
 145                 return 0;
 146         }
 147
 148         if (di->chip == BQ27500) {
 149                 /* bq27500 returns signed value */
 150                 curr = (int)(s16)curr;
 151         } else {
 152                 ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di);
 153                 if (ret < 0) {
 154                         dev_err(di->dev, "error reading flags\n");
 155                         return 0;
 156                 }
 157                 if (flags & BQ27000_FLAG_CHGS) {
 158                         dev_dbg(di->dev, "negative current!\n");
 159                         return -curr;
 160                 }
 161         }
 162
 163         return curr;
 164 }
 165
 166 /*
 167  * Return the battery Relative State-of-Charge
 168  * Or < 0 if something fails.
 169  */
 170 static int bq27x00_battery_rsoc(struct bq27x00_device_info *di)
 171 {
 172         int ret;
 173         int rsoc = 0;
 174
 175         if (di->chip == BQ27500)
 176                 ret = bq27x00_read(BQ27500_REG_SOC, &rsoc, 0, di);
 177         else
 178                 ret = bq27x00_read(BQ27000_REG_RSOC, &rsoc, 1, di);
 179         if (ret) {
 180                 dev_err(di->dev, "error reading relative State-of-Charge\n");
 181                 return ret;
 182         }
 183
 184         return rsoc;
 185 }
 186
 187 static int bq27x00_battery_status(struct bq27x00_device_info *di,
 188                                   union power_supply_propval *val)
 189 {
 190         int flags = 0;
 191         int status;
 192         int ret;
 193
 194         ret = bq27x00_read(BQ27x00_REG_FLAGS, &flags, 0, di);
 195         if (ret < 0) {
 196                 dev_err(di->dev, "error reading flags\n");
 197                 return ret;
 198         }
 199
 200         if (di->chip == BQ27500) {
 201                 if (flags & BQ27500_FLAG_FC)
 202                         status = POWER_SUPPLY_STATUS_FULL;
 203                 else if (flags & BQ27500_FLAG_DSC)
 204                         status = POWER_SUPPLY_STATUS_DISCHARGING;
 205                 else
 206                         status = POWER_SUPPLY_STATUS_CHARGING;
 207         } else {
 208                 if (flags & BQ27000_FLAG_CHGS)
 209                         status = POWER_SUPPLY_STATUS_CHARGING;
 210                 else
 211                         status = POWER_SUPPLY_STATUS_DISCHARGING;
 212         }
 213
 214         val->intval = status;
 215         return 0;
 216 }
 217
 218 /*
 219  * Read a time register.
 220  * Return < 0 if something fails.
 221  */
 222 static int bq27x00_battery_time(struct bq27x00_device_info *di, int reg,
 223                                 union power_supply_propval *val)
 224 {
 225         int tval = 0;
 226         int ret;
 227
 228         ret = bq27x00_read(reg, &tval, 0, di);
 229         if (ret) {
 230                 dev_err(di->dev, "error reading register %02x\n", reg);
 231                 return ret;
 232         }
 233
 234         if (tval == 65535)
 235                 return -ENODATA;
 236
 237         val->intval = tval * 60;
 238         return 0;
 239 }
 240
 241 #define to_bq27x00_device_info(x) container_of((x), \
 242                                 struct bq27x00_device_info, bat);
 243
 244 static int bq27x00_battery_get_property(struct power_supply *psy,
 245                                         enum power_supply_property psp,
 246                                         union power_supply_propval *val)
 247 {
 248         int ret = 0;
 249         struct bq27x00_device_info *di = to_bq27x00_device_info(psy);
 250
 251         switch (psp) {
 252         case POWER_SUPPLY_PROP_STATUS:
 253                 ret = bq27x00_battery_status(di, val);
 254                 break;
 255         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 256         case POWER_SUPPLY_PROP_PRESENT:
 257                 val->intval = bq27x00_battery_voltage(di);
 258                 if (psp == POWER_SUPPLY_PROP_PRESENT)
 259                         val->intval = val->intval <= 0 ? 0 : 1;
 260                 break;
 261         case POWER_SUPPLY_PROP_CURRENT_NOW:
 262                 val->intval = bq27x00_battery_current(di);
 263                 break;
 264         case POWER_SUPPLY_PROP_CAPACITY:
 265                 val->intval = bq27x00_battery_rsoc(di);
 266                 break;
 267         case POWER_SUPPLY_PROP_TEMP:
 268                 val->intval = bq27x00_battery_temperature(di);
 269                 break;
 270         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
 271                 ret = bq27x00_battery_time(di, BQ27x00_REG_TTE, val);
 272                 break;
 273         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 274                 ret = bq27x00_battery_time(di, BQ27x00_REG_TTECP, val);
 275                 break;
 276         case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
 277                 ret = bq27x00_battery_time(di, BQ27x00_REG_TTF, val);
 278                 break;
 279         default:
 280                 return -EINVAL;
 281         }
 282
 283         return ret;
 284 }
 285
 286 static void bq27x00_powersupply_init(struct bq27x00_device_info *di)
 287 {
 288         di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
 289         di->bat.properties = bq27x00_battery_props;
 290         di->bat.num_properties = ARRAY_SIZE(bq27x00_battery_props);
 291         di->bat.get_property = bq27x00_battery_get_property;
 292         di->bat.external_power_changed = NULL;
 293 }
 294
 295 /*
 296  * i2c specific code
 297  */
 298
 299 static int bq27x00_read_i2c(u8 reg, int *rt_value, int b_single,
 300                         struct bq27x00_device_info *di)
 301 {
 302         struct i2c_client *client = di->client;
 303         struct i2c_msg msg[1];
 304         unsigned char data[2];
 305         int err;
 306
 307         if (!client->adapter)
 308                 return -ENODEV;
 309
 310         msg->addr = client->addr;
 311         msg->flags = 0;
 312         msg->len = 1;
 313         msg->buf = data;
 314
 315         data[0] = reg;
 316         err = i2c_transfer(client->adapter, msg, 1);
 317
 318         if (err >= 0) {
 319                 if (!b_single)
 320                         msg->len = 2;
 321                 else
 322                         msg->len = 1;
 323
 324                 msg->flags = I2C_M_RD;
 325                 err = i2c_transfer(client->adapter, msg, 1);
 326                 if (err >= 0) {
 327                         if (!b_single)
 328                                 *rt_value = get_unaligned_le16(data);
 329                         else
 330                                 *rt_value = data[0];
 331
 332                         return 0;
 333                 }
 334         }
 335         return err;
 336 }
 337
 338 static int bq27x00_battery_probe(struct i2c_client *client,
 339                                  const struct i2c_device_id *id)
 340 {
 341         char *name;
 342         struct bq27x00_device_info *di;
 343         struct bq27x00_access_methods *bus;
 344         int num;
 345         int retval = 0;
 346
 347         /* Get new ID for the new battery device */
 348         retval = idr_pre_get(&battery_id, GFP_KERNEL);
 349         if (retval == 0)
 350                 return -ENOMEM;
 351         mutex_lock(&battery_mutex);
 352         retval = idr_get_new(&battery_id, client, &num);
 353         mutex_unlock(&battery_mutex);
 354         if (retval < 0)
 355                 return retval;
 356
 357         name = kasprintf(GFP_KERNEL, "%s-%d", id->name, num);
 358         if (!name) {
 359                 dev_err(&client->dev, "failed to allocate device name\n");
 360                 retval = -ENOMEM;
 361                 goto batt_failed_1;
 362         }
 363
 364         di = kzalloc(sizeof(*di), GFP_KERNEL);
 365         if (!di) {
 366                 dev_err(&client->dev, "failed to allocate device info data\n");
 367                 retval = -ENOMEM;
 368                 goto batt_failed_2;
 369         }
 370         di->id = num;
 371         di->chip = id->driver_data;
 372
 373         bus = kzalloc(sizeof(*bus), GFP_KERNEL);
 374         if (!bus) {
 375                 dev_err(&client->dev, "failed to allocate access method "
 376                                         "data\n");
 377                 retval = -ENOMEM;
 378                 goto batt_failed_3;
 379         }
 380
 381         i2c_set_clientdata(client, di);
 382         di->dev = &client->dev;
 383         di->bat.name = name;
 384         bus->read = &bq27x00_read_i2c;
 385         di->bus = bus;
 386         di->client = client;
 387
 388         bq27x00_powersupply_init(di);
 389
 390         retval = power_supply_register(&client->dev, &di->bat);
 391         if (retval) {
 392                 dev_err(&client->dev, "failed to register battery\n");
 393                 goto batt_failed_4;
 394         }
 395
 396         dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
 397
 398         return 0;
 399
 400 batt_failed_4:
 401         kfree(bus);
 402 batt_failed_3:
 403         kfree(di);
 404 batt_failed_2:
 405         kfree(name);
 406 batt_failed_1:
 407         mutex_lock(&battery_mutex);
 408         idr_remove(&battery_id, num);
 409         mutex_unlock(&battery_mutex);
 410
 411         return retval;
 412 }
 413
 414 static int bq27x00_battery_remove(struct i2c_client *client)
 415 {
 416         struct bq27x00_device_info *di = i2c_get_clientdata(client);
 417
 418         power_supply_unregister(&di->bat);
 419
 420         kfree(di->bat.name);
 421
 422         mutex_lock(&battery_mutex);
 423         idr_remove(&battery_id, di->id);
 424         mutex_unlock(&battery_mutex);
 425
 426         kfree(di);
 427
 428         return 0;
 429 }
 430
 431 /*
 432  * Module stuff
 433  */
 434
 435 static const struct i2c_device_id bq27x00_id[] = {
 436         { "bq27200", BQ27000 }, /* bq27200 is same as bq27000, but with i2c */
 437         { "bq27500", BQ27500 },
 438         {},
 439 };
 440
 441 static struct i2c_driver bq27x00_battery_driver = {
 442         .driver = {
 443                 .name = "bq27x00-battery",
 444         },
 445         .probe = bq27x00_battery_probe,
 446         .remove = bq27x00_battery_remove,
 447         .id_table = bq27x00_id,
 448 };
 449
 450 static int __init bq27x00_battery_init(void)
 451 {
 452         int ret;
 453
 454         ret = i2c_add_driver(&bq27x00_battery_driver);
 455         if (ret)
 456                 printk(KERN_ERR "Unable to register BQ27x00 driver\n");
 457
 458         return ret;
 459 }
 460 module_init(bq27x00_battery_init);
 461
 462 static void __exit bq27x00_battery_exit(void)
 463 {
 464         i2c_del_driver(&bq27x00_battery_driver);
 465 }
 466 module_exit(bq27x00_battery_exit);
 467
 468 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
 469 MODULE_DESCRIPTION("BQ27x00 battery monitor driver");
 470 MODULE_LICENSE("GPL");