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