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