drivers/power/sbs-battery.c

   1 /*
   2  * Gas Gauge driver for SBS Compliant Batteries
   3  *
   4  * Copyright (c) 2010, NVIDIA Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 #include <linux/init.h>
  22 #include <linux/module.h>
  23 #include <linux/kernel.h>
  24 #include <linux/err.h>
  25 #include <linux/power_supply.h>
  26 #include <linux/i2c.h>
  27 #include <linux/slab.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/gpio.h>
  30
  31 #include <linux/power/sbs-battery.h>
  32
  33 enum {
  34         REG_MANUFACTURER_DATA,
  35         REG_TEMPERATURE,
  36         REG_VOLTAGE,
  37         REG_CURRENT,
  38         REG_CAPACITY,
  39         REG_TIME_TO_EMPTY,
  40         REG_TIME_TO_FULL,
  41         REG_STATUS,
  42         REG_CYCLE_COUNT,
  43         REG_SERIAL_NUMBER,
  44         REG_REMAINING_CAPACITY,
  45         REG_REMAINING_CAPACITY_CHARGE,
  46         REG_FULL_CHARGE_CAPACITY,
  47         REG_FULL_CHARGE_CAPACITY_CHARGE,
  48         REG_DESIGN_CAPACITY,
  49         REG_DESIGN_CAPACITY_CHARGE,
  50         REG_DESIGN_VOLTAGE,
  51 };
  52
  53 /* Battery Mode defines */
  54 #define BATTERY_MODE_OFFSET             0x03
  55 #define BATTERY_MODE_MASK               0x8000
  56 enum sbs_battery_mode {
  57         BATTERY_MODE_AMPS,
  58         BATTERY_MODE_WATTS
  59 };
  60
  61 /* manufacturer access defines */
  62 #define MANUFACTURER_ACCESS_STATUS      0x0006
  63 #define MANUFACTURER_ACCESS_SLEEP       0x0011
  64
  65 /* battery status value bits */
  66 #define BATTERY_DISCHARGING             0x40
  67 #define BATTERY_FULL_CHARGED            0x20
  68 #define BATTERY_FULL_DISCHARGED         0x10
  69
  70 #define SBS_DATA(_psp, _addr, _min_value, _max_value) { \
  71         .psp = _psp, \
  72         .addr = _addr, \
  73         .min_value = _min_value, \
  74         .max_value = _max_value, \
  75 }
  76
  77 static const struct chip_data {
  78         enum power_supply_property psp;
  79         u8 addr;
  80         int min_value;
  81         int max_value;
  82 } sbs_data[] = {
  83         [REG_MANUFACTURER_DATA] =
  84                 SBS_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),
  85         [REG_TEMPERATURE] =
  86                 SBS_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),
  87         [REG_VOLTAGE] =
  88                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),
  89         [REG_CURRENT] =
  90                 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768, 32767),
  91         [REG_CAPACITY] =
  92                 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0E, 0, 100),
  93         [REG_REMAINING_CAPACITY] =
  94                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
  95         [REG_REMAINING_CAPACITY_CHARGE] =
  96                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
  97         [REG_FULL_CHARGE_CAPACITY] =
  98                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
  99         [REG_FULL_CHARGE_CAPACITY_CHARGE] =
 100                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
 101         [REG_TIME_TO_EMPTY] =
 102                 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 65535),
 103         [REG_TIME_TO_FULL] =
 104                 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0, 65535),
 105         [REG_STATUS] =
 106                 SBS_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),
 107         [REG_CYCLE_COUNT] =
 108                 SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),
 109         [REG_DESIGN_CAPACITY] =
 110                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 65535),
 111         [REG_DESIGN_CAPACITY_CHARGE] =
 112                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0, 65535),
 113         [REG_DESIGN_VOLTAGE] =
 114                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 65535),
 115         [REG_SERIAL_NUMBER] =
 116                 SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),
 117 };
 118
 119 static enum power_supply_property sbs_properties[] = {
 120         POWER_SUPPLY_PROP_STATUS,
 121         POWER_SUPPLY_PROP_HEALTH,
 122         POWER_SUPPLY_PROP_PRESENT,
 123         POWER_SUPPLY_PROP_TECHNOLOGY,
 124         POWER_SUPPLY_PROP_CYCLE_COUNT,
 125         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 126         POWER_SUPPLY_PROP_CURRENT_NOW,
 127         POWER_SUPPLY_PROP_CAPACITY,
 128         POWER_SUPPLY_PROP_TEMP,
 129         POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
 130         POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
 131         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 132         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 133         POWER_SUPPLY_PROP_ENERGY_NOW,
 134         POWER_SUPPLY_PROP_ENERGY_FULL,
 135         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 136         POWER_SUPPLY_PROP_CHARGE_NOW,
 137         POWER_SUPPLY_PROP_CHARGE_FULL,
 138         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 139 };
 140
 141 struct sbs_info {
 142         struct i2c_client               *client;
 143         struct power_supply             power_supply;
 144         struct sbs_platform_data        *pdata;
 145         bool                            is_present;
 146         bool                            gpio_detect;
 147         bool                            enable_detection;
 148         int                             irq;
 149         int                             last_state;
 150         int                             poll_time;
 151         struct delayed_work             work;
 152         int                             ignore_changes;
 153 };
 154
 155 static int sbs_read_word_data(struct i2c_client *client, u8 address)
 156 {
 157         struct sbs_info *chip = i2c_get_clientdata(client);
 158         s32 ret = 0;
 159         int retries = 1;
 160
 161         if (chip->pdata)
 162                 retries = max(chip->pdata->i2c_retry_count + 1, 1);
 163
 164         while (retries > 0) {
 165                 ret = i2c_smbus_read_word_data(client, address);
 166                 if (ret >= 0)
 167                         break;
 168                 retries--;
 169         }
 170
 171         if (ret < 0) {
 172                 dev_dbg(&client->dev,
 173                         "%s: i2c read at address 0x%x failed\n",
 174                         __func__, address);
 175                 return ret;
 176         }
 177
 178         return le16_to_cpu(ret);
 179 }
 180
 181 static int sbs_write_word_data(struct i2c_client *client, u8 address,
 182         u16 value)
 183 {
 184         struct sbs_info *chip = i2c_get_clientdata(client);
 185         s32 ret = 0;
 186         int retries = 1;
 187
 188         if (chip->pdata)
 189                 retries = max(chip->pdata->i2c_retry_count + 1, 1);
 190
 191         while (retries > 0) {
 192                 ret = i2c_smbus_write_word_data(client, address,
 193                         le16_to_cpu(value));
 194                 if (ret >= 0)
 195                         break;
 196                 retries--;
 197         }
 198
 199         if (ret < 0) {
 200                 dev_dbg(&client->dev,
 201                         "%s: i2c write to address 0x%x failed\n",
 202                         __func__, address);
 203                 return ret;
 204         }
 205
 206         return 0;
 207 }
 208
 209 static int sbs_get_battery_presence_and_health(
 210         struct i2c_client *client, enum power_supply_property psp,
 211         union power_supply_propval *val)
 212 {
 213         s32 ret;
 214         struct sbs_info *chip = i2c_get_clientdata(client);
 215
 216         if (psp == POWER_SUPPLY_PROP_PRESENT &&
 217                 chip->gpio_detect) {
 218                 ret = gpio_get_value(chip->pdata->battery_detect);
 219                 if (ret == chip->pdata->battery_detect_present)
 220                         val->intval = 1;
 221                 else
 222                         val->intval = 0;
 223                 chip->is_present = val->intval;
 224                 return ret;
 225         }
 226
 227         /* Write to ManufacturerAccess with
 228          * ManufacturerAccess command and then
 229          * read the status */
 230         ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
 231                                         MANUFACTURER_ACCESS_STATUS);
 232         if (ret < 0) {
 233                 if (psp == POWER_SUPPLY_PROP_PRESENT)
 234                         val->intval = 0; /* battery removed */
 235                 return ret;
 236         }
 237
 238         ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr);
 239         if (ret < 0)
 240                 return ret;
 241
 242         if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value ||
 243             ret > sbs_data[REG_MANUFACTURER_DATA].max_value) {
 244                 val->intval = 0;
 245                 return 0;
 246         }
 247
 248         /* Mask the upper nibble of 2nd byte and
 249          * lower byte of response then
 250          * shift the result by 8 to get status*/
 251         ret &= 0x0F00;
 252         ret >>= 8;
 253         if (psp == POWER_SUPPLY_PROP_PRESENT) {
 254                 if (ret == 0x0F)
 255                         /* battery removed */
 256                         val->intval = 0;
 257                 else
 258                         val->intval = 1;
 259         } else if (psp == POWER_SUPPLY_PROP_HEALTH) {
 260                 if (ret == 0x09)
 261                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 262                 else if (ret == 0x0B)
 263                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 264                 else if (ret == 0x0C)
 265                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
 266                 else
 267                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 268         }
 269
 270         return 0;
 271 }
 272
 273 static int sbs_get_battery_property(struct i2c_client *client,
 274         int reg_offset, enum power_supply_property psp,
 275         union power_supply_propval *val)
 276 {
 277         struct sbs_info *chip = i2c_get_clientdata(client);
 278         s32 ret;
 279
 280         ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
 281         if (ret < 0)
 282                 return ret;
 283
 284         /* returned values are 16 bit */
 285         if (sbs_data[reg_offset].min_value < 0)
 286                 ret = (s16)ret;
 287
 288         if (ret >= sbs_data[reg_offset].min_value &&
 289             ret <= sbs_data[reg_offset].max_value) {
 290                 val->intval = ret;
 291                 if (psp != POWER_SUPPLY_PROP_STATUS)
 292                         return 0;
 293
 294                 if (ret & BATTERY_FULL_CHARGED)
 295                         val->intval = POWER_SUPPLY_STATUS_FULL;
 296                 else if (ret & BATTERY_FULL_DISCHARGED)
 297                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 298                 else if (ret & BATTERY_DISCHARGING)
 299                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 300                 else
 301                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 302
 303                 if (chip->poll_time == 0)
 304                         chip->last_state = val->intval;
 305                 else if (chip->last_state != val->intval) {
 306                         cancel_delayed_work_sync(&chip->work);
 307                         power_supply_changed(&chip->power_supply);
 308                         chip->poll_time = 0;
 309                 }
 310         } else {
 311                 if (psp == POWER_SUPPLY_PROP_STATUS)
 312                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 313                 else
 314                         val->intval = 0;
 315         }
 316
 317         return 0;
 318 }
 319
 320 static void  sbs_unit_adjustment(struct i2c_client *client,
 321         enum power_supply_property psp, union power_supply_propval *val)
 322 {
 323 #define BASE_UNIT_CONVERSION            1000
 324 #define BATTERY_MODE_CAP_MULT_WATT      (10 * BASE_UNIT_CONVERSION)
 325 #define TIME_UNIT_CONVERSION            60
 326 #define TEMP_KELVIN_TO_CELSIUS          2731
 327         switch (psp) {
 328         case POWER_SUPPLY_PROP_ENERGY_NOW:
 329         case POWER_SUPPLY_PROP_ENERGY_FULL:
 330         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 331                 /* sbs provides energy in units of 10mWh.
 332                  * Convert to µWh
 333                  */
 334                 val->intval *= BATTERY_MODE_CAP_MULT_WATT;
 335                 break;
 336
 337         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 338         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 339         case POWER_SUPPLY_PROP_CURRENT_NOW:
 340         case POWER_SUPPLY_PROP_CHARGE_NOW:
 341         case POWER_SUPPLY_PROP_CHARGE_FULL:
 342         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 343                 val->intval *= BASE_UNIT_CONVERSION;
 344                 break;
 345
 346         case POWER_SUPPLY_PROP_TEMP:
 347                 /* sbs provides battery temperature in 0.1K
 348                  * so convert it to 0.1°C
 349                  */
 350                 val->intval -= TEMP_KELVIN_TO_CELSIUS;
 351                 break;
 352
 353         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 354         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
 355                 /* sbs provides time to empty and time to full in minutes.
 356                  * Convert to seconds
 357                  */
 358                 val->intval *= TIME_UNIT_CONVERSION;
 359                 break;
 360
 361         default:
 362                 dev_dbg(&client->dev,
 363                         "%s: no need for unit conversion %d\n", __func__, psp);
 364         }
 365 }
 366
 367 static enum sbs_battery_mode sbs_set_battery_mode(struct i2c_client *client,
 368         enum sbs_battery_mode mode)
 369 {
 370         int ret, original_val;
 371
 372         original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET);
 373         if (original_val < 0)
 374                 return original_val;
 375
 376         if ((original_val & BATTERY_MODE_MASK) == mode)
 377                 return mode;
 378
 379         if (mode == BATTERY_MODE_AMPS)
 380                 ret = original_val & ~BATTERY_MODE_MASK;
 381         else
 382                 ret = original_val | BATTERY_MODE_MASK;
 383
 384         ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret);
 385         if (ret < 0)
 386                 return ret;
 387
 388         return original_val & BATTERY_MODE_MASK;
 389 }
 390
 391 static int sbs_get_battery_capacity(struct i2c_client *client,
 392         int reg_offset, enum power_supply_property psp,
 393         union power_supply_propval *val)
 394 {
 395         s32 ret;
 396         enum sbs_battery_mode mode = BATTERY_MODE_WATTS;
 397
 398         if (power_supply_is_amp_property(psp))
 399                 mode = BATTERY_MODE_AMPS;
 400
 401         mode = sbs_set_battery_mode(client, mode);
 402         if (mode < 0)
 403                 return mode;
 404
 405         ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
 406         if (ret < 0)
 407                 return ret;
 408
 409         if (psp == POWER_SUPPLY_PROP_CAPACITY) {
 410                 /* sbs spec says that this can be >100 %
 411                 * even if max value is 100 % */
 412                 val->intval = min(ret, 100);
 413         } else
 414                 val->intval = ret;
 415
 416         ret = sbs_set_battery_mode(client, mode);
 417         if (ret < 0)
 418                 return ret;
 419
 420         return 0;
 421 }
 422
 423 static char sbs_serial[5];
 424 static int sbs_get_battery_serial_number(struct i2c_client *client,
 425         union power_supply_propval *val)
 426 {
 427         int ret;
 428
 429         ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr);
 430         if (ret < 0)
 431                 return ret;
 432
 433         ret = sprintf(sbs_serial, "%04x", ret);
 434         val->strval = sbs_serial;
 435
 436         return 0;
 437 }
 438
 439 static int sbs_get_property_index(struct i2c_client *client,
 440         enum power_supply_property psp)
 441 {
 442         int count;
 443         for (count = 0; count < ARRAY_SIZE(sbs_data); count++)
 444                 if (psp == sbs_data[count].psp)
 445                         return count;
 446
 447         dev_warn(&client->dev,
 448                 "%s: Invalid Property - %d\n", __func__, psp);
 449
 450         return -EINVAL;
 451 }
 452
 453 static int sbs_get_property(struct power_supply *psy,
 454         enum power_supply_property psp,
 455         union power_supply_propval *val)
 456 {
 457         int ret = 0;
 458         struct sbs_info *chip = container_of(psy,
 459                                 struct sbs_info, power_supply);
 460         struct i2c_client *client = chip->client;
 461
 462         switch (psp) {
 463         case POWER_SUPPLY_PROP_PRESENT:
 464         case POWER_SUPPLY_PROP_HEALTH:
 465                 ret = sbs_get_battery_presence_and_health(client, psp, val);
 466                 if (psp == POWER_SUPPLY_PROP_PRESENT)
 467                         return 0;
 468                 break;
 469
 470         case POWER_SUPPLY_PROP_TECHNOLOGY:
 471                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 472                 break;
 473
 474         case POWER_SUPPLY_PROP_ENERGY_NOW:
 475         case POWER_SUPPLY_PROP_ENERGY_FULL:
 476         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 477         case POWER_SUPPLY_PROP_CHARGE_NOW:
 478         case POWER_SUPPLY_PROP_CHARGE_FULL:
 479         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 480         case POWER_SUPPLY_PROP_CAPACITY:
 481                 ret = sbs_get_property_index(client, psp);
 482                 if (ret < 0)
 483                         break;
 484
 485                 ret = sbs_get_battery_capacity(client, ret, psp, val);
 486                 break;
 487
 488         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 489                 ret = sbs_get_battery_serial_number(client, val);
 490                 break;
 491
 492         case POWER_SUPPLY_PROP_STATUS:
 493         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 494         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 495         case POWER_SUPPLY_PROP_CURRENT_NOW:
 496         case POWER_SUPPLY_PROP_TEMP:
 497         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 498         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
 499         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 500                 ret = sbs_get_property_index(client, psp);
 501                 if (ret < 0)
 502                         break;
 503
 504                 ret = sbs_get_battery_property(client, ret, psp, val);
 505                 break;
 506
 507         default:
 508                 dev_err(&client->dev,
 509                         "%s: INVALID property\n", __func__);
 510                 return -EINVAL;
 511         }
 512
 513         if (!chip->enable_detection)
 514                 goto done;
 515
 516         if (!chip->gpio_detect &&
 517                 chip->is_present != (ret >= 0)) {
 518                 chip->is_present = (ret >= 0);
 519                 power_supply_changed(&chip->power_supply);
 520         }
 521
 522 done:
 523         if (!ret) {
 524                 /* Convert units to match requirements for power supply class */
 525                 sbs_unit_adjustment(client, psp, val);
 526         }
 527
 528         dev_dbg(&client->dev,
 529                 "%s: property = %d, value = %x\n", __func__, psp, val->intval);
 530
 531         if (ret && chip->is_present)
 532                 return ret;
 533
 534         /* battery not present, so return NODATA for properties */
 535         if (ret)
 536                 return -ENODATA;
 537
 538         return 0;
 539 }
 540
 541 static irqreturn_t sbs_irq(int irq, void *devid)
 542 {
 543         struct power_supply *battery = devid;
 544
 545         power_supply_changed(battery);
 546
 547         return IRQ_HANDLED;
 548 }
 549
 550 static void sbs_external_power_changed(struct power_supply *psy)
 551 {
 552         struct sbs_info *chip;
 553
 554         chip = container_of(psy, struct sbs_info, power_supply);
 555
 556         if (chip->ignore_changes > 0) {
 557                 chip->ignore_changes--;
 558                 return;
 559         }
 560
 561         /* cancel outstanding work */
 562         cancel_delayed_work_sync(&chip->work);
 563
 564         schedule_delayed_work(&chip->work, HZ);
 565         chip->poll_time = chip->pdata->poll_retry_count;
 566 }
 567
 568 static void sbs_delayed_work(struct work_struct *work)
 569 {
 570         struct sbs_info *chip;
 571         s32 ret;
 572
 573         chip = container_of(work, struct sbs_info, work.work);
 574
 575         ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr);
 576         /* if the read failed, give up on this work */
 577         if (ret < 0) {
 578                 chip->poll_time = 0;
 579                 return;
 580         }
 581
 582         if (ret & BATTERY_FULL_CHARGED)
 583                 ret = POWER_SUPPLY_STATUS_FULL;
 584         else if (ret & BATTERY_FULL_DISCHARGED)
 585                 ret = POWER_SUPPLY_STATUS_NOT_CHARGING;
 586         else if (ret & BATTERY_DISCHARGING)
 587                 ret = POWER_SUPPLY_STATUS_DISCHARGING;
 588         else
 589                 ret = POWER_SUPPLY_STATUS_CHARGING;
 590
 591         if (chip->last_state != ret) {
 592                 chip->poll_time = 0;
 593                 power_supply_changed(&chip->power_supply);
 594                 return;
 595         }
 596         if (chip->poll_time > 0) {
 597                 schedule_delayed_work(&chip->work, HZ);
 598                 chip->poll_time--;
 599                 return;
 600         }
 601 }
 602
 603 #if defined(CONFIG_OF)
 604
 605 #include <linux/of_device.h>
 606 #include <linux/of_gpio.h>
 607
 608 static const struct of_device_id sbs_dt_ids[] = {
 609         { .compatible = "sbs,sbs-battery" },
 610         { .compatible = "ti,bq20z75" },
 611         { }
 612 };
 613 MODULE_DEVICE_TABLE(of, sbs_dt_ids);
 614
 615 static struct sbs_platform_data *sbs_of_populate_pdata(
 616                 struct i2c_client *client)
 617 {
 618         struct device_node *of_node = client->dev.of_node;
 619         struct sbs_platform_data *pdata = client->dev.platform_data;
 620         enum of_gpio_flags gpio_flags;
 621         int rc;
 622         u32 prop;
 623
 624         /* verify this driver matches this device */
 625         if (!of_node)
 626                 return NULL;
 627
 628         /* if platform data is set, honor it */
 629         if (pdata)
 630                 return pdata;
 631
 632         /* first make sure at least one property is set, otherwise
 633          * it won't change behavior from running without pdata.
 634          */
 635         if (!of_get_property(of_node, "sbs,i2c-retry-count", NULL) &&
 636                 !of_get_property(of_node, "sbs,poll-retry-count", NULL) &&
 637                 !of_get_property(of_node, "sbs,battery-detect-gpios", NULL))
 638                 goto of_out;
 639
 640         pdata = devm_kzalloc(&client->dev, sizeof(struct sbs_platform_data),
 641                                 GFP_KERNEL);
 642         if (!pdata)
 643                 goto of_out;
 644
 645         rc = of_property_read_u32(of_node, "sbs,i2c-retry-count", &prop);
 646         if (!rc)
 647                 pdata->i2c_retry_count = prop;
 648
 649         rc = of_property_read_u32(of_node, "sbs,poll-retry-count", &prop);
 650         if (!rc)
 651                 pdata->poll_retry_count = prop;
 652
 653         if (!of_get_property(of_node, "sbs,battery-detect-gpios", NULL)) {
 654                 pdata->battery_detect = -1;
 655                 goto of_out;
 656         }
 657
 658         pdata->battery_detect = of_get_named_gpio_flags(of_node,
 659                         "sbs,battery-detect-gpios", 0, &gpio_flags);
 660
 661         if (gpio_flags & OF_GPIO_ACTIVE_LOW)
 662                 pdata->battery_detect_present = 0;
 663         else
 664                 pdata->battery_detect_present = 1;
 665
 666 of_out:
 667         return pdata;
 668 }
 669 #else
 670 #define sbs_dt_ids NULL
 671 static struct sbs_platform_data *sbs_of_populate_pdata(
 672         struct i2c_client *client)
 673 {
 674         return client->dev.platform_data;
 675 }
 676 #endif
 677
 678 static int __devinit sbs_probe(struct i2c_client *client,
 679         const struct i2c_device_id *id)
 680 {
 681         struct sbs_info *chip;
 682         struct sbs_platform_data *pdata = client->dev.platform_data;
 683         int rc;
 684         int irq;
 685         char *name;
 686
 687         name = kasprintf(GFP_KERNEL, "sbs-%s", dev_name(&client->dev));
 688         if (!name) {
 689                 dev_err(&client->dev, "Failed to allocate device name\n");
 690                 return -ENOMEM;
 691         }
 692
 693         chip = kzalloc(sizeof(struct sbs_info), GFP_KERNEL);
 694         if (!chip) {
 695                 rc = -ENOMEM;
 696                 goto exit_free_name;
 697         }
 698
 699         chip->client = client;
 700         chip->enable_detection = false;
 701         chip->gpio_detect = false;
 702         chip->power_supply.name = name;
 703         chip->power_supply.type = POWER_SUPPLY_TYPE_BATTERY;
 704         chip->power_supply.properties = sbs_properties;
 705         chip->power_supply.num_properties = ARRAY_SIZE(sbs_properties);
 706         chip->power_supply.get_property = sbs_get_property;
 707         /* ignore first notification of external change, it is generated
 708          * from the power_supply_register call back
 709          */
 710         chip->ignore_changes = 1;
 711         chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN;
 712         chip->power_supply.external_power_changed = sbs_external_power_changed;
 713
 714         pdata = sbs_of_populate_pdata(client);
 715
 716         if (pdata) {
 717                 chip->gpio_detect = gpio_is_valid(pdata->battery_detect);
 718                 chip->pdata = pdata;
 719         }
 720
 721         i2c_set_clientdata(client, chip);
 722
 723         if (!chip->gpio_detect)
 724                 goto skip_gpio;
 725
 726         rc = gpio_request(pdata->battery_detect, dev_name(&client->dev));
 727         if (rc) {
 728                 dev_warn(&client->dev, "Failed to request gpio: %d\n", rc);
 729                 chip->gpio_detect = false;
 730                 goto skip_gpio;
 731         }
 732
 733         rc = gpio_direction_input(pdata->battery_detect);
 734         if (rc) {
 735                 dev_warn(&client->dev, "Failed to get gpio as input: %d\n", rc);
 736                 gpio_free(pdata->battery_detect);
 737                 chip->gpio_detect = false;
 738                 goto skip_gpio;
 739         }
 740
 741         irq = gpio_to_irq(pdata->battery_detect);
 742         if (irq <= 0) {
 743                 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
 744                 gpio_free(pdata->battery_detect);
 745                 chip->gpio_detect = false;
 746                 goto skip_gpio;
 747         }
 748
 749         rc = request_irq(irq, sbs_irq,
 750                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 751                 dev_name(&client->dev), &chip->power_supply);
 752         if (rc) {
 753                 dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
 754                 gpio_free(pdata->battery_detect);
 755                 chip->gpio_detect = false;
 756                 goto skip_gpio;
 757         }
 758
 759         chip->irq = irq;
 760
 761 skip_gpio:
 762
 763         rc = power_supply_register(&client->dev, &chip->power_supply);
 764         if (rc) {
 765                 dev_err(&client->dev,
 766                         "%s: Failed to register power supply\n", __func__);
 767                 goto exit_psupply;
 768         }
 769
 770         dev_info(&client->dev,
 771                 "%s: battery gas gauge device registered\n", client->name);
 772
 773         INIT_DELAYED_WORK(&chip->work, sbs_delayed_work);
 774
 775         chip->enable_detection = true;
 776
 777         return 0;
 778
 779 exit_psupply:
 780         if (chip->irq)
 781                 free_irq(chip->irq, &chip->power_supply);
 782         if (chip->gpio_detect)
 783                 gpio_free(pdata->battery_detect);
 784
 785         kfree(chip);
 786
 787 exit_free_name:
 788         kfree(name);
 789
 790         return rc;
 791 }
 792
 793 static int __devexit sbs_remove(struct i2c_client *client)
 794 {
 795         struct sbs_info *chip = i2c_get_clientdata(client);
 796
 797         if (chip->irq)
 798                 free_irq(chip->irq, &chip->power_supply);
 799         if (chip->gpio_detect)
 800                 gpio_free(chip->pdata->battery_detect);
 801
 802         power_supply_unregister(&chip->power_supply);
 803
 804         cancel_delayed_work_sync(&chip->work);
 805
 806         kfree(chip->power_supply.name);
 807         kfree(chip);
 808         chip = NULL;
 809
 810         return 0;
 811 }
 812
 813 #if defined CONFIG_PM
 814 static int sbs_suspend(struct i2c_client *client,
 815         pm_message_t state)
 816 {
 817         struct sbs_info *chip = i2c_get_clientdata(client);
 818         s32 ret;
 819
 820         if (chip->poll_time > 0)
 821                 cancel_delayed_work_sync(&chip->work);
 822
 823         /* write to manufacturer access with sleep command */
 824         ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
 825                 MANUFACTURER_ACCESS_SLEEP);
 826         if (chip->is_present && ret < 0)
 827                 return ret;
 828
 829         return 0;
 830 }
 831 #else
 832 #define sbs_suspend             NULL
 833 #endif
 834 /* any smbus transaction will wake up sbs */
 835 #define sbs_resume              NULL
 836
 837 static const struct i2c_device_id sbs_id[] = {
 838         { "bq20z75", 0 },
 839         { "sbs-battery", 1 },
 840         {}
 841 };
 842 MODULE_DEVICE_TABLE(i2c, sbs_id);
 843
 844 static struct i2c_driver sbs_battery_driver = {
 845         .probe          = sbs_probe,
 846         .remove         = __devexit_p(sbs_remove),
 847         .suspend        = sbs_suspend,
 848         .resume         = sbs_resume,
 849         .id_table       = sbs_id,
 850         .driver = {
 851                 .name   = "sbs-battery",
 852                 .of_match_table = sbs_dt_ids,
 853         },
 854 };
 855
 856 static int __init sbs_battery_init(void)
 857 {
 858         return i2c_add_driver(&sbs_battery_driver);
 859 }
 860 module_init(sbs_battery_init);
 861
 862 static void __exit sbs_battery_exit(void)
 863 {
 864         i2c_del_driver(&sbs_battery_driver);
 865 }
 866 module_exit(sbs_battery_exit);
 867
 868 MODULE_DESCRIPTION("SBS battery monitor driver");
 869 MODULE_LICENSE("GPL");