drivers/power/ds2782_battery.c

   1 /*
   2  * I2C client/driver for the Maxim/Dallas DS2782 Stand-Alone Fuel Gauge IC
   3  *
   4  * Copyright (C) 2009 Bluewater Systems Ltd
   5  *
   6  * Author: Ryan Mallon
   7  *
   8  * DS2786 added by Yulia Vilensky <vilensky@compulab.co.il>
   9  *
  10  * UEvent sending added by Evgeny Romanov <romanov@neurosoft.ru>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License version 2 as
  14  * published by the Free Software Foundation.
  15  *
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/types.h>
  21 #include <linux/errno.h>
  22 #include <linux/swab.h>
  23 #include <linux/i2c.h>
  24 #include <linux/delay.h>
  25 #include <linux/idr.h>
  26 #include <linux/power_supply.h>
  27 #include <linux/slab.h>
  28 #include <linux/ds2782_battery.h>
  29
  30 #define DS2782_REG_RARC         0x06    /* Remaining active relative capacity */
  31
  32 #define DS278x_REG_VOLT_MSB     0x0c
  33 #define DS278x_REG_TEMP_MSB     0x0a
  34 #define DS278x_REG_CURRENT_MSB  0x0e
  35
  36 /* EEPROM Block */
  37 #define DS2782_REG_RSNSP        0x69    /* Sense resistor value */
  38
  39 /* Current unit measurement in uA for a 1 milli-ohm sense resistor */
  40 #define DS2782_CURRENT_UNITS    1563
  41
  42 #define DS2786_REG_RARC         0x02    /* Remaining active relative capacity */
  43
  44 #define DS2786_CURRENT_UNITS    25
  45
  46 #define DS278x_DELAY            1000
  47
  48 struct ds278x_info;
  49
  50 struct ds278x_battery_ops {
  51         int (*get_battery_current)(struct ds278x_info *info, int *current_uA);
  52         int (*get_battery_voltage)(struct ds278x_info *info, int *voltage_uV);
  53         int (*get_battery_capacity)(struct ds278x_info *info, int *capacity);
  54 };
  55
  56 #define to_ds278x_info(x) container_of(x, struct ds278x_info, battery)
  57
  58 struct ds278x_info {
  59         struct i2c_client       *client;
  60         struct power_supply     battery;
  61         struct ds278x_battery_ops  *ops;
  62         struct delayed_work     bat_work;
  63         int                     id;
  64         int                     rsns;
  65         int                     capacity;
  66         int                     status;         /* State Of Charge */
  67 };
  68
  69 static DEFINE_IDR(battery_id);
  70 static DEFINE_MUTEX(battery_lock);
  71
  72 static inline int ds278x_read_reg(struct ds278x_info *info, int reg, u8 *val)
  73 {
  74         int ret;
  75
  76         ret = i2c_smbus_read_byte_data(info->client, reg);
  77         if (ret < 0) {
  78                 dev_err(&info->client->dev, "register read failed\n");
  79                 return ret;
  80         }
  81
  82         *val = ret;
  83         return 0;
  84 }
  85
  86 static inline int ds278x_read_reg16(struct ds278x_info *info, int reg_msb,
  87                                     s16 *val)
  88 {
  89         int ret;
  90
  91         ret = i2c_smbus_read_word_data(info->client, reg_msb);
  92         if (ret < 0) {
  93                 dev_err(&info->client->dev, "register read failed\n");
  94                 return ret;
  95         }
  96
  97         *val = swab16(ret);
  98         return 0;
  99 }
 100
 101 static int ds278x_get_temp(struct ds278x_info *info, int *temp)
 102 {
 103         s16 raw;
 104         int err;
 105
 106         /*
 107          * Temperature is measured in units of 0.125 degrees celcius, the
 108          * power_supply class measures temperature in tenths of degrees
 109          * celsius. The temperature value is stored as a 10 bit number, plus
 110          * sign in the upper bits of a 16 bit register.
 111          */
 112         err = ds278x_read_reg16(info, DS278x_REG_TEMP_MSB, &raw);
 113         if (err)
 114                 return err;
 115         *temp = ((raw / 32) * 125) / 100;
 116         return 0;
 117 }
 118
 119 static int ds2782_get_current(struct ds278x_info *info, int *current_uA)
 120 {
 121         int sense_res;
 122         int err;
 123         u8 sense_res_raw;
 124         s16 raw;
 125
 126         /*
 127          * The units of measurement for current are dependent on the value of
 128          * the sense resistor.
 129          */
 130         err = ds278x_read_reg(info, DS2782_REG_RSNSP, &sense_res_raw);
 131         if (err)
 132                 return err;
 133         if (sense_res_raw == 0) {
 134                 dev_err(&info->client->dev, "sense resistor value is 0\n");
 135                 return -ENXIO;
 136         }
 137         sense_res = 1000 / sense_res_raw;
 138
 139         dev_dbg(&info->client->dev, "sense resistor = %d milli-ohms\n",
 140                 sense_res);
 141         err = ds278x_read_reg16(info, DS278x_REG_CURRENT_MSB, &raw);
 142         if (err)
 143                 return err;
 144         *current_uA = raw * (DS2782_CURRENT_UNITS / sense_res);
 145         return 0;
 146 }
 147
 148 static int ds2782_get_voltage(struct ds278x_info *info, int *voltage_uV)
 149 {
 150         s16 raw;
 151         int err;
 152
 153         /*
 154          * Voltage is measured in units of 4.88mV. The voltage is stored as
 155          * a 10-bit number plus sign, in the upper bits of a 16-bit register
 156          */
 157         err = ds278x_read_reg16(info, DS278x_REG_VOLT_MSB, &raw);
 158         if (err)
 159                 return err;
 160         *voltage_uV = (raw / 32) * 4800;
 161         return 0;
 162 }
 163
 164 static int ds2782_get_capacity(struct ds278x_info *info, int *capacity)
 165 {
 166         int err;
 167         u8 raw;
 168
 169         err = ds278x_read_reg(info, DS2782_REG_RARC, &raw);
 170         if (err)
 171                 return err;
 172         *capacity = raw;
 173         return 0;
 174 }
 175
 176 static int ds2786_get_current(struct ds278x_info *info, int *current_uA)
 177 {
 178         int err;
 179         s16 raw;
 180
 181         err = ds278x_read_reg16(info, DS278x_REG_CURRENT_MSB, &raw);
 182         if (err)
 183                 return err;
 184         *current_uA = (raw / 16) * (DS2786_CURRENT_UNITS / info->rsns);
 185         return 0;
 186 }
 187
 188 static int ds2786_get_voltage(struct ds278x_info *info, int *voltage_uV)
 189 {
 190         s16 raw;
 191         int err;
 192
 193         /*
 194          * Voltage is measured in units of 1.22mV. The voltage is stored as
 195          * a 12-bit number plus sign, in the upper bits of a 16-bit register
 196          */
 197         err = ds278x_read_reg16(info, DS278x_REG_VOLT_MSB, &raw);
 198         if (err)
 199                 return err;
 200         *voltage_uV = (raw / 8) * 1220;
 201         return 0;
 202 }
 203
 204 static int ds2786_get_capacity(struct ds278x_info *info, int *capacity)
 205 {
 206         int err;
 207         u8 raw;
 208
 209         err = ds278x_read_reg(info, DS2786_REG_RARC, &raw);
 210         if (err)
 211                 return err;
 212         /* Relative capacity is displayed with resolution 0.5 % */
 213         *capacity = raw/2 ;
 214         return 0;
 215 }
 216
 217 static int ds278x_get_status(struct ds278x_info *info, int *status)
 218 {
 219         int err;
 220         int current_uA;
 221         int capacity;
 222
 223         err = info->ops->get_battery_current(info, &current_uA);
 224         if (err)
 225                 return err;
 226
 227         err = info->ops->get_battery_capacity(info, &capacity);
 228         if (err)
 229                 return err;
 230
 231         info->capacity = capacity;
 232
 233         if (capacity == 100)
 234                 *status = POWER_SUPPLY_STATUS_FULL;
 235         else if (current_uA == 0)
 236                 *status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 237         else if (current_uA < 0)
 238                 *status = POWER_SUPPLY_STATUS_DISCHARGING;
 239         else
 240                 *status = POWER_SUPPLY_STATUS_CHARGING;
 241
 242         return 0;
 243 }
 244
 245 static int ds278x_battery_get_property(struct power_supply *psy,
 246                                        enum power_supply_property prop,
 247                                        union power_supply_propval *val)
 248 {
 249         struct ds278x_info *info = to_ds278x_info(psy);
 250         int ret;
 251
 252         switch (prop) {
 253         case POWER_SUPPLY_PROP_STATUS:
 254                 ret = ds278x_get_status(info, &val->intval);
 255                 break;
 256
 257         case POWER_SUPPLY_PROP_CAPACITY:
 258                 ret = info->ops->get_battery_capacity(info, &val->intval);
 259                 break;
 260
 261         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 262                 ret = info->ops->get_battery_voltage(info, &val->intval);
 263                 break;
 264
 265         case POWER_SUPPLY_PROP_CURRENT_NOW:
 266                 ret = info->ops->get_battery_current(info, &val->intval);
 267                 break;
 268
 269         case POWER_SUPPLY_PROP_TEMP:
 270                 ret = ds278x_get_temp(info, &val->intval);
 271                 break;
 272
 273         default:
 274                 ret = -EINVAL;
 275         }
 276
 277         return ret;
 278 }
 279
 280 static void ds278x_bat_update(struct ds278x_info *info)
 281 {
 282         int old_status = info->status;
 283         int old_capacity = info->capacity;
 284
 285         ds278x_get_status(info, &info->status);
 286
 287         if ((old_status != info->status) || (old_capacity != info->capacity))
 288                 power_supply_changed(&info->battery);
 289 }
 290
 291 static void ds278x_bat_work(struct work_struct *work)
 292 {
 293         struct ds278x_info *info;
 294
 295         info = container_of(work, struct ds278x_info, bat_work.work);
 296         ds278x_bat_update(info);
 297
 298         schedule_delayed_work(&info->bat_work, DS278x_DELAY);
 299 }
 300
 301 static enum power_supply_property ds278x_battery_props[] = {
 302         POWER_SUPPLY_PROP_STATUS,
 303         POWER_SUPPLY_PROP_CAPACITY,
 304         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 305         POWER_SUPPLY_PROP_CURRENT_NOW,
 306         POWER_SUPPLY_PROP_TEMP,
 307 };
 308
 309 static void ds278x_power_supply_init(struct power_supply *battery)
 310 {
 311         battery->type                   = POWER_SUPPLY_TYPE_BATTERY;
 312         battery->properties             = ds278x_battery_props;
 313         battery->num_properties         = ARRAY_SIZE(ds278x_battery_props);
 314         battery->get_property           = ds278x_battery_get_property;
 315         battery->external_power_changed = NULL;
 316 }
 317
 318 static int ds278x_battery_remove(struct i2c_client *client)
 319 {
 320         struct ds278x_info *info = i2c_get_clientdata(client);
 321
 322         power_supply_unregister(&info->battery);
 323         kfree(info->battery.name);
 324
 325         mutex_lock(&battery_lock);
 326         idr_remove(&battery_id, info->id);
 327         mutex_unlock(&battery_lock);
 328
 329         cancel_delayed_work(&info->bat_work);
 330
 331         kfree(info);
 332         return 0;
 333 }
 334
 335 #ifdef CONFIG_PM_SLEEP
 336
 337 static int ds278x_suspend(struct device *dev)
 338 {
 339         struct i2c_client *client = to_i2c_client(dev);
 340         struct ds278x_info *info = i2c_get_clientdata(client);
 341
 342         cancel_delayed_work(&info->bat_work);
 343         return 0;
 344 }
 345
 346 static int ds278x_resume(struct device *dev)
 347 {
 348         struct i2c_client *client = to_i2c_client(dev);
 349         struct ds278x_info *info = i2c_get_clientdata(client);
 350
 351         schedule_delayed_work(&info->bat_work, DS278x_DELAY);
 352         return 0;
 353 }
 354
 355 static SIMPLE_DEV_PM_OPS(ds278x_battery_pm_ops, ds278x_suspend, ds278x_resume);
 356 #define DS278X_BATTERY_PM_OPS (&ds278x_battery_pm_ops)
 357
 358 #else
 359 #define DS278X_BATTERY_PM_OPS NULL
 360 #endif /* CONFIG_PM_SLEEP */
 361
 362 enum ds278x_num_id {
 363         DS2782 = 0,
 364         DS2786,
 365 };
 366
 367 static struct ds278x_battery_ops ds278x_ops[] = {
 368         [DS2782] = {
 369                 .get_battery_current  = ds2782_get_current,
 370                 .get_battery_voltage  = ds2782_get_voltage,
 371                 .get_battery_capacity = ds2782_get_capacity,
 372         },
 373         [DS2786] = {
 374                 .get_battery_current  = ds2786_get_current,
 375                 .get_battery_voltage  = ds2786_get_voltage,
 376                 .get_battery_capacity = ds2786_get_capacity,
 377         }
 378 };
 379
 380 static int ds278x_battery_probe(struct i2c_client *client,
 381                                 const struct i2c_device_id *id)
 382 {
 383         struct ds278x_platform_data *pdata = client->dev.platform_data;
 384         struct ds278x_info *info;
 385         int ret;
 386         int num;
 387
 388         /*
 389          * ds2786 should have the sense resistor value set
 390          * in the platform data
 391          */
 392         if (id->driver_data == DS2786 && !pdata) {
 393                 dev_err(&client->dev, "missing platform data for ds2786\n");
 394                 return -EINVAL;
 395         }
 396
 397         /* Get an ID for this battery */
 398         mutex_lock(&battery_lock);
 399         ret = idr_alloc(&battery_id, client, 0, 0, GFP_KERNEL);
 400         mutex_unlock(&battery_lock);
 401         if (ret < 0)
 402                 goto fail_id;
 403         num = ret;
 404
 405         info = kzalloc(sizeof(*info), GFP_KERNEL);
 406         if (!info) {
 407                 ret = -ENOMEM;
 408                 goto fail_info;
 409         }
 410
 411         info->battery.name = kasprintf(GFP_KERNEL, "%s-%d", client->name, num);
 412         if (!info->battery.name) {
 413                 ret = -ENOMEM;
 414                 goto fail_name;
 415         }
 416
 417         if (id->driver_data == DS2786)
 418                 info->rsns = pdata->rsns;
 419
 420         i2c_set_clientdata(client, info);
 421         info->client = client;
 422         info->id = num;
 423         info->ops  = &ds278x_ops[id->driver_data];
 424         ds278x_power_supply_init(&info->battery);
 425
 426         info->capacity = 100;
 427         info->status = POWER_SUPPLY_STATUS_FULL;
 428
 429         INIT_DELAYED_WORK(&info->bat_work, ds278x_bat_work);
 430
 431         ret = power_supply_register(&client->dev, &info->battery);
 432         if (ret) {
 433                 dev_err(&client->dev, "failed to register battery\n");
 434                 goto fail_register;
 435         } else {
 436                 schedule_delayed_work(&info->bat_work, DS278x_DELAY);
 437         }
 438
 439         return 0;
 440
 441 fail_register:
 442         kfree(info->battery.name);
 443 fail_name:
 444         kfree(info);
 445 fail_info:
 446         mutex_lock(&battery_lock);
 447         idr_remove(&battery_id, num);
 448         mutex_unlock(&battery_lock);
 449 fail_id:
 450         return ret;
 451 }
 452
 453 static const struct i2c_device_id ds278x_id[] = {
 454         {"ds2782", DS2782},
 455         {"ds2786", DS2786},
 456         {},
 457 };
 458 MODULE_DEVICE_TABLE(i2c, ds278x_id);
 459
 460 static struct i2c_driver ds278x_battery_driver = {
 461         .driver         = {
 462                 .name   = "ds2782-battery",
 463                 .pm     = DS278X_BATTERY_PM_OPS,
 464         },
 465         .probe          = ds278x_battery_probe,
 466         .remove         = ds278x_battery_remove,
 467         .id_table       = ds278x_id,
 468 };
 469 module_i2c_driver(ds278x_battery_driver);
 470
 471 MODULE_AUTHOR("Ryan Mallon");
 472 MODULE_DESCRIPTION("Maxim/Dallas DS2782 Stand-Alone Fuel Gauage IC driver");
 473 MODULE_LICENSE("GPL");