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