drivers/power/supply/sbs-battery.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Gas Gauge driver for SBS Compliant Batteries
   4  *
   5  * Copyright (c) 2010, NVIDIA Corporation.
   6  */
   7
   8 #include <linux/bits.h>
   9 #include <linux/delay.h>
  10 #include <linux/err.h>
  11 #include <linux/gpio/consumer.h>
  12 #include <linux/i2c.h>
  13 #include <linux/init.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/property.h>
  18 #include <linux/of_device.h>
  19 #include <linux/power/sbs-battery.h>
  20 #include <linux/power_supply.h>
  21 #include <linux/slab.h>
  22 #include <linux/stat.h>
  23
  24 enum {
  25         REG_MANUFACTURER_DATA,
  26         REG_BATTERY_MODE,
  27         REG_TEMPERATURE,
  28         REG_VOLTAGE,
  29         REG_CURRENT_NOW,
  30         REG_CURRENT_AVG,
  31         REG_MAX_ERR,
  32         REG_CAPACITY,
  33         REG_TIME_TO_EMPTY,
  34         REG_TIME_TO_FULL,
  35         REG_STATUS,
  36         REG_CAPACITY_LEVEL,
  37         REG_CYCLE_COUNT,
  38         REG_SERIAL_NUMBER,
  39         REG_REMAINING_CAPACITY,
  40         REG_REMAINING_CAPACITY_CHARGE,
  41         REG_FULL_CHARGE_CAPACITY,
  42         REG_FULL_CHARGE_CAPACITY_CHARGE,
  43         REG_DESIGN_CAPACITY,
  44         REG_DESIGN_CAPACITY_CHARGE,
  45         REG_DESIGN_VOLTAGE_MIN,
  46         REG_DESIGN_VOLTAGE_MAX,
  47         REG_CHEMISTRY,
  48         REG_MANUFACTURER,
  49         REG_MODEL_NAME,
  50         REG_CHARGE_CURRENT,
  51         REG_CHARGE_VOLTAGE,
  52 };
  53
  54 #define REG_ADDR_SPEC_INFO              0x1A
  55 #define SPEC_INFO_VERSION_MASK          GENMASK(7, 4)
  56 #define SPEC_INFO_VERSION_SHIFT         4
  57
  58 #define SBS_VERSION_1_0                 1
  59 #define SBS_VERSION_1_1                 2
  60 #define SBS_VERSION_1_1_WITH_PEC        3
  61
  62 #define REG_ADDR_MANUFACTURE_DATE       0x1B
  63
  64 /* Battery Mode defines */
  65 #define BATTERY_MODE_OFFSET             0x03
  66 #define BATTERY_MODE_CAPACITY_MASK      BIT(15)
  67 enum sbs_capacity_mode {
  68         CAPACITY_MODE_AMPS = 0,
  69         CAPACITY_MODE_WATTS = BATTERY_MODE_CAPACITY_MASK
  70 };
  71 #define BATTERY_MODE_CHARGER_MASK       (1<<14)
  72
  73 /* manufacturer access defines */
  74 #define MANUFACTURER_ACCESS_STATUS      0x0006
  75 #define MANUFACTURER_ACCESS_SLEEP       0x0011
  76
  77 /* battery status value bits */
  78 #define BATTERY_INITIALIZED             0x80
  79 #define BATTERY_DISCHARGING             0x40
  80 #define BATTERY_FULL_CHARGED            0x20
  81 #define BATTERY_FULL_DISCHARGED         0x10
  82
  83 /* min_value and max_value are only valid for numerical data */
  84 #define SBS_DATA(_psp, _addr, _min_value, _max_value) { \
  85         .psp = _psp, \
  86         .addr = _addr, \
  87         .min_value = _min_value, \
  88         .max_value = _max_value, \
  89 }
  90
  91 static const struct chip_data {
  92         enum power_supply_property psp;
  93         u8 addr;
  94         int min_value;
  95         int max_value;
  96 } sbs_data[] = {
  97         [REG_MANUFACTURER_DATA] =
  98                 SBS_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),
  99         [REG_BATTERY_MODE] =
 100                 SBS_DATA(-1, 0x03, 0, 65535),
 101         [REG_TEMPERATURE] =
 102                 SBS_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),
 103         [REG_VOLTAGE] =
 104                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),
 105         [REG_CURRENT_NOW] =
 106                 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768, 32767),
 107         [REG_CURRENT_AVG] =
 108                 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_AVG, 0x0B, -32768, 32767),
 109         [REG_MAX_ERR] =
 110                 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY_ERROR_MARGIN, 0x0c, 0, 100),
 111         [REG_CAPACITY] =
 112                 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0D, 0, 100),
 113         [REG_REMAINING_CAPACITY] =
 114                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
 115         [REG_REMAINING_CAPACITY_CHARGE] =
 116                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
 117         [REG_FULL_CHARGE_CAPACITY] =
 118                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
 119         [REG_FULL_CHARGE_CAPACITY_CHARGE] =
 120                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
 121         [REG_TIME_TO_EMPTY] =
 122                 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 65535),
 123         [REG_TIME_TO_FULL] =
 124                 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0, 65535),
 125         [REG_CHARGE_CURRENT] =
 126                 SBS_DATA(POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, 0x14, 0, 65535),
 127         [REG_CHARGE_VOLTAGE] =
 128                 SBS_DATA(POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, 0x15, 0, 65535),
 129         [REG_STATUS] =
 130                 SBS_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),
 131         [REG_CAPACITY_LEVEL] =
 132                 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY_LEVEL, 0x16, 0, 65535),
 133         [REG_CYCLE_COUNT] =
 134                 SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),
 135         [REG_DESIGN_CAPACITY] =
 136                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 65535),
 137         [REG_DESIGN_CAPACITY_CHARGE] =
 138                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0, 65535),
 139         [REG_DESIGN_VOLTAGE_MIN] =
 140                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 0x19, 0, 65535),
 141         [REG_DESIGN_VOLTAGE_MAX] =
 142                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 65535),
 143         [REG_SERIAL_NUMBER] =
 144                 SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),
 145         /* Properties of type `const char *' */
 146         [REG_MANUFACTURER] =
 147                 SBS_DATA(POWER_SUPPLY_PROP_MANUFACTURER, 0x20, 0, 65535),
 148         [REG_MODEL_NAME] =
 149                 SBS_DATA(POWER_SUPPLY_PROP_MODEL_NAME, 0x21, 0, 65535),
 150         [REG_CHEMISTRY] =
 151                 SBS_DATA(POWER_SUPPLY_PROP_TECHNOLOGY, 0x22, 0, 65535)
 152 };
 153
 154 static const enum power_supply_property sbs_properties[] = {
 155         POWER_SUPPLY_PROP_STATUS,
 156         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
 157         POWER_SUPPLY_PROP_HEALTH,
 158         POWER_SUPPLY_PROP_PRESENT,
 159         POWER_SUPPLY_PROP_TECHNOLOGY,
 160         POWER_SUPPLY_PROP_CYCLE_COUNT,
 161         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 162         POWER_SUPPLY_PROP_CURRENT_NOW,
 163         POWER_SUPPLY_PROP_CURRENT_AVG,
 164         POWER_SUPPLY_PROP_CAPACITY,
 165         POWER_SUPPLY_PROP_CAPACITY_ERROR_MARGIN,
 166         POWER_SUPPLY_PROP_TEMP,
 167         POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
 168         POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
 169         POWER_SUPPLY_PROP_SERIAL_NUMBER,
 170         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 171         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 172         POWER_SUPPLY_PROP_ENERGY_NOW,
 173         POWER_SUPPLY_PROP_ENERGY_FULL,
 174         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
 175         POWER_SUPPLY_PROP_CHARGE_NOW,
 176         POWER_SUPPLY_PROP_CHARGE_FULL,
 177         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 178         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 179         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 180         POWER_SUPPLY_PROP_MANUFACTURE_YEAR,
 181         POWER_SUPPLY_PROP_MANUFACTURE_MONTH,
 182         POWER_SUPPLY_PROP_MANUFACTURE_DAY,
 183         /* Properties of type `const char *' */
 184         POWER_SUPPLY_PROP_MANUFACTURER,
 185         POWER_SUPPLY_PROP_MODEL_NAME
 186 };
 187
 188 /* Supports special manufacturer commands from TI BQ20Z65 and BQ20Z75 IC. */
 189 #define SBS_FLAGS_TI_BQ20ZX5            BIT(0)
 190
 191 struct sbs_info {
 192         struct i2c_client               *client;
 193         struct power_supply             *power_supply;
 194         bool                            is_present;
 195         struct gpio_desc                *gpio_detect;
 196         bool                            enable_detection;
 197         bool                            charger_broadcasts;
 198         int                             last_state;
 199         int                             poll_time;
 200         u32                             i2c_retry_count;
 201         u32                             poll_retry_count;
 202         struct delayed_work             work;
 203         struct mutex                    mode_lock;
 204         u32                             flags;
 205 };
 206
 207 static char model_name[I2C_SMBUS_BLOCK_MAX + 1];
 208 static char manufacturer[I2C_SMBUS_BLOCK_MAX + 1];
 209 static char chemistry[I2C_SMBUS_BLOCK_MAX + 1];
 210 static bool force_load;
 211
 212 static int sbs_read_word_data(struct i2c_client *client, u8 address);
 213 static int sbs_write_word_data(struct i2c_client *client, u8 address, u16 value);
 214
 215 static void sbs_disable_charger_broadcasts(struct sbs_info *chip)
 216 {
 217         int val = sbs_read_word_data(chip->client, BATTERY_MODE_OFFSET);
 218         if (val < 0)
 219                 goto exit;
 220
 221         val |= BATTERY_MODE_CHARGER_MASK;
 222
 223         val = sbs_write_word_data(chip->client, BATTERY_MODE_OFFSET, val);
 224
 225 exit:
 226         if (val < 0)
 227                 dev_err(&chip->client->dev,
 228                         "Failed to disable charger broadcasting: %d\n", val);
 229         else
 230                 dev_dbg(&chip->client->dev, "%s\n", __func__);
 231 }
 232
 233 static int sbs_update_presence(struct sbs_info *chip, bool is_present)
 234 {
 235         struct i2c_client *client = chip->client;
 236         int retries = chip->i2c_retry_count;
 237         s32 ret = 0;
 238         u8 version;
 239
 240         if (chip->is_present == is_present)
 241                 return 0;
 242
 243         if (!is_present) {
 244                 chip->is_present = false;
 245                 /* Disable PEC when no device is present */
 246                 client->flags &= ~I2C_CLIENT_PEC;
 247                 return 0;
 248         }
 249
 250         /* Check if device supports packet error checking and use it */
 251         while (retries > 0) {
 252                 ret = i2c_smbus_read_word_data(client, REG_ADDR_SPEC_INFO);
 253                 if (ret >= 0)
 254                         break;
 255
 256                 /*
 257                  * Some batteries trigger the detection pin before the
 258                  * I2C bus is properly connected. This works around the
 259                  * issue.
 260                  */
 261                 msleep(100);
 262
 263                 retries--;
 264         }
 265
 266         if (ret < 0) {
 267                 dev_dbg(&client->dev, "failed to read spec info: %d\n", ret);
 268
 269                 /* fallback to old behaviour */
 270                 client->flags &= ~I2C_CLIENT_PEC;
 271                 chip->is_present = true;
 272
 273                 return ret;
 274         }
 275
 276         version = (ret & SPEC_INFO_VERSION_MASK) >> SPEC_INFO_VERSION_SHIFT;
 277
 278         if (version == SBS_VERSION_1_1_WITH_PEC)
 279                 client->flags |= I2C_CLIENT_PEC;
 280         else
 281                 client->flags &= ~I2C_CLIENT_PEC;
 282
 283         dev_dbg(&client->dev, "PEC: %s\n", (client->flags & I2C_CLIENT_PEC) ?
 284                 "enabled" : "disabled");
 285
 286         if (!chip->is_present && is_present && !chip->charger_broadcasts)
 287                 sbs_disable_charger_broadcasts(chip);
 288
 289         chip->is_present = true;
 290
 291         return 0;
 292 }
 293
 294 static int sbs_read_word_data(struct i2c_client *client, u8 address)
 295 {
 296         struct sbs_info *chip = i2c_get_clientdata(client);
 297         int retries = chip->i2c_retry_count;
 298         s32 ret = 0;
 299
 300         while (retries > 0) {
 301                 ret = i2c_smbus_read_word_data(client, address);
 302                 if (ret >= 0)
 303                         break;
 304                 retries--;
 305         }
 306
 307         if (ret < 0) {
 308                 dev_dbg(&client->dev,
 309                         "%s: i2c read at address 0x%x failed\n",
 310                         __func__, address);
 311                 return ret;
 312         }
 313
 314         return ret;
 315 }
 316
 317 static int sbs_read_string_data_fallback(struct i2c_client *client, u8 address, char *values)
 318 {
 319         struct sbs_info *chip = i2c_get_clientdata(client);
 320         s32 ret = 0, block_length = 0;
 321         int retries_length, retries_block;
 322         u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
 323
 324         retries_length = chip->i2c_retry_count;
 325         retries_block = chip->i2c_retry_count;
 326
 327         dev_warn_once(&client->dev, "I2C adapter does not support I2C_FUNC_SMBUS_READ_BLOCK_DATA.\n"
 328                                     "Fallback method does not support PEC.\n");
 329
 330         /* Adapter needs to support these two functions */
 331         if (!i2c_check_functionality(client->adapter,
 332                                      I2C_FUNC_SMBUS_BYTE_DATA |
 333                                      I2C_FUNC_SMBUS_I2C_BLOCK)){
 334                 return -ENODEV;
 335         }
 336
 337         /* Get the length of block data */
 338         while (retries_length > 0) {
 339                 ret = i2c_smbus_read_byte_data(client, address);
 340                 if (ret >= 0)
 341                         break;
 342                 retries_length--;
 343         }
 344
 345         if (ret < 0) {
 346                 dev_dbg(&client->dev,
 347                         "%s: i2c read at address 0x%x failed\n",
 348                         __func__, address);
 349                 return ret;
 350         }
 351
 352         /* block_length does not include NULL terminator */
 353         block_length = ret;
 354         if (block_length > I2C_SMBUS_BLOCK_MAX) {
 355                 dev_err(&client->dev,
 356                         "%s: Returned block_length is longer than 0x%x\n",
 357                         __func__, I2C_SMBUS_BLOCK_MAX);
 358                 return -EINVAL;
 359         }
 360
 361         /* Get the block data */
 362         while (retries_block > 0) {
 363                 ret = i2c_smbus_read_i2c_block_data(
 364                                 client, address,
 365                                 block_length + 1, block_buffer);
 366                 if (ret >= 0)
 367                         break;
 368                 retries_block--;
 369         }
 370
 371         if (ret < 0) {
 372                 dev_dbg(&client->dev,
 373                         "%s: i2c read at address 0x%x failed\n",
 374                         __func__, address);
 375                 return ret;
 376         }
 377
 378         /* block_buffer[0] == block_length */
 379         memcpy(values, block_buffer + 1, block_length);
 380         values[block_length] = '\0';
 381
 382         return ret;
 383 }
 384
 385 static int sbs_read_string_data(struct i2c_client *client, u8 address, char *values)
 386 {
 387         struct sbs_info *chip = i2c_get_clientdata(client);
 388         int retries = chip->i2c_retry_count;
 389         int ret = 0;
 390
 391         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BLOCK_DATA)) {
 392                 bool pec = client->flags & I2C_CLIENT_PEC;
 393                 client->flags &= ~I2C_CLIENT_PEC;
 394                 ret = sbs_read_string_data_fallback(client, address, values);
 395                 if (pec)
 396                         client->flags |= I2C_CLIENT_PEC;
 397                 return ret;
 398         }
 399
 400         while (retries > 0) {
 401                 ret = i2c_smbus_read_block_data(client, address, values);
 402                 if (ret >= 0)
 403                         break;
 404                 retries--;
 405         }
 406
 407         if (ret < 0) {
 408                 dev_dbg(&client->dev, "failed to read block 0x%x: %d\n", address, ret);
 409                 return ret;
 410         }
 411
 412         /* add string termination */
 413         values[ret] = '\0';
 414         return ret;
 415 }
 416
 417 static int sbs_write_word_data(struct i2c_client *client, u8 address,
 418         u16 value)
 419 {
 420         struct sbs_info *chip = i2c_get_clientdata(client);
 421         int retries = chip->i2c_retry_count;
 422         s32 ret = 0;
 423
 424         while (retries > 0) {
 425                 ret = i2c_smbus_write_word_data(client, address, value);
 426                 if (ret >= 0)
 427                         break;
 428                 retries--;
 429         }
 430
 431         if (ret < 0) {
 432                 dev_dbg(&client->dev,
 433                         "%s: i2c write to address 0x%x failed\n",
 434                         __func__, address);
 435                 return ret;
 436         }
 437
 438         return 0;
 439 }
 440
 441 static int sbs_status_correct(struct i2c_client *client, int *intval)
 442 {
 443         int ret;
 444
 445         ret = sbs_read_word_data(client, sbs_data[REG_CURRENT_NOW].addr);
 446         if (ret < 0)
 447                 return ret;
 448
 449         ret = (s16)ret;
 450
 451         /* Not drawing current -> not charging (i.e. idle) */
 452         if (*intval != POWER_SUPPLY_STATUS_FULL && ret == 0)
 453                 *intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 454
 455         if (*intval == POWER_SUPPLY_STATUS_FULL) {
 456                 /* Drawing or providing current when full */
 457                 if (ret > 0)
 458                         *intval = POWER_SUPPLY_STATUS_CHARGING;
 459                 else if (ret < 0)
 460                         *intval = POWER_SUPPLY_STATUS_DISCHARGING;
 461         }
 462
 463         return 0;
 464 }
 465
 466 static bool sbs_bat_needs_calibration(struct i2c_client *client)
 467 {
 468         int ret;
 469
 470         ret = sbs_read_word_data(client, sbs_data[REG_BATTERY_MODE].addr);
 471         if (ret < 0)
 472                 return false;
 473
 474         return !!(ret & BIT(7));
 475 }
 476
 477 static int sbs_get_battery_presence_and_health(
 478         struct i2c_client *client, enum power_supply_property psp,
 479         union power_supply_propval *val)
 480 {
 481         int ret;
 482
 483         /* Dummy command; if it succeeds, battery is present. */
 484         ret = sbs_read_word_data(client, sbs_data[REG_STATUS].addr);
 485
 486         if (ret < 0) { /* battery not present*/
 487                 if (psp == POWER_SUPPLY_PROP_PRESENT) {
 488                         val->intval = 0;
 489                         return 0;
 490                 }
 491                 return ret;
 492         }
 493
 494         if (psp == POWER_SUPPLY_PROP_PRESENT)
 495                 val->intval = 1; /* battery present */
 496         else { /* POWER_SUPPLY_PROP_HEALTH */
 497                 if (sbs_bat_needs_calibration(client)) {
 498                         val->intval = POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED;
 499                 } else {
 500                         /* SBS spec doesn't have a general health command. */
 501                         val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
 502                 }
 503         }
 504
 505         return 0;
 506 }
 507
 508 static int sbs_get_ti_battery_presence_and_health(
 509         struct i2c_client *client, enum power_supply_property psp,
 510         union power_supply_propval *val)
 511 {
 512         s32 ret;
 513
 514         /*
 515          * Write to ManufacturerAccess with ManufacturerAccess command
 516          * and then read the status.
 517          */
 518         ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
 519                                   MANUFACTURER_ACCESS_STATUS);
 520         if (ret < 0) {
 521                 if (psp == POWER_SUPPLY_PROP_PRESENT)
 522                         val->intval = 0; /* battery removed */
 523                 return ret;
 524         }
 525
 526         ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr);
 527         if (ret < 0) {
 528                 if (psp == POWER_SUPPLY_PROP_PRESENT)
 529                         val->intval = 0; /* battery removed */
 530                 return ret;
 531         }
 532
 533         if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value ||
 534             ret > sbs_data[REG_MANUFACTURER_DATA].max_value) {
 535                 val->intval = 0;
 536                 return 0;
 537         }
 538
 539         /* Mask the upper nibble of 2nd byte and
 540          * lower byte of response then
 541          * shift the result by 8 to get status*/
 542         ret &= 0x0F00;
 543         ret >>= 8;
 544         if (psp == POWER_SUPPLY_PROP_PRESENT) {
 545                 if (ret == 0x0F)
 546                         /* battery removed */
 547                         val->intval = 0;
 548                 else
 549                         val->intval = 1;
 550         } else if (psp == POWER_SUPPLY_PROP_HEALTH) {
 551                 if (ret == 0x09)
 552                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 553                 else if (ret == 0x0B)
 554                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 555                 else if (ret == 0x0C)
 556                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
 557                 else if (sbs_bat_needs_calibration(client))
 558                         val->intval = POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED;
 559                 else
 560                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 561         }
 562
 563         return 0;
 564 }
 565
 566 static int sbs_get_battery_property(struct i2c_client *client,
 567         int reg_offset, enum power_supply_property psp,
 568         union power_supply_propval *val)
 569 {
 570         struct sbs_info *chip = i2c_get_clientdata(client);
 571         s32 ret;
 572
 573         ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
 574         if (ret < 0)
 575                 return ret;
 576
 577         /* returned values are 16 bit */
 578         if (sbs_data[reg_offset].min_value < 0)
 579                 ret = (s16)ret;
 580
 581         if (ret >= sbs_data[reg_offset].min_value &&
 582             ret <= sbs_data[reg_offset].max_value) {
 583                 val->intval = ret;
 584                 if (psp == POWER_SUPPLY_PROP_CAPACITY_LEVEL) {
 585                         if (!(ret & BATTERY_INITIALIZED))
 586                                 val->intval =
 587                                         POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
 588                         else if (ret & BATTERY_FULL_CHARGED)
 589                                 val->intval =
 590                                         POWER_SUPPLY_CAPACITY_LEVEL_FULL;
 591                         else if (ret & BATTERY_FULL_DISCHARGED)
 592                                 val->intval =
 593                                         POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
 594                         else
 595                                 val->intval =
 596                                         POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
 597                         return 0;
 598                 } else if (psp != POWER_SUPPLY_PROP_STATUS) {
 599                         return 0;
 600                 }
 601
 602                 if (ret & BATTERY_FULL_CHARGED)
 603                         val->intval = POWER_SUPPLY_STATUS_FULL;
 604                 else if (ret & BATTERY_DISCHARGING)
 605                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 606                 else
 607                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 608
 609                 sbs_status_correct(client, &val->intval);
 610
 611                 if (chip->poll_time == 0)
 612                         chip->last_state = val->intval;
 613                 else if (chip->last_state != val->intval) {
 614                         cancel_delayed_work_sync(&chip->work);
 615                         power_supply_changed(chip->power_supply);
 616                         chip->poll_time = 0;
 617                 }
 618         } else {
 619                 if (psp == POWER_SUPPLY_PROP_STATUS)
 620                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 621                 else if (psp == POWER_SUPPLY_PROP_CAPACITY)
 622                         /* sbs spec says that this can be >100 %
 623                          * even if max value is 100 %
 624                          */
 625                         val->intval = min(ret, 100);
 626                 else
 627                         val->intval = 0;
 628         }
 629
 630         return 0;
 631 }
 632
 633 static int sbs_get_battery_string_property(struct i2c_client *client,
 634         int reg_offset, enum power_supply_property psp, char *val)
 635 {
 636         s32 ret;
 637
 638         ret = sbs_read_string_data(client, sbs_data[reg_offset].addr, val);
 639
 640         if (ret < 0)
 641                 return ret;
 642
 643         return 0;
 644 }
 645
 646 static void  sbs_unit_adjustment(struct i2c_client *client,
 647         enum power_supply_property psp, union power_supply_propval *val)
 648 {
 649 #define BASE_UNIT_CONVERSION            1000
 650 #define BATTERY_MODE_CAP_MULT_WATT      (10 * BASE_UNIT_CONVERSION)
 651 #define TIME_UNIT_CONVERSION            60
 652 #define TEMP_KELVIN_TO_CELSIUS          2731
 653         switch (psp) {
 654         case POWER_SUPPLY_PROP_ENERGY_NOW:
 655         case POWER_SUPPLY_PROP_ENERGY_FULL:
 656         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 657                 /* sbs provides energy in units of 10mWh.
 658                  * Convert to µWh
 659                  */
 660                 val->intval *= BATTERY_MODE_CAP_MULT_WATT;
 661                 break;
 662
 663         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 664         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 665         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 666         case POWER_SUPPLY_PROP_CURRENT_NOW:
 667         case POWER_SUPPLY_PROP_CURRENT_AVG:
 668         case POWER_SUPPLY_PROP_CHARGE_NOW:
 669         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 670         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 671         case POWER_SUPPLY_PROP_CHARGE_FULL:
 672         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 673                 val->intval *= BASE_UNIT_CONVERSION;
 674                 break;
 675
 676         case POWER_SUPPLY_PROP_TEMP:
 677                 /* sbs provides battery temperature in 0.1K
 678                  * so convert it to 0.1°C
 679                  */
 680                 val->intval -= TEMP_KELVIN_TO_CELSIUS;
 681                 break;
 682
 683         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 684         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
 685                 /* sbs provides time to empty and time to full in minutes.
 686                  * Convert to seconds
 687                  */
 688                 val->intval *= TIME_UNIT_CONVERSION;
 689                 break;
 690
 691         default:
 692                 dev_dbg(&client->dev,
 693                         "%s: no need for unit conversion %d\n", __func__, psp);
 694         }
 695 }
 696
 697 static enum sbs_capacity_mode sbs_set_capacity_mode(struct i2c_client *client,
 698         enum sbs_capacity_mode mode)
 699 {
 700         int ret, original_val;
 701
 702         original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET);
 703         if (original_val < 0)
 704                 return original_val;
 705
 706         if ((original_val & BATTERY_MODE_CAPACITY_MASK) == mode)
 707                 return mode;
 708
 709         if (mode == CAPACITY_MODE_AMPS)
 710                 ret = original_val & ~BATTERY_MODE_CAPACITY_MASK;
 711         else
 712                 ret = original_val | BATTERY_MODE_CAPACITY_MASK;
 713
 714         ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret);
 715         if (ret < 0)
 716                 return ret;
 717
 718         usleep_range(1000, 2000);
 719
 720         return original_val & BATTERY_MODE_CAPACITY_MASK;
 721 }
 722
 723 static int sbs_get_battery_capacity(struct i2c_client *client,
 724         int reg_offset, enum power_supply_property psp,
 725         union power_supply_propval *val)
 726 {
 727         s32 ret;
 728         enum sbs_capacity_mode mode = CAPACITY_MODE_WATTS;
 729
 730         if (power_supply_is_amp_property(psp))
 731                 mode = CAPACITY_MODE_AMPS;
 732
 733         mode = sbs_set_capacity_mode(client, mode);
 734         if ((int)mode < 0)
 735                 return mode;
 736
 737         ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
 738         if (ret < 0)
 739                 return ret;
 740
 741         val->intval = ret;
 742
 743         ret = sbs_set_capacity_mode(client, mode);
 744         if (ret < 0)
 745                 return ret;
 746
 747         return 0;
 748 }
 749
 750 static char sbs_serial[5];
 751 static int sbs_get_battery_serial_number(struct i2c_client *client,
 752         union power_supply_propval *val)
 753 {
 754         int ret;
 755
 756         ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr);
 757         if (ret < 0)
 758                 return ret;
 759
 760         sprintf(sbs_serial, "%04x", ret);
 761         val->strval = sbs_serial;
 762
 763         return 0;
 764 }
 765
 766 static int sbs_get_property_index(struct i2c_client *client,
 767         enum power_supply_property psp)
 768 {
 769         int count;
 770         for (count = 0; count < ARRAY_SIZE(sbs_data); count++)
 771                 if (psp == sbs_data[count].psp)
 772                         return count;
 773
 774         dev_warn(&client->dev,
 775                 "%s: Invalid Property - %d\n", __func__, psp);
 776
 777         return -EINVAL;
 778 }
 779
 780 static int sbs_get_chemistry(struct i2c_client *client,
 781                 union power_supply_propval *val)
 782 {
 783         enum power_supply_property psp = POWER_SUPPLY_PROP_TECHNOLOGY;
 784         int ret;
 785
 786         ret = sbs_get_property_index(client, psp);
 787         if (ret < 0)
 788                 return ret;
 789
 790         ret = sbs_get_battery_string_property(client, ret, psp,
 791                                               chemistry);
 792         if (ret < 0)
 793                 return ret;
 794
 795         if (!strncasecmp(chemistry, "LION", 4))
 796                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 797         else if (!strncasecmp(chemistry, "LiP", 3))
 798                 val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO;
 799         else if (!strncasecmp(chemistry, "NiCd", 4))
 800                 val->intval = POWER_SUPPLY_TECHNOLOGY_NiCd;
 801         else if (!strncasecmp(chemistry, "NiMH", 4))
 802                 val->intval = POWER_SUPPLY_TECHNOLOGY_NiMH;
 803         else
 804                 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
 805
 806         if (val->intval == POWER_SUPPLY_TECHNOLOGY_UNKNOWN)
 807                 dev_warn(&client->dev, "Unknown chemistry: %s\n", chemistry);
 808
 809         return 0;
 810 }
 811
 812 static int sbs_get_battery_manufacture_date(struct i2c_client *client,
 813         enum power_supply_property psp,
 814         union power_supply_propval *val)
 815 {
 816         int ret;
 817         u16 day, month, year;
 818
 819         ret = sbs_read_word_data(client, REG_ADDR_MANUFACTURE_DATE);
 820         if (ret < 0)
 821                 return ret;
 822
 823         day   = ret   & GENMASK(4,  0);
 824         month = (ret  & GENMASK(8,  5)) >> 5;
 825         year  = ((ret & GENMASK(15, 9)) >> 9) + 1980;
 826
 827         switch (psp) {
 828         case POWER_SUPPLY_PROP_MANUFACTURE_YEAR:
 829                 val->intval = year;
 830                 break;
 831         case POWER_SUPPLY_PROP_MANUFACTURE_MONTH:
 832                 val->intval = month;
 833                 break;
 834         case POWER_SUPPLY_PROP_MANUFACTURE_DAY:
 835                 val->intval = day;
 836                 break;
 837         default:
 838                 return -EINVAL;
 839         }
 840
 841         return 0;
 842 }
 843
 844 static int sbs_get_property(struct power_supply *psy,
 845         enum power_supply_property psp,
 846         union power_supply_propval *val)
 847 {
 848         int ret = 0;
 849         struct sbs_info *chip = power_supply_get_drvdata(psy);
 850         struct i2c_client *client = chip->client;
 851
 852         if (chip->gpio_detect) {
 853                 ret = gpiod_get_value_cansleep(chip->gpio_detect);
 854                 if (ret < 0)
 855                         return ret;
 856                 if (psp == POWER_SUPPLY_PROP_PRESENT) {
 857                         val->intval = ret;
 858                         sbs_update_presence(chip, ret);
 859                         return 0;
 860                 }
 861                 if (ret == 0)
 862                         return -ENODATA;
 863         }
 864
 865         switch (psp) {
 866         case POWER_SUPPLY_PROP_PRESENT:
 867         case POWER_SUPPLY_PROP_HEALTH:
 868                 if (chip->flags & SBS_FLAGS_TI_BQ20ZX5)
 869                         ret = sbs_get_ti_battery_presence_and_health(client,
 870                                                                      psp, val);
 871                 else
 872                         ret = sbs_get_battery_presence_and_health(client, psp,
 873                                                                   val);
 874
 875                 /* this can only be true if no gpio is used */
 876                 if (psp == POWER_SUPPLY_PROP_PRESENT)
 877                         return 0;
 878                 break;
 879
 880         case POWER_SUPPLY_PROP_TECHNOLOGY:
 881                 ret = sbs_get_chemistry(client, val);
 882                 if (ret < 0)
 883                         break;
 884
 885                 goto done; /* don't trigger power_supply_changed()! */
 886
 887         case POWER_SUPPLY_PROP_ENERGY_NOW:
 888         case POWER_SUPPLY_PROP_ENERGY_FULL:
 889         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
 890         case POWER_SUPPLY_PROP_CHARGE_NOW:
 891         case POWER_SUPPLY_PROP_CHARGE_FULL:
 892         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 893                 ret = sbs_get_property_index(client, psp);
 894                 if (ret < 0)
 895                         break;
 896
 897                 /* sbs_get_battery_capacity() will change the battery mode
 898                  * temporarily to read the requested attribute. Ensure we stay
 899                  * in the desired mode for the duration of the attribute read.
 900                  */
 901                 mutex_lock(&chip->mode_lock);
 902                 ret = sbs_get_battery_capacity(client, ret, psp, val);
 903                 mutex_unlock(&chip->mode_lock);
 904                 break;
 905
 906         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 907                 ret = sbs_get_battery_serial_number(client, val);
 908                 break;
 909
 910         case POWER_SUPPLY_PROP_STATUS:
 911         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
 912         case POWER_SUPPLY_PROP_CYCLE_COUNT:
 913         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 914         case POWER_SUPPLY_PROP_CURRENT_NOW:
 915         case POWER_SUPPLY_PROP_CURRENT_AVG:
 916         case POWER_SUPPLY_PROP_TEMP:
 917         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
 918         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
 919         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 920         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 921         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 922         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 923         case POWER_SUPPLY_PROP_CAPACITY:
 924         case POWER_SUPPLY_PROP_CAPACITY_ERROR_MARGIN:
 925                 ret = sbs_get_property_index(client, psp);
 926                 if (ret < 0)
 927                         break;
 928
 929                 ret = sbs_get_battery_property(client, ret, psp, val);
 930                 break;
 931
 932         case POWER_SUPPLY_PROP_MODEL_NAME:
 933                 ret = sbs_get_property_index(client, psp);
 934                 if (ret < 0)
 935                         break;
 936
 937                 ret = sbs_get_battery_string_property(client, ret, psp,
 938                                                       model_name);
 939                 val->strval = model_name;
 940                 break;
 941
 942         case POWER_SUPPLY_PROP_MANUFACTURER:
 943                 ret = sbs_get_property_index(client, psp);
 944                 if (ret < 0)
 945                         break;
 946
 947                 ret = sbs_get_battery_string_property(client, ret, psp,
 948                                                       manufacturer);
 949                 val->strval = manufacturer;
 950                 break;
 951
 952         case POWER_SUPPLY_PROP_MANUFACTURE_YEAR:
 953         case POWER_SUPPLY_PROP_MANUFACTURE_MONTH:
 954         case POWER_SUPPLY_PROP_MANUFACTURE_DAY:
 955                 ret = sbs_get_battery_manufacture_date(client, psp, val);
 956                 break;
 957
 958         default:
 959                 dev_err(&client->dev,
 960                         "%s: INVALID property\n", __func__);
 961                 return -EINVAL;
 962         }
 963
 964         if (!chip->enable_detection)
 965                 goto done;
 966
 967         if (!chip->gpio_detect &&
 968                 chip->is_present != (ret >= 0)) {
 969                 sbs_update_presence(chip, (ret >= 0));
 970                 power_supply_changed(chip->power_supply);
 971         }
 972
 973 done:
 974         if (!ret) {
 975                 /* Convert units to match requirements for power supply class */
 976                 sbs_unit_adjustment(client, psp, val);
 977         }
 978
 979         dev_dbg(&client->dev,
 980                 "%s: property = %d, value = %x\n", __func__, psp, val->intval);
 981
 982         if (ret && chip->is_present)
 983                 return ret;
 984
 985         /* battery not present, so return NODATA for properties */
 986         if (ret)
 987                 return -ENODATA;
 988
 989         return 0;
 990 }
 991
 992 static void sbs_supply_changed(struct sbs_info *chip)
 993 {
 994         struct power_supply *battery = chip->power_supply;
 995         int ret;
 996
 997         ret = gpiod_get_value_cansleep(chip->gpio_detect);
 998         if (ret < 0)
 999                 return;
1000         sbs_update_presence(chip, ret);
1001         power_supply_changed(battery);
1002 }
1003
1004 static irqreturn_t sbs_irq(int irq, void *devid)
1005 {
1006         sbs_supply_changed(devid);
1007         return IRQ_HANDLED;
1008 }
1009
1010 static void sbs_alert(struct i2c_client *client, enum i2c_alert_protocol prot,
1011         unsigned int data)
1012 {
1013         sbs_supply_changed(i2c_get_clientdata(client));
1014 }
1015
1016 static void sbs_external_power_changed(struct power_supply *psy)
1017 {
1018         struct sbs_info *chip = power_supply_get_drvdata(psy);
1019
1020         /* cancel outstanding work */
1021         cancel_delayed_work_sync(&chip->work);
1022
1023         schedule_delayed_work(&chip->work, HZ);
1024         chip->poll_time = chip->poll_retry_count;
1025 }
1026
1027 static void sbs_delayed_work(struct work_struct *work)
1028 {
1029         struct sbs_info *chip;
1030         s32 ret;
1031
1032         chip = container_of(work, struct sbs_info, work.work);
1033
1034         ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr);
1035         /* if the read failed, give up on this work */
1036         if (ret < 0) {
1037                 chip->poll_time = 0;
1038                 return;
1039         }
1040
1041         if (ret & BATTERY_FULL_CHARGED)
1042                 ret = POWER_SUPPLY_STATUS_FULL;
1043         else if (ret & BATTERY_DISCHARGING)
1044                 ret = POWER_SUPPLY_STATUS_DISCHARGING;
1045         else
1046                 ret = POWER_SUPPLY_STATUS_CHARGING;
1047
1048         sbs_status_correct(chip->client, &ret);
1049
1050         if (chip->last_state != ret) {
1051                 chip->poll_time = 0;
1052                 power_supply_changed(chip->power_supply);
1053                 return;
1054         }
1055         if (chip->poll_time > 0) {
1056                 schedule_delayed_work(&chip->work, HZ);
1057                 chip->poll_time--;
1058                 return;
1059         }
1060 }
1061
1062 static const struct power_supply_desc sbs_default_desc = {
1063         .type = POWER_SUPPLY_TYPE_BATTERY,
1064         .properties = sbs_properties,
1065         .num_properties = ARRAY_SIZE(sbs_properties),
1066         .get_property = sbs_get_property,
1067         .external_power_changed = sbs_external_power_changed,
1068 };
1069
1070 static int sbs_probe(struct i2c_client *client)
1071 {
1072         struct sbs_info *chip;
1073         struct power_supply_desc *sbs_desc;
1074         struct sbs_platform_data *pdata = client->dev.platform_data;
1075         struct power_supply_config psy_cfg = {};
1076         int rc;
1077         int irq;
1078
1079         sbs_desc = devm_kmemdup(&client->dev, &sbs_default_desc,
1080                         sizeof(*sbs_desc), GFP_KERNEL);
1081         if (!sbs_desc)
1082                 return -ENOMEM;
1083
1084         sbs_desc->name = devm_kasprintf(&client->dev, GFP_KERNEL, "sbs-%s",
1085                         dev_name(&client->dev));
1086         if (!sbs_desc->name)
1087                 return -ENOMEM;
1088
1089         chip = devm_kzalloc(&client->dev, sizeof(struct sbs_info), GFP_KERNEL);
1090         if (!chip)
1091                 return -ENOMEM;
1092
1093         chip->flags = (u32)(uintptr_t)device_get_match_data(&client->dev);
1094         chip->client = client;
1095         chip->enable_detection = false;
1096         psy_cfg.of_node = client->dev.of_node;
1097         psy_cfg.drv_data = chip;
1098         chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN;
1099         mutex_init(&chip->mode_lock);
1100
1101         /* use pdata if available, fall back to DT properties,
1102          * or hardcoded defaults if not
1103          */
1104         rc = device_property_read_u32(&client->dev, "sbs,i2c-retry-count",
1105                                       &chip->i2c_retry_count);
1106         if (rc)
1107                 chip->i2c_retry_count = 0;
1108
1109         rc = device_property_read_u32(&client->dev, "sbs,poll-retry-count",
1110                                       &chip->poll_retry_count);
1111         if (rc)
1112                 chip->poll_retry_count = 0;
1113
1114         if (pdata) {
1115                 chip->poll_retry_count = pdata->poll_retry_count;
1116                 chip->i2c_retry_count  = pdata->i2c_retry_count;
1117         }
1118         chip->i2c_retry_count = chip->i2c_retry_count + 1;
1119
1120         chip->charger_broadcasts = !device_property_read_bool(&client->dev,
1121                                         "sbs,disable-charger-broadcasts");
1122
1123         chip->gpio_detect = devm_gpiod_get_optional(&client->dev,
1124                         "sbs,battery-detect", GPIOD_IN);
1125         if (IS_ERR(chip->gpio_detect)) {
1126                 dev_err(&client->dev, "Failed to get gpio: %ld\n",
1127                         PTR_ERR(chip->gpio_detect));
1128                 return PTR_ERR(chip->gpio_detect);
1129         }
1130
1131         i2c_set_clientdata(client, chip);
1132
1133         if (!chip->gpio_detect)
1134                 goto skip_gpio;
1135
1136         irq = gpiod_to_irq(chip->gpio_detect);
1137         if (irq <= 0) {
1138                 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
1139                 goto skip_gpio;
1140         }
1141
1142         rc = devm_request_threaded_irq(&client->dev, irq, NULL, sbs_irq,
1143                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1144                 dev_name(&client->dev), chip);
1145         if (rc) {
1146                 dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
1147                 goto skip_gpio;
1148         }
1149
1150 skip_gpio:
1151         /*
1152          * Before we register, we might need to make sure we can actually talk
1153          * to the battery.
1154          */
1155         if (!(force_load || chip->gpio_detect)) {
1156                 rc = sbs_read_word_data(client, sbs_data[REG_STATUS].addr);
1157
1158                 if (rc < 0) {
1159                         dev_err(&client->dev, "%s: Failed to get device status\n",
1160                                 __func__);
1161                         goto exit_psupply;
1162                 }
1163         }
1164
1165         chip->power_supply = devm_power_supply_register(&client->dev, sbs_desc,
1166                                                    &psy_cfg);
1167         if (IS_ERR(chip->power_supply)) {
1168                 dev_err(&client->dev,
1169                         "%s: Failed to register power supply\n", __func__);
1170                 rc = PTR_ERR(chip->power_supply);
1171                 goto exit_psupply;
1172         }
1173
1174         dev_info(&client->dev,
1175                 "%s: battery gas gauge device registered\n", client->name);
1176
1177         INIT_DELAYED_WORK(&chip->work, sbs_delayed_work);
1178
1179         chip->enable_detection = true;
1180
1181         return 0;
1182
1183 exit_psupply:
1184         return rc;
1185 }
1186
1187 static int sbs_remove(struct i2c_client *client)
1188 {
1189         struct sbs_info *chip = i2c_get_clientdata(client);
1190
1191         cancel_delayed_work_sync(&chip->work);
1192
1193         return 0;
1194 }
1195
1196 #if defined CONFIG_PM_SLEEP
1197
1198 static int sbs_suspend(struct device *dev)
1199 {
1200         struct i2c_client *client = to_i2c_client(dev);
1201         struct sbs_info *chip = i2c_get_clientdata(client);
1202         int ret;
1203
1204         if (chip->poll_time > 0)
1205                 cancel_delayed_work_sync(&chip->work);
1206
1207         if (chip->flags & SBS_FLAGS_TI_BQ20ZX5) {
1208                 /* Write to manufacturer access with sleep command. */
1209                 ret = sbs_write_word_data(client,
1210                                           sbs_data[REG_MANUFACTURER_DATA].addr,
1211                                           MANUFACTURER_ACCESS_SLEEP);
1212                 if (chip->is_present && ret < 0)
1213                         return ret;
1214         }
1215
1216         return 0;
1217 }
1218
1219 static SIMPLE_DEV_PM_OPS(sbs_pm_ops, sbs_suspend, NULL);
1220 #define SBS_PM_OPS (&sbs_pm_ops)
1221
1222 #else
1223 #define SBS_PM_OPS NULL
1224 #endif
1225
1226 static const struct i2c_device_id sbs_id[] = {
1227         { "bq20z65", 0 },
1228         { "bq20z75", 0 },
1229         { "sbs-battery", 1 },
1230         {}
1231 };
1232 MODULE_DEVICE_TABLE(i2c, sbs_id);
1233
1234 static const struct of_device_id sbs_dt_ids[] = {
1235         { .compatible = "sbs,sbs-battery" },
1236         {
1237                 .compatible = "ti,bq20z65",
1238                 .data = (void *)SBS_FLAGS_TI_BQ20ZX5,
1239         },
1240         {
1241                 .compatible = "ti,bq20z75",
1242                 .data = (void *)SBS_FLAGS_TI_BQ20ZX5,
1243         },
1244         { }
1245 };
1246 MODULE_DEVICE_TABLE(of, sbs_dt_ids);
1247
1248 static struct i2c_driver sbs_battery_driver = {
1249         .probe_new      = sbs_probe,
1250         .remove         = sbs_remove,
1251         .alert          = sbs_alert,
1252         .id_table       = sbs_id,
1253         .driver = {
1254                 .name   = "sbs-battery",
1255                 .of_match_table = sbs_dt_ids,
1256                 .pm     = SBS_PM_OPS,
1257         },
1258 };
1259 module_i2c_driver(sbs_battery_driver);
1260
1261 MODULE_DESCRIPTION("SBS battery monitor driver");
1262 MODULE_LICENSE("GPL");
1263
1264 module_param(force_load, bool, 0444);
1265 MODULE_PARM_DESC(force_load,
1266                  "Attempt to load the driver even if no battery is connected");