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 if (of_device_is_compatible(client->dev.parent->of_node, "google,cros-ec-i2c-tunnel") 284 && client->flags & I2C_CLIENT_PEC) { 285 dev_info(&client->dev, "Disabling PEC because of broken Cros-EC implementation\n"); 286 client->flags &= ~I2C_CLIENT_PEC; 287 } 288 289 dev_dbg(&client->dev, "PEC: %s\n", (client->flags & I2C_CLIENT_PEC) ? 290 "enabled" : "disabled"); 291 292 if (!chip->is_present && is_present && !chip->charger_broadcasts) 293 sbs_disable_charger_broadcasts(chip); 294 295 chip->is_present = true; 296 297 return 0; 298 } 299 300 static int sbs_read_word_data(struct i2c_client *client, u8 address) 301 { 302 struct sbs_info *chip = i2c_get_clientdata(client); 303 int retries = chip->i2c_retry_count; 304 s32 ret = 0; 305 306 while (retries > 0) { 307 ret = i2c_smbus_read_word_data(client, address); 308 if (ret >= 0) 309 break; 310 retries--; 311 } 312 313 if (ret < 0) { 314 dev_dbg(&client->dev, 315 "%s: i2c read at address 0x%x failed\n", 316 __func__, address); 317 return ret; 318 } 319 320 return ret; 321 } 322 323 static int sbs_read_string_data_fallback(struct i2c_client *client, u8 address, char *values) 324 { 325 struct sbs_info *chip = i2c_get_clientdata(client); 326 s32 ret = 0, block_length = 0; 327 int retries_length, retries_block; 328 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1]; 329 330 retries_length = chip->i2c_retry_count; 331 retries_block = chip->i2c_retry_count; 332 333 dev_warn_once(&client->dev, "I2C adapter does not support I2C_FUNC_SMBUS_READ_BLOCK_DATA.\n" 334 "Fallback method does not support PEC.\n"); 335 336 /* Adapter needs to support these two functions */ 337 if (!i2c_check_functionality(client->adapter, 338 I2C_FUNC_SMBUS_BYTE_DATA | 339 I2C_FUNC_SMBUS_I2C_BLOCK)){ 340 return -ENODEV; 341 } 342 343 /* Get the length of block data */ 344 while (retries_length > 0) { 345 ret = i2c_smbus_read_byte_data(client, address); 346 if (ret >= 0) 347 break; 348 retries_length--; 349 } 350 351 if (ret < 0) { 352 dev_dbg(&client->dev, 353 "%s: i2c read at address 0x%x failed\n", 354 __func__, address); 355 return ret; 356 } 357 358 /* block_length does not include NULL terminator */ 359 block_length = ret; 360 if (block_length > I2C_SMBUS_BLOCK_MAX) { 361 dev_err(&client->dev, 362 "%s: Returned block_length is longer than 0x%x\n", 363 __func__, I2C_SMBUS_BLOCK_MAX); 364 return -EINVAL; 365 } 366 367 /* Get the block data */ 368 while (retries_block > 0) { 369 ret = i2c_smbus_read_i2c_block_data( 370 client, address, 371 block_length + 1, block_buffer); 372 if (ret >= 0) 373 break; 374 retries_block--; 375 } 376 377 if (ret < 0) { 378 dev_dbg(&client->dev, 379 "%s: i2c read at address 0x%x failed\n", 380 __func__, address); 381 return ret; 382 } 383 384 /* block_buffer[0] == block_length */ 385 memcpy(values, block_buffer + 1, block_length); 386 values[block_length] = '\0'; 387 388 return ret; 389 } 390 391 static int sbs_read_string_data(struct i2c_client *client, u8 address, char *values) 392 { 393 struct sbs_info *chip = i2c_get_clientdata(client); 394 int retries = chip->i2c_retry_count; 395 int ret = 0; 396 397 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BLOCK_DATA)) { 398 bool pec = client->flags & I2C_CLIENT_PEC; 399 client->flags &= ~I2C_CLIENT_PEC; 400 ret = sbs_read_string_data_fallback(client, address, values); 401 if (pec) 402 client->flags |= I2C_CLIENT_PEC; 403 return ret; 404 } 405 406 while (retries > 0) { 407 ret = i2c_smbus_read_block_data(client, address, values); 408 if (ret >= 0) 409 break; 410 retries--; 411 } 412 413 if (ret < 0) { 414 dev_dbg(&client->dev, "failed to read block 0x%x: %d\n", address, ret); 415 return ret; 416 } 417 418 /* add string termination */ 419 values[ret] = '\0'; 420 return ret; 421 } 422 423 static int sbs_write_word_data(struct i2c_client *client, u8 address, 424 u16 value) 425 { 426 struct sbs_info *chip = i2c_get_clientdata(client); 427 int retries = chip->i2c_retry_count; 428 s32 ret = 0; 429 430 while (retries > 0) { 431 ret = i2c_smbus_write_word_data(client, address, value); 432 if (ret >= 0) 433 break; 434 retries--; 435 } 436 437 if (ret < 0) { 438 dev_dbg(&client->dev, 439 "%s: i2c write to address 0x%x failed\n", 440 __func__, address); 441 return ret; 442 } 443 444 return 0; 445 } 446 447 static int sbs_status_correct(struct i2c_client *client, int *intval) 448 { 449 int ret; 450 451 ret = sbs_read_word_data(client, sbs_data[REG_CURRENT_NOW].addr); 452 if (ret < 0) 453 return ret; 454 455 ret = (s16)ret; 456 457 /* Not drawing current -> not charging (i.e. idle) */ 458 if (*intval != POWER_SUPPLY_STATUS_FULL && ret == 0) 459 *intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 460 461 if (*intval == POWER_SUPPLY_STATUS_FULL) { 462 /* Drawing or providing current when full */ 463 if (ret > 0) 464 *intval = POWER_SUPPLY_STATUS_CHARGING; 465 else if (ret < 0) 466 *intval = POWER_SUPPLY_STATUS_DISCHARGING; 467 } 468 469 return 0; 470 } 471 472 static bool sbs_bat_needs_calibration(struct i2c_client *client) 473 { 474 int ret; 475 476 ret = sbs_read_word_data(client, sbs_data[REG_BATTERY_MODE].addr); 477 if (ret < 0) 478 return false; 479 480 return !!(ret & BIT(7)); 481 } 482 483 static int sbs_get_battery_presence_and_health( 484 struct i2c_client *client, enum power_supply_property psp, 485 union power_supply_propval *val) 486 { 487 int ret; 488 489 /* Dummy command; if it succeeds, battery is present. */ 490 ret = sbs_read_word_data(client, sbs_data[REG_STATUS].addr); 491 492 if (ret < 0) { /* battery not present*/ 493 if (psp == POWER_SUPPLY_PROP_PRESENT) { 494 val->intval = 0; 495 return 0; 496 } 497 return ret; 498 } 499 500 if (psp == POWER_SUPPLY_PROP_PRESENT) 501 val->intval = 1; /* battery present */ 502 else { /* POWER_SUPPLY_PROP_HEALTH */ 503 if (sbs_bat_needs_calibration(client)) { 504 val->intval = POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED; 505 } else { 506 /* SBS spec doesn't have a general health command. */ 507 val->intval = POWER_SUPPLY_HEALTH_UNKNOWN; 508 } 509 } 510 511 return 0; 512 } 513 514 static int sbs_get_ti_battery_presence_and_health( 515 struct i2c_client *client, enum power_supply_property psp, 516 union power_supply_propval *val) 517 { 518 s32 ret; 519 520 /* 521 * Write to ManufacturerAccess with ManufacturerAccess command 522 * and then read the status. 523 */ 524 ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr, 525 MANUFACTURER_ACCESS_STATUS); 526 if (ret < 0) { 527 if (psp == POWER_SUPPLY_PROP_PRESENT) 528 val->intval = 0; /* battery removed */ 529 return ret; 530 } 531 532 ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr); 533 if (ret < 0) { 534 if (psp == POWER_SUPPLY_PROP_PRESENT) 535 val->intval = 0; /* battery removed */ 536 return ret; 537 } 538 539 if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value || 540 ret > sbs_data[REG_MANUFACTURER_DATA].max_value) { 541 val->intval = 0; 542 return 0; 543 } 544 545 /* Mask the upper nibble of 2nd byte and 546 * lower byte of response then 547 * shift the result by 8 to get status*/ 548 ret &= 0x0F00; 549 ret >>= 8; 550 if (psp == POWER_SUPPLY_PROP_PRESENT) { 551 if (ret == 0x0F) 552 /* battery removed */ 553 val->intval = 0; 554 else 555 val->intval = 1; 556 } else if (psp == POWER_SUPPLY_PROP_HEALTH) { 557 if (ret == 0x09) 558 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 559 else if (ret == 0x0B) 560 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 561 else if (ret == 0x0C) 562 val->intval = POWER_SUPPLY_HEALTH_DEAD; 563 else if (sbs_bat_needs_calibration(client)) 564 val->intval = POWER_SUPPLY_HEALTH_CALIBRATION_REQUIRED; 565 else 566 val->intval = POWER_SUPPLY_HEALTH_GOOD; 567 } 568 569 return 0; 570 } 571 572 static int sbs_get_battery_property(struct i2c_client *client, 573 int reg_offset, enum power_supply_property psp, 574 union power_supply_propval *val) 575 { 576 struct sbs_info *chip = i2c_get_clientdata(client); 577 s32 ret; 578 579 ret = sbs_read_word_data(client, sbs_data[reg_offset].addr); 580 if (ret < 0) 581 return ret; 582 583 /* returned values are 16 bit */ 584 if (sbs_data[reg_offset].min_value < 0) 585 ret = (s16)ret; 586 587 if (ret >= sbs_data[reg_offset].min_value && 588 ret <= sbs_data[reg_offset].max_value) { 589 val->intval = ret; 590 if (psp == POWER_SUPPLY_PROP_CAPACITY_LEVEL) { 591 if (!(ret & BATTERY_INITIALIZED)) 592 val->intval = 593 POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN; 594 else if (ret & BATTERY_FULL_CHARGED) 595 val->intval = 596 POWER_SUPPLY_CAPACITY_LEVEL_FULL; 597 else if (ret & BATTERY_FULL_DISCHARGED) 598 val->intval = 599 POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; 600 else 601 val->intval = 602 POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 603 return 0; 604 } else if (psp != POWER_SUPPLY_PROP_STATUS) { 605 return 0; 606 } 607 608 if (ret & BATTERY_FULL_CHARGED) 609 val->intval = POWER_SUPPLY_STATUS_FULL; 610 else if (ret & BATTERY_DISCHARGING) 611 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 612 else 613 val->intval = POWER_SUPPLY_STATUS_CHARGING; 614 615 sbs_status_correct(client, &val->intval); 616 617 if (chip->poll_time == 0) 618 chip->last_state = val->intval; 619 else if (chip->last_state != val->intval) { 620 cancel_delayed_work_sync(&chip->work); 621 power_supply_changed(chip->power_supply); 622 chip->poll_time = 0; 623 } 624 } else { 625 if (psp == POWER_SUPPLY_PROP_STATUS) 626 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 627 else if (psp == POWER_SUPPLY_PROP_CAPACITY) 628 /* sbs spec says that this can be >100 % 629 * even if max value is 100 % 630 */ 631 val->intval = min(ret, 100); 632 else 633 val->intval = 0; 634 } 635 636 return 0; 637 } 638 639 static int sbs_get_battery_string_property(struct i2c_client *client, 640 int reg_offset, enum power_supply_property psp, char *val) 641 { 642 s32 ret; 643 644 ret = sbs_read_string_data(client, sbs_data[reg_offset].addr, val); 645 646 if (ret < 0) 647 return ret; 648 649 return 0; 650 } 651 652 static void sbs_unit_adjustment(struct i2c_client *client, 653 enum power_supply_property psp, union power_supply_propval *val) 654 { 655 #define BASE_UNIT_CONVERSION 1000 656 #define BATTERY_MODE_CAP_MULT_WATT (10 * BASE_UNIT_CONVERSION) 657 #define TIME_UNIT_CONVERSION 60 658 #define TEMP_KELVIN_TO_CELSIUS 2731 659 switch (psp) { 660 case POWER_SUPPLY_PROP_ENERGY_NOW: 661 case POWER_SUPPLY_PROP_ENERGY_FULL: 662 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 663 /* sbs provides energy in units of 10mWh. 664 * Convert to µWh 665 */ 666 val->intval *= BATTERY_MODE_CAP_MULT_WATT; 667 break; 668 669 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 670 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 671 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 672 case POWER_SUPPLY_PROP_CURRENT_NOW: 673 case POWER_SUPPLY_PROP_CURRENT_AVG: 674 case POWER_SUPPLY_PROP_CHARGE_NOW: 675 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 676 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 677 case POWER_SUPPLY_PROP_CHARGE_FULL: 678 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 679 val->intval *= BASE_UNIT_CONVERSION; 680 break; 681 682 case POWER_SUPPLY_PROP_TEMP: 683 /* sbs provides battery temperature in 0.1K 684 * so convert it to 0.1°C 685 */ 686 val->intval -= TEMP_KELVIN_TO_CELSIUS; 687 break; 688 689 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 690 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 691 /* sbs provides time to empty and time to full in minutes. 692 * Convert to seconds 693 */ 694 val->intval *= TIME_UNIT_CONVERSION; 695 break; 696 697 default: 698 dev_dbg(&client->dev, 699 "%s: no need for unit conversion %d\n", __func__, psp); 700 } 701 } 702 703 static enum sbs_capacity_mode sbs_set_capacity_mode(struct i2c_client *client, 704 enum sbs_capacity_mode mode) 705 { 706 int ret, original_val; 707 708 original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET); 709 if (original_val < 0) 710 return original_val; 711 712 if ((original_val & BATTERY_MODE_CAPACITY_MASK) == mode) 713 return mode; 714 715 if (mode == CAPACITY_MODE_AMPS) 716 ret = original_val & ~BATTERY_MODE_CAPACITY_MASK; 717 else 718 ret = original_val | BATTERY_MODE_CAPACITY_MASK; 719 720 ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret); 721 if (ret < 0) 722 return ret; 723 724 usleep_range(1000, 2000); 725 726 return original_val & BATTERY_MODE_CAPACITY_MASK; 727 } 728 729 static int sbs_get_battery_capacity(struct i2c_client *client, 730 int reg_offset, enum power_supply_property psp, 731 union power_supply_propval *val) 732 { 733 s32 ret; 734 enum sbs_capacity_mode mode = CAPACITY_MODE_WATTS; 735 736 if (power_supply_is_amp_property(psp)) 737 mode = CAPACITY_MODE_AMPS; 738 739 mode = sbs_set_capacity_mode(client, mode); 740 if ((int)mode < 0) 741 return mode; 742 743 ret = sbs_read_word_data(client, sbs_data[reg_offset].addr); 744 if (ret < 0) 745 return ret; 746 747 val->intval = ret; 748 749 ret = sbs_set_capacity_mode(client, mode); 750 if (ret < 0) 751 return ret; 752 753 return 0; 754 } 755 756 static char sbs_serial[5]; 757 static int sbs_get_battery_serial_number(struct i2c_client *client, 758 union power_supply_propval *val) 759 { 760 int ret; 761 762 ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr); 763 if (ret < 0) 764 return ret; 765 766 sprintf(sbs_serial, "%04x", ret); 767 val->strval = sbs_serial; 768 769 return 0; 770 } 771 772 static int sbs_get_property_index(struct i2c_client *client, 773 enum power_supply_property psp) 774 { 775 int count; 776 for (count = 0; count < ARRAY_SIZE(sbs_data); count++) 777 if (psp == sbs_data[count].psp) 778 return count; 779 780 dev_warn(&client->dev, 781 "%s: Invalid Property - %d\n", __func__, psp); 782 783 return -EINVAL; 784 } 785 786 static int sbs_get_chemistry(struct i2c_client *client, 787 union power_supply_propval *val) 788 { 789 enum power_supply_property psp = POWER_SUPPLY_PROP_TECHNOLOGY; 790 int ret; 791 792 ret = sbs_get_property_index(client, psp); 793 if (ret < 0) 794 return ret; 795 796 ret = sbs_get_battery_string_property(client, ret, psp, 797 chemistry); 798 if (ret < 0) 799 return ret; 800 801 if (!strncasecmp(chemistry, "LION", 4)) 802 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 803 else if (!strncasecmp(chemistry, "LiP", 3)) 804 val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO; 805 else if (!strncasecmp(chemistry, "NiCd", 4)) 806 val->intval = POWER_SUPPLY_TECHNOLOGY_NiCd; 807 else if (!strncasecmp(chemistry, "NiMH", 4)) 808 val->intval = POWER_SUPPLY_TECHNOLOGY_NiMH; 809 else 810 val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 811 812 if (val->intval == POWER_SUPPLY_TECHNOLOGY_UNKNOWN) 813 dev_warn(&client->dev, "Unknown chemistry: %s\n", chemistry); 814 815 return 0; 816 } 817 818 static int sbs_get_battery_manufacture_date(struct i2c_client *client, 819 enum power_supply_property psp, 820 union power_supply_propval *val) 821 { 822 int ret; 823 u16 day, month, year; 824 825 ret = sbs_read_word_data(client, REG_ADDR_MANUFACTURE_DATE); 826 if (ret < 0) 827 return ret; 828 829 day = ret & GENMASK(4, 0); 830 month = (ret & GENMASK(8, 5)) >> 5; 831 year = ((ret & GENMASK(15, 9)) >> 9) + 1980; 832 833 switch (psp) { 834 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR: 835 val->intval = year; 836 break; 837 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH: 838 val->intval = month; 839 break; 840 case POWER_SUPPLY_PROP_MANUFACTURE_DAY: 841 val->intval = day; 842 break; 843 default: 844 return -EINVAL; 845 } 846 847 return 0; 848 } 849 850 static int sbs_get_property(struct power_supply *psy, 851 enum power_supply_property psp, 852 union power_supply_propval *val) 853 { 854 int ret = 0; 855 struct sbs_info *chip = power_supply_get_drvdata(psy); 856 struct i2c_client *client = chip->client; 857 858 if (chip->gpio_detect) { 859 ret = gpiod_get_value_cansleep(chip->gpio_detect); 860 if (ret < 0) 861 return ret; 862 if (psp == POWER_SUPPLY_PROP_PRESENT) { 863 val->intval = ret; 864 sbs_update_presence(chip, ret); 865 return 0; 866 } 867 if (ret == 0) 868 return -ENODATA; 869 } 870 871 switch (psp) { 872 case POWER_SUPPLY_PROP_PRESENT: 873 case POWER_SUPPLY_PROP_HEALTH: 874 if (chip->flags & SBS_FLAGS_TI_BQ20ZX5) 875 ret = sbs_get_ti_battery_presence_and_health(client, 876 psp, val); 877 else 878 ret = sbs_get_battery_presence_and_health(client, psp, 879 val); 880 881 /* this can only be true if no gpio is used */ 882 if (psp == POWER_SUPPLY_PROP_PRESENT) 883 return 0; 884 break; 885 886 case POWER_SUPPLY_PROP_TECHNOLOGY: 887 ret = sbs_get_chemistry(client, val); 888 if (ret < 0) 889 break; 890 891 goto done; /* don't trigger power_supply_changed()! */ 892 893 case POWER_SUPPLY_PROP_ENERGY_NOW: 894 case POWER_SUPPLY_PROP_ENERGY_FULL: 895 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 896 case POWER_SUPPLY_PROP_CHARGE_NOW: 897 case POWER_SUPPLY_PROP_CHARGE_FULL: 898 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 899 ret = sbs_get_property_index(client, psp); 900 if (ret < 0) 901 break; 902 903 /* sbs_get_battery_capacity() will change the battery mode 904 * temporarily to read the requested attribute. Ensure we stay 905 * in the desired mode for the duration of the attribute read. 906 */ 907 mutex_lock(&chip->mode_lock); 908 ret = sbs_get_battery_capacity(client, ret, psp, val); 909 mutex_unlock(&chip->mode_lock); 910 break; 911 912 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 913 ret = sbs_get_battery_serial_number(client, val); 914 break; 915 916 case POWER_SUPPLY_PROP_STATUS: 917 case POWER_SUPPLY_PROP_CAPACITY_LEVEL: 918 case POWER_SUPPLY_PROP_CYCLE_COUNT: 919 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 920 case POWER_SUPPLY_PROP_CURRENT_NOW: 921 case POWER_SUPPLY_PROP_CURRENT_AVG: 922 case POWER_SUPPLY_PROP_TEMP: 923 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 924 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 925 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 926 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 927 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: 928 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: 929 case POWER_SUPPLY_PROP_CAPACITY: 930 case POWER_SUPPLY_PROP_CAPACITY_ERROR_MARGIN: 931 ret = sbs_get_property_index(client, psp); 932 if (ret < 0) 933 break; 934 935 ret = sbs_get_battery_property(client, ret, psp, val); 936 break; 937 938 case POWER_SUPPLY_PROP_MODEL_NAME: 939 ret = sbs_get_property_index(client, psp); 940 if (ret < 0) 941 break; 942 943 ret = sbs_get_battery_string_property(client, ret, psp, 944 model_name); 945 val->strval = model_name; 946 break; 947 948 case POWER_SUPPLY_PROP_MANUFACTURER: 949 ret = sbs_get_property_index(client, psp); 950 if (ret < 0) 951 break; 952 953 ret = sbs_get_battery_string_property(client, ret, psp, 954 manufacturer); 955 val->strval = manufacturer; 956 break; 957 958 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR: 959 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH: 960 case POWER_SUPPLY_PROP_MANUFACTURE_DAY: 961 ret = sbs_get_battery_manufacture_date(client, psp, val); 962 break; 963 964 default: 965 dev_err(&client->dev, 966 "%s: INVALID property\n", __func__); 967 return -EINVAL; 968 } 969 970 if (!chip->enable_detection) 971 goto done; 972 973 if (!chip->gpio_detect && 974 chip->is_present != (ret >= 0)) { 975 sbs_update_presence(chip, (ret >= 0)); 976 power_supply_changed(chip->power_supply); 977 } 978 979 done: 980 if (!ret) { 981 /* Convert units to match requirements for power supply class */ 982 sbs_unit_adjustment(client, psp, val); 983 } 984 985 dev_dbg(&client->dev, 986 "%s: property = %d, value = %x\n", __func__, psp, val->intval); 987 988 if (ret && chip->is_present) 989 return ret; 990 991 /* battery not present, so return NODATA for properties */ 992 if (ret) 993 return -ENODATA; 994 995 return 0; 996 } 997 998 static void sbs_supply_changed(struct sbs_info *chip) 999 { 1000 struct power_supply *battery = chip->power_supply; 1001 int ret; 1002 1003 ret = gpiod_get_value_cansleep(chip->gpio_detect); 1004 if (ret < 0) 1005 return; 1006 sbs_update_presence(chip, ret); 1007 power_supply_changed(battery); 1008 } 1009 1010 static irqreturn_t sbs_irq(int irq, void *devid) 1011 { 1012 sbs_supply_changed(devid); 1013 return IRQ_HANDLED; 1014 } 1015 1016 static void sbs_alert(struct i2c_client *client, enum i2c_alert_protocol prot, 1017 unsigned int data) 1018 { 1019 sbs_supply_changed(i2c_get_clientdata(client)); 1020 } 1021 1022 static void sbs_external_power_changed(struct power_supply *psy) 1023 { 1024 struct sbs_info *chip = power_supply_get_drvdata(psy); 1025 1026 /* cancel outstanding work */ 1027 cancel_delayed_work_sync(&chip->work); 1028 1029 schedule_delayed_work(&chip->work, HZ); 1030 chip->poll_time = chip->poll_retry_count; 1031 } 1032 1033 static void sbs_delayed_work(struct work_struct *work) 1034 { 1035 struct sbs_info *chip; 1036 s32 ret; 1037 1038 chip = container_of(work, struct sbs_info, work.work); 1039 1040 ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr); 1041 /* if the read failed, give up on this work */ 1042 if (ret < 0) { 1043 chip->poll_time = 0; 1044 return; 1045 } 1046 1047 if (ret & BATTERY_FULL_CHARGED) 1048 ret = POWER_SUPPLY_STATUS_FULL; 1049 else if (ret & BATTERY_DISCHARGING) 1050 ret = POWER_SUPPLY_STATUS_DISCHARGING; 1051 else 1052 ret = POWER_SUPPLY_STATUS_CHARGING; 1053 1054 sbs_status_correct(chip->client, &ret); 1055 1056 if (chip->last_state != ret) { 1057 chip->poll_time = 0; 1058 power_supply_changed(chip->power_supply); 1059 return; 1060 } 1061 if (chip->poll_time > 0) { 1062 schedule_delayed_work(&chip->work, HZ); 1063 chip->poll_time--; 1064 return; 1065 } 1066 } 1067 1068 static const struct power_supply_desc sbs_default_desc = { 1069 .type = POWER_SUPPLY_TYPE_BATTERY, 1070 .properties = sbs_properties, 1071 .num_properties = ARRAY_SIZE(sbs_properties), 1072 .get_property = sbs_get_property, 1073 .external_power_changed = sbs_external_power_changed, 1074 }; 1075 1076 static int sbs_probe(struct i2c_client *client) 1077 { 1078 struct sbs_info *chip; 1079 struct power_supply_desc *sbs_desc; 1080 struct sbs_platform_data *pdata = client->dev.platform_data; 1081 struct power_supply_config psy_cfg = {}; 1082 int rc; 1083 int irq; 1084 1085 sbs_desc = devm_kmemdup(&client->dev, &sbs_default_desc, 1086 sizeof(*sbs_desc), GFP_KERNEL); 1087 if (!sbs_desc) 1088 return -ENOMEM; 1089 1090 sbs_desc->name = devm_kasprintf(&client->dev, GFP_KERNEL, "sbs-%s", 1091 dev_name(&client->dev)); 1092 if (!sbs_desc->name) 1093 return -ENOMEM; 1094 1095 chip = devm_kzalloc(&client->dev, sizeof(struct sbs_info), GFP_KERNEL); 1096 if (!chip) 1097 return -ENOMEM; 1098 1099 chip->flags = (u32)(uintptr_t)device_get_match_data(&client->dev); 1100 chip->client = client; 1101 chip->enable_detection = false; 1102 psy_cfg.of_node = client->dev.of_node; 1103 psy_cfg.drv_data = chip; 1104 chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN; 1105 mutex_init(&chip->mode_lock); 1106 1107 /* use pdata if available, fall back to DT properties, 1108 * or hardcoded defaults if not 1109 */ 1110 rc = device_property_read_u32(&client->dev, "sbs,i2c-retry-count", 1111 &chip->i2c_retry_count); 1112 if (rc) 1113 chip->i2c_retry_count = 0; 1114 1115 rc = device_property_read_u32(&client->dev, "sbs,poll-retry-count", 1116 &chip->poll_retry_count); 1117 if (rc) 1118 chip->poll_retry_count = 0; 1119 1120 if (pdata) { 1121 chip->poll_retry_count = pdata->poll_retry_count; 1122 chip->i2c_retry_count = pdata->i2c_retry_count; 1123 } 1124 chip->i2c_retry_count = chip->i2c_retry_count + 1; 1125 1126 chip->charger_broadcasts = !device_property_read_bool(&client->dev, 1127 "sbs,disable-charger-broadcasts"); 1128 1129 chip->gpio_detect = devm_gpiod_get_optional(&client->dev, 1130 "sbs,battery-detect", GPIOD_IN); 1131 if (IS_ERR(chip->gpio_detect)) { 1132 dev_err(&client->dev, "Failed to get gpio: %ld\n", 1133 PTR_ERR(chip->gpio_detect)); 1134 return PTR_ERR(chip->gpio_detect); 1135 } 1136 1137 i2c_set_clientdata(client, chip); 1138 1139 if (!chip->gpio_detect) 1140 goto skip_gpio; 1141 1142 irq = gpiod_to_irq(chip->gpio_detect); 1143 if (irq <= 0) { 1144 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq); 1145 goto skip_gpio; 1146 } 1147 1148 rc = devm_request_threaded_irq(&client->dev, irq, NULL, sbs_irq, 1149 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1150 dev_name(&client->dev), chip); 1151 if (rc) { 1152 dev_warn(&client->dev, "Failed to request irq: %d\n", rc); 1153 goto skip_gpio; 1154 } 1155 1156 skip_gpio: 1157 /* 1158 * Before we register, we might need to make sure we can actually talk 1159 * to the battery. 1160 */ 1161 if (!(force_load || chip->gpio_detect)) { 1162 rc = sbs_read_word_data(client, sbs_data[REG_STATUS].addr); 1163 1164 if (rc < 0) { 1165 dev_err(&client->dev, "%s: Failed to get device status\n", 1166 __func__); 1167 goto exit_psupply; 1168 } 1169 } 1170 1171 chip->power_supply = devm_power_supply_register(&client->dev, sbs_desc, 1172 &psy_cfg); 1173 if (IS_ERR(chip->power_supply)) { 1174 dev_err(&client->dev, 1175 "%s: Failed to register power supply\n", __func__); 1176 rc = PTR_ERR(chip->power_supply); 1177 goto exit_psupply; 1178 } 1179 1180 dev_info(&client->dev, 1181 "%s: battery gas gauge device registered\n", client->name); 1182 1183 INIT_DELAYED_WORK(&chip->work, sbs_delayed_work); 1184 1185 chip->enable_detection = true; 1186 1187 return 0; 1188 1189 exit_psupply: 1190 return rc; 1191 } 1192 1193 static int sbs_remove(struct i2c_client *client) 1194 { 1195 struct sbs_info *chip = i2c_get_clientdata(client); 1196 1197 cancel_delayed_work_sync(&chip->work); 1198 1199 return 0; 1200 } 1201 1202 #if defined CONFIG_PM_SLEEP 1203 1204 static int sbs_suspend(struct device *dev) 1205 { 1206 struct i2c_client *client = to_i2c_client(dev); 1207 struct sbs_info *chip = i2c_get_clientdata(client); 1208 int ret; 1209 1210 if (chip->poll_time > 0) 1211 cancel_delayed_work_sync(&chip->work); 1212 1213 if (chip->flags & SBS_FLAGS_TI_BQ20ZX5) { 1214 /* Write to manufacturer access with sleep command. */ 1215 ret = sbs_write_word_data(client, 1216 sbs_data[REG_MANUFACTURER_DATA].addr, 1217 MANUFACTURER_ACCESS_SLEEP); 1218 if (chip->is_present && ret < 0) 1219 return ret; 1220 } 1221 1222 return 0; 1223 } 1224 1225 static SIMPLE_DEV_PM_OPS(sbs_pm_ops, sbs_suspend, NULL); 1226 #define SBS_PM_OPS (&sbs_pm_ops) 1227 1228 #else 1229 #define SBS_PM_OPS NULL 1230 #endif 1231 1232 static const struct i2c_device_id sbs_id[] = { 1233 { "bq20z65", 0 }, 1234 { "bq20z75", 0 }, 1235 { "sbs-battery", 1 }, 1236 {} 1237 }; 1238 MODULE_DEVICE_TABLE(i2c, sbs_id); 1239 1240 static const struct of_device_id sbs_dt_ids[] = { 1241 { .compatible = "sbs,sbs-battery" }, 1242 { 1243 .compatible = "ti,bq20z65", 1244 .data = (void *)SBS_FLAGS_TI_BQ20ZX5, 1245 }, 1246 { 1247 .compatible = "ti,bq20z75", 1248 .data = (void *)SBS_FLAGS_TI_BQ20ZX5, 1249 }, 1250 { } 1251 }; 1252 MODULE_DEVICE_TABLE(of, sbs_dt_ids); 1253 1254 static struct i2c_driver sbs_battery_driver = { 1255 .probe_new = sbs_probe, 1256 .remove = sbs_remove, 1257 .alert = sbs_alert, 1258 .id_table = sbs_id, 1259 .driver = { 1260 .name = "sbs-battery", 1261 .of_match_table = sbs_dt_ids, 1262 .pm = SBS_PM_OPS, 1263 }, 1264 }; 1265 module_i2c_driver(sbs_battery_driver); 1266 1267 MODULE_DESCRIPTION("SBS battery monitor driver"); 1268 MODULE_LICENSE("GPL"); 1269 1270 module_param(force_load, bool, 0444); 1271 MODULE_PARM_DESC(force_load, 1272 "Attempt to load the driver even if no battery is connected"); 1273