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"); 1267