1/* 2 * Gas Gauge driver for SBS Compliant Batteries 3 * 4 * Copyright (c) 2010, NVIDIA Corporation. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along 17 * with this program; if not, write to the Free Software Foundation, Inc., 18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 19 */ 20 21#include <linux/init.h> 22#include <linux/module.h> 23#include <linux/kernel.h> 24#include <linux/err.h> 25#include <linux/power_supply.h> 26#include <linux/i2c.h> 27#include <linux/slab.h> 28#include <linux/interrupt.h> 29#include <linux/gpio.h> 30#include <linux/of.h> 31 32#include <linux/power/sbs-battery.h> 33 34enum { 35 REG_MANUFACTURER_DATA, 36 REG_TEMPERATURE, 37 REG_VOLTAGE, 38 REG_CURRENT, 39 REG_CAPACITY, 40 REG_TIME_TO_EMPTY, 41 REG_TIME_TO_FULL, 42 REG_STATUS, 43 REG_CYCLE_COUNT, 44 REG_SERIAL_NUMBER, 45 REG_REMAINING_CAPACITY, 46 REG_REMAINING_CAPACITY_CHARGE, 47 REG_FULL_CHARGE_CAPACITY, 48 REG_FULL_CHARGE_CAPACITY_CHARGE, 49 REG_DESIGN_CAPACITY, 50 REG_DESIGN_CAPACITY_CHARGE, 51 REG_DESIGN_VOLTAGE_MIN, 52 REG_DESIGN_VOLTAGE_MAX, 53 REG_MANUFACTURER, 54 REG_MODEL_NAME, 55}; 56 57/* Battery Mode defines */ 58#define BATTERY_MODE_OFFSET 0x03 59#define BATTERY_MODE_MASK 0x8000 60enum sbs_battery_mode { 61 BATTERY_MODE_AMPS, 62 BATTERY_MODE_WATTS 63}; 64 65/* manufacturer access defines */ 66#define MANUFACTURER_ACCESS_STATUS 0x0006 67#define MANUFACTURER_ACCESS_SLEEP 0x0011 68 69/* battery status value bits */ 70#define BATTERY_DISCHARGING 0x40 71#define BATTERY_FULL_CHARGED 0x20 72#define BATTERY_FULL_DISCHARGED 0x10 73 74/* min_value and max_value are only valid for numerical data */ 75#define SBS_DATA(_psp, _addr, _min_value, _max_value) { \ 76 .psp = _psp, \ 77 .addr = _addr, \ 78 .min_value = _min_value, \ 79 .max_value = _max_value, \ 80} 81 82static const struct chip_data { 83 enum power_supply_property psp; 84 u8 addr; 85 int min_value; 86 int max_value; 87} sbs_data[] = { 88 [REG_MANUFACTURER_DATA] = 89 SBS_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535), 90 [REG_TEMPERATURE] = 91 SBS_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535), 92 [REG_VOLTAGE] = 93 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000), 94 [REG_CURRENT] = 95 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768, 32767), 96 [REG_CAPACITY] = 97 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0D, 0, 100), 98 [REG_REMAINING_CAPACITY] = 99 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535), 100 [REG_REMAINING_CAPACITY_CHARGE] = 101 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535), 102 [REG_FULL_CHARGE_CAPACITY] = 103 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535), 104 [REG_FULL_CHARGE_CAPACITY_CHARGE] = 105 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535), 106 [REG_TIME_TO_EMPTY] = 107 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 65535), 108 [REG_TIME_TO_FULL] = 109 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0, 65535), 110 [REG_STATUS] = 111 SBS_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535), 112 [REG_CYCLE_COUNT] = 113 SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535), 114 [REG_DESIGN_CAPACITY] = 115 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 65535), 116 [REG_DESIGN_CAPACITY_CHARGE] = 117 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0, 65535), 118 [REG_DESIGN_VOLTAGE_MIN] = 119 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 0x19, 0, 65535), 120 [REG_DESIGN_VOLTAGE_MAX] = 121 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 65535), 122 [REG_SERIAL_NUMBER] = 123 SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535), 124 /* Properties of type `const char *' */ 125 [REG_MANUFACTURER] = 126 SBS_DATA(POWER_SUPPLY_PROP_MANUFACTURER, 0x20, 0, 65535), 127 [REG_MODEL_NAME] = 128 SBS_DATA(POWER_SUPPLY_PROP_MODEL_NAME, 0x21, 0, 65535) 129}; 130 131static enum power_supply_property sbs_properties[] = { 132 POWER_SUPPLY_PROP_STATUS, 133 POWER_SUPPLY_PROP_HEALTH, 134 POWER_SUPPLY_PROP_PRESENT, 135 POWER_SUPPLY_PROP_TECHNOLOGY, 136 POWER_SUPPLY_PROP_CYCLE_COUNT, 137 POWER_SUPPLY_PROP_VOLTAGE_NOW, 138 POWER_SUPPLY_PROP_CURRENT_NOW, 139 POWER_SUPPLY_PROP_CAPACITY, 140 POWER_SUPPLY_PROP_TEMP, 141 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 142 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 143 POWER_SUPPLY_PROP_SERIAL_NUMBER, 144 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 145 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 146 POWER_SUPPLY_PROP_ENERGY_NOW, 147 POWER_SUPPLY_PROP_ENERGY_FULL, 148 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 149 POWER_SUPPLY_PROP_CHARGE_NOW, 150 POWER_SUPPLY_PROP_CHARGE_FULL, 151 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 152 /* Properties of type `const char *' */ 153 POWER_SUPPLY_PROP_MANUFACTURER, 154 POWER_SUPPLY_PROP_MODEL_NAME 155}; 156 157struct sbs_info { 158 struct i2c_client *client; 159 struct power_supply *power_supply; 160 struct sbs_platform_data *pdata; 161 bool is_present; 162 bool gpio_detect; 163 bool enable_detection; 164 int irq; 165 int last_state; 166 int poll_time; 167 struct delayed_work work; 168 int ignore_changes; 169}; 170 171static char model_name[I2C_SMBUS_BLOCK_MAX + 1]; 172static char manufacturer[I2C_SMBUS_BLOCK_MAX + 1]; 173 174static int sbs_read_word_data(struct i2c_client *client, u8 address) 175{ 176 struct sbs_info *chip = i2c_get_clientdata(client); 177 s32 ret = 0; 178 int retries = 1; 179 180 if (chip->pdata) 181 retries = max(chip->pdata->i2c_retry_count + 1, 1); 182 183 while (retries > 0) { 184 ret = i2c_smbus_read_word_data(client, address); 185 if (ret >= 0) 186 break; 187 retries--; 188 } 189 190 if (ret < 0) { 191 dev_dbg(&client->dev, 192 "%s: i2c read at address 0x%x failed\n", 193 __func__, address); 194 return ret; 195 } 196 197 return le16_to_cpu(ret); 198} 199 200static int sbs_read_string_data(struct i2c_client *client, u8 address, 201 char *values) 202{ 203 struct sbs_info *chip = i2c_get_clientdata(client); 204 s32 ret = 0, block_length = 0; 205 int retries_length = 1, retries_block = 1; 206 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1]; 207 208 if (chip->pdata) { 209 retries_length = max(chip->pdata->i2c_retry_count + 1, 1); 210 retries_block = max(chip->pdata->i2c_retry_count + 1, 1); 211 } 212 213 /* Adapter needs to support these two functions */ 214 if (!i2c_check_functionality(client->adapter, 215 I2C_FUNC_SMBUS_BYTE_DATA | 216 I2C_FUNC_SMBUS_I2C_BLOCK)){ 217 return -ENODEV; 218 } 219 220 /* Get the length of block data */ 221 while (retries_length > 0) { 222 ret = i2c_smbus_read_byte_data(client, address); 223 if (ret >= 0) 224 break; 225 retries_length--; 226 } 227 228 if (ret < 0) { 229 dev_dbg(&client->dev, 230 "%s: i2c read at address 0x%x failed\n", 231 __func__, address); 232 return ret; 233 } 234 235 /* block_length does not include NULL terminator */ 236 block_length = ret; 237 if (block_length > I2C_SMBUS_BLOCK_MAX) { 238 dev_err(&client->dev, 239 "%s: Returned block_length is longer than 0x%x\n", 240 __func__, I2C_SMBUS_BLOCK_MAX); 241 return -EINVAL; 242 } 243 244 /* Get the block data */ 245 while (retries_block > 0) { 246 ret = i2c_smbus_read_i2c_block_data( 247 client, address, 248 block_length + 1, block_buffer); 249 if (ret >= 0) 250 break; 251 retries_block--; 252 } 253 254 if (ret < 0) { 255 dev_dbg(&client->dev, 256 "%s: i2c read at address 0x%x failed\n", 257 __func__, address); 258 return ret; 259 } 260 261 /* block_buffer[0] == block_length */ 262 memcpy(values, block_buffer + 1, block_length); 263 values[block_length] = '\0'; 264 265 return le16_to_cpu(ret); 266} 267 268static int sbs_write_word_data(struct i2c_client *client, u8 address, 269 u16 value) 270{ 271 struct sbs_info *chip = i2c_get_clientdata(client); 272 s32 ret = 0; 273 int retries = 1; 274 275 if (chip->pdata) 276 retries = max(chip->pdata->i2c_retry_count + 1, 1); 277 278 while (retries > 0) { 279 ret = i2c_smbus_write_word_data(client, address, 280 le16_to_cpu(value)); 281 if (ret >= 0) 282 break; 283 retries--; 284 } 285 286 if (ret < 0) { 287 dev_dbg(&client->dev, 288 "%s: i2c write to address 0x%x failed\n", 289 __func__, address); 290 return ret; 291 } 292 293 return 0; 294} 295 296static int sbs_get_battery_presence_and_health( 297 struct i2c_client *client, enum power_supply_property psp, 298 union power_supply_propval *val) 299{ 300 s32 ret; 301 struct sbs_info *chip = i2c_get_clientdata(client); 302 303 if (psp == POWER_SUPPLY_PROP_PRESENT && 304 chip->gpio_detect) { 305 ret = gpio_get_value(chip->pdata->battery_detect); 306 if (ret == chip->pdata->battery_detect_present) 307 val->intval = 1; 308 else 309 val->intval = 0; 310 chip->is_present = val->intval; 311 return ret; 312 } 313 314 /* Write to ManufacturerAccess with 315 * ManufacturerAccess command and then 316 * read the status */ 317 ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr, 318 MANUFACTURER_ACCESS_STATUS); 319 if (ret < 0) { 320 if (psp == POWER_SUPPLY_PROP_PRESENT) 321 val->intval = 0; /* battery removed */ 322 return ret; 323 } 324 325 ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr); 326 if (ret < 0) 327 return ret; 328 329 if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value || 330 ret > sbs_data[REG_MANUFACTURER_DATA].max_value) { 331 val->intval = 0; 332 return 0; 333 } 334 335 /* Mask the upper nibble of 2nd byte and 336 * lower byte of response then 337 * shift the result by 8 to get status*/ 338 ret &= 0x0F00; 339 ret >>= 8; 340 if (psp == POWER_SUPPLY_PROP_PRESENT) { 341 if (ret == 0x0F) 342 /* battery removed */ 343 val->intval = 0; 344 else 345 val->intval = 1; 346 } else if (psp == POWER_SUPPLY_PROP_HEALTH) { 347 if (ret == 0x09) 348 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 349 else if (ret == 0x0B) 350 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 351 else if (ret == 0x0C) 352 val->intval = POWER_SUPPLY_HEALTH_DEAD; 353 else 354 val->intval = POWER_SUPPLY_HEALTH_GOOD; 355 } 356 357 return 0; 358} 359 360static int sbs_get_battery_property(struct i2c_client *client, 361 int reg_offset, enum power_supply_property psp, 362 union power_supply_propval *val) 363{ 364 struct sbs_info *chip = i2c_get_clientdata(client); 365 s32 ret; 366 367 ret = sbs_read_word_data(client, sbs_data[reg_offset].addr); 368 if (ret < 0) 369 return ret; 370 371 /* returned values are 16 bit */ 372 if (sbs_data[reg_offset].min_value < 0) 373 ret = (s16)ret; 374 375 if (ret >= sbs_data[reg_offset].min_value && 376 ret <= sbs_data[reg_offset].max_value) { 377 val->intval = ret; 378 if (psp != POWER_SUPPLY_PROP_STATUS) 379 return 0; 380 381 if (ret & BATTERY_FULL_CHARGED) 382 val->intval = POWER_SUPPLY_STATUS_FULL; 383 else if (ret & BATTERY_FULL_DISCHARGED) 384 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING; 385 else if (ret & BATTERY_DISCHARGING) 386 val->intval = POWER_SUPPLY_STATUS_DISCHARGING; 387 else 388 val->intval = POWER_SUPPLY_STATUS_CHARGING; 389 390 if (chip->poll_time == 0) 391 chip->last_state = val->intval; 392 else if (chip->last_state != val->intval) { 393 cancel_delayed_work_sync(&chip->work); 394 power_supply_changed(chip->power_supply); 395 chip->poll_time = 0; 396 } 397 } else { 398 if (psp == POWER_SUPPLY_PROP_STATUS) 399 val->intval = POWER_SUPPLY_STATUS_UNKNOWN; 400 else 401 val->intval = 0; 402 } 403 404 return 0; 405} 406 407static int sbs_get_battery_string_property(struct i2c_client *client, 408 int reg_offset, enum power_supply_property psp, char *val) 409{ 410 s32 ret; 411 412 ret = sbs_read_string_data(client, sbs_data[reg_offset].addr, val); 413 414 if (ret < 0) 415 return ret; 416 417 return 0; 418} 419 420static void sbs_unit_adjustment(struct i2c_client *client, 421 enum power_supply_property psp, union power_supply_propval *val) 422{ 423#define BASE_UNIT_CONVERSION 1000 424#define BATTERY_MODE_CAP_MULT_WATT (10 * BASE_UNIT_CONVERSION) 425#define TIME_UNIT_CONVERSION 60 426#define TEMP_KELVIN_TO_CELSIUS 2731 427 switch (psp) { 428 case POWER_SUPPLY_PROP_ENERGY_NOW: 429 case POWER_SUPPLY_PROP_ENERGY_FULL: 430 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 431 /* sbs provides energy in units of 10mWh. 432 * Convert to µWh 433 */ 434 val->intval *= BATTERY_MODE_CAP_MULT_WATT; 435 break; 436 437 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 438 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 439 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 440 case POWER_SUPPLY_PROP_CURRENT_NOW: 441 case POWER_SUPPLY_PROP_CHARGE_NOW: 442 case POWER_SUPPLY_PROP_CHARGE_FULL: 443 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 444 val->intval *= BASE_UNIT_CONVERSION; 445 break; 446 447 case POWER_SUPPLY_PROP_TEMP: 448 /* sbs provides battery temperature in 0.1K 449 * so convert it to 0.1°C 450 */ 451 val->intval -= TEMP_KELVIN_TO_CELSIUS; 452 break; 453 454 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 455 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 456 /* sbs provides time to empty and time to full in minutes. 457 * Convert to seconds 458 */ 459 val->intval *= TIME_UNIT_CONVERSION; 460 break; 461 462 default: 463 dev_dbg(&client->dev, 464 "%s: no need for unit conversion %d\n", __func__, psp); 465 } 466} 467 468static enum sbs_battery_mode sbs_set_battery_mode(struct i2c_client *client, 469 enum sbs_battery_mode mode) 470{ 471 int ret, original_val; 472 473 original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET); 474 if (original_val < 0) 475 return original_val; 476 477 if ((original_val & BATTERY_MODE_MASK) == mode) 478 return mode; 479 480 if (mode == BATTERY_MODE_AMPS) 481 ret = original_val & ~BATTERY_MODE_MASK; 482 else 483 ret = original_val | BATTERY_MODE_MASK; 484 485 ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret); 486 if (ret < 0) 487 return ret; 488 489 return original_val & BATTERY_MODE_MASK; 490} 491 492static int sbs_get_battery_capacity(struct i2c_client *client, 493 int reg_offset, enum power_supply_property psp, 494 union power_supply_propval *val) 495{ 496 s32 ret; 497 enum sbs_battery_mode mode = BATTERY_MODE_WATTS; 498 499 if (power_supply_is_amp_property(psp)) 500 mode = BATTERY_MODE_AMPS; 501 502 mode = sbs_set_battery_mode(client, mode); 503 if (mode < 0) 504 return mode; 505 506 ret = sbs_read_word_data(client, sbs_data[reg_offset].addr); 507 if (ret < 0) 508 return ret; 509 510 if (psp == POWER_SUPPLY_PROP_CAPACITY) { 511 /* sbs spec says that this can be >100 % 512 * even if max value is 100 % */ 513 val->intval = min(ret, 100); 514 } else 515 val->intval = ret; 516 517 ret = sbs_set_battery_mode(client, mode); 518 if (ret < 0) 519 return ret; 520 521 return 0; 522} 523 524static char sbs_serial[5]; 525static int sbs_get_battery_serial_number(struct i2c_client *client, 526 union power_supply_propval *val) 527{ 528 int ret; 529 530 ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr); 531 if (ret < 0) 532 return ret; 533 534 ret = sprintf(sbs_serial, "%04x", ret); 535 val->strval = sbs_serial; 536 537 return 0; 538} 539 540static int sbs_get_property_index(struct i2c_client *client, 541 enum power_supply_property psp) 542{ 543 int count; 544 for (count = 0; count < ARRAY_SIZE(sbs_data); count++) 545 if (psp == sbs_data[count].psp) 546 return count; 547 548 dev_warn(&client->dev, 549 "%s: Invalid Property - %d\n", __func__, psp); 550 551 return -EINVAL; 552} 553 554static int sbs_get_property(struct power_supply *psy, 555 enum power_supply_property psp, 556 union power_supply_propval *val) 557{ 558 int ret = 0; 559 struct sbs_info *chip = power_supply_get_drvdata(psy); 560 struct i2c_client *client = chip->client; 561 562 switch (psp) { 563 case POWER_SUPPLY_PROP_PRESENT: 564 case POWER_SUPPLY_PROP_HEALTH: 565 ret = sbs_get_battery_presence_and_health(client, psp, val); 566 if (psp == POWER_SUPPLY_PROP_PRESENT) 567 return 0; 568 break; 569 570 case POWER_SUPPLY_PROP_TECHNOLOGY: 571 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 572 goto done; /* don't trigger power_supply_changed()! */ 573 574 case POWER_SUPPLY_PROP_ENERGY_NOW: 575 case POWER_SUPPLY_PROP_ENERGY_FULL: 576 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 577 case POWER_SUPPLY_PROP_CHARGE_NOW: 578 case POWER_SUPPLY_PROP_CHARGE_FULL: 579 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 580 case POWER_SUPPLY_PROP_CAPACITY: 581 ret = sbs_get_property_index(client, psp); 582 if (ret < 0) 583 break; 584 585 ret = sbs_get_battery_capacity(client, ret, psp, val); 586 break; 587 588 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 589 ret = sbs_get_battery_serial_number(client, val); 590 break; 591 592 case POWER_SUPPLY_PROP_STATUS: 593 case POWER_SUPPLY_PROP_CYCLE_COUNT: 594 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 595 case POWER_SUPPLY_PROP_CURRENT_NOW: 596 case POWER_SUPPLY_PROP_TEMP: 597 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 598 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 599 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: 600 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 601 ret = sbs_get_property_index(client, psp); 602 if (ret < 0) 603 break; 604 605 ret = sbs_get_battery_property(client, ret, psp, val); 606 break; 607 608 case POWER_SUPPLY_PROP_MODEL_NAME: 609 ret = sbs_get_property_index(client, psp); 610 if (ret < 0) 611 break; 612 613 ret = sbs_get_battery_string_property(client, ret, psp, 614 model_name); 615 val->strval = model_name; 616 break; 617 618 case POWER_SUPPLY_PROP_MANUFACTURER: 619 ret = sbs_get_property_index(client, psp); 620 if (ret < 0) 621 break; 622 623 ret = sbs_get_battery_string_property(client, ret, psp, 624 manufacturer); 625 val->strval = manufacturer; 626 break; 627 628 default: 629 dev_err(&client->dev, 630 "%s: INVALID property\n", __func__); 631 return -EINVAL; 632 } 633 634 if (!chip->enable_detection) 635 goto done; 636 637 if (!chip->gpio_detect && 638 chip->is_present != (ret >= 0)) { 639 chip->is_present = (ret >= 0); 640 power_supply_changed(chip->power_supply); 641 } 642 643done: 644 if (!ret) { 645 /* Convert units to match requirements for power supply class */ 646 sbs_unit_adjustment(client, psp, val); 647 } 648 649 dev_dbg(&client->dev, 650 "%s: property = %d, value = %x\n", __func__, psp, val->intval); 651 652 if (ret && chip->is_present) 653 return ret; 654 655 /* battery not present, so return NODATA for properties */ 656 if (ret) 657 return -ENODATA; 658 659 return 0; 660} 661 662static irqreturn_t sbs_irq(int irq, void *devid) 663{ 664 struct power_supply *battery = devid; 665 666 power_supply_changed(battery); 667 668 return IRQ_HANDLED; 669} 670 671static void sbs_external_power_changed(struct power_supply *psy) 672{ 673 struct sbs_info *chip = power_supply_get_drvdata(psy); 674 675 if (chip->ignore_changes > 0) { 676 chip->ignore_changes--; 677 return; 678 } 679 680 /* cancel outstanding work */ 681 cancel_delayed_work_sync(&chip->work); 682 683 schedule_delayed_work(&chip->work, HZ); 684 chip->poll_time = chip->pdata->poll_retry_count; 685} 686 687static void sbs_delayed_work(struct work_struct *work) 688{ 689 struct sbs_info *chip; 690 s32 ret; 691 692 chip = container_of(work, struct sbs_info, work.work); 693 694 ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr); 695 /* if the read failed, give up on this work */ 696 if (ret < 0) { 697 chip->poll_time = 0; 698 return; 699 } 700 701 if (ret & BATTERY_FULL_CHARGED) 702 ret = POWER_SUPPLY_STATUS_FULL; 703 else if (ret & BATTERY_FULL_DISCHARGED) 704 ret = POWER_SUPPLY_STATUS_NOT_CHARGING; 705 else if (ret & BATTERY_DISCHARGING) 706 ret = POWER_SUPPLY_STATUS_DISCHARGING; 707 else 708 ret = POWER_SUPPLY_STATUS_CHARGING; 709 710 if (chip->last_state != ret) { 711 chip->poll_time = 0; 712 power_supply_changed(chip->power_supply); 713 return; 714 } 715 if (chip->poll_time > 0) { 716 schedule_delayed_work(&chip->work, HZ); 717 chip->poll_time--; 718 return; 719 } 720} 721 722#if defined(CONFIG_OF) 723 724#include <linux/of_device.h> 725#include <linux/of_gpio.h> 726 727static const struct of_device_id sbs_dt_ids[] = { 728 { .compatible = "sbs,sbs-battery" }, 729 { .compatible = "ti,bq20z75" }, 730 { } 731}; 732MODULE_DEVICE_TABLE(of, sbs_dt_ids); 733 734static struct sbs_platform_data *sbs_of_populate_pdata( 735 struct i2c_client *client) 736{ 737 struct device_node *of_node = client->dev.of_node; 738 struct sbs_platform_data *pdata = client->dev.platform_data; 739 enum of_gpio_flags gpio_flags; 740 int rc; 741 u32 prop; 742 743 /* verify this driver matches this device */ 744 if (!of_node) 745 return NULL; 746 747 /* if platform data is set, honor it */ 748 if (pdata) 749 return pdata; 750 751 /* first make sure at least one property is set, otherwise 752 * it won't change behavior from running without pdata. 753 */ 754 if (!of_get_property(of_node, "sbs,i2c-retry-count", NULL) && 755 !of_get_property(of_node, "sbs,poll-retry-count", NULL) && 756 !of_get_property(of_node, "sbs,battery-detect-gpios", NULL)) 757 goto of_out; 758 759 pdata = devm_kzalloc(&client->dev, sizeof(struct sbs_platform_data), 760 GFP_KERNEL); 761 if (!pdata) 762 goto of_out; 763 764 rc = of_property_read_u32(of_node, "sbs,i2c-retry-count", &prop); 765 if (!rc) 766 pdata->i2c_retry_count = prop; 767 768 rc = of_property_read_u32(of_node, "sbs,poll-retry-count", &prop); 769 if (!rc) 770 pdata->poll_retry_count = prop; 771 772 if (!of_get_property(of_node, "sbs,battery-detect-gpios", NULL)) { 773 pdata->battery_detect = -1; 774 goto of_out; 775 } 776 777 pdata->battery_detect = of_get_named_gpio_flags(of_node, 778 "sbs,battery-detect-gpios", 0, &gpio_flags); 779 780 if (gpio_flags & OF_GPIO_ACTIVE_LOW) 781 pdata->battery_detect_present = 0; 782 else 783 pdata->battery_detect_present = 1; 784 785of_out: 786 return pdata; 787} 788#else 789static struct sbs_platform_data *sbs_of_populate_pdata( 790 struct i2c_client *client) 791{ 792 return client->dev.platform_data; 793} 794#endif 795 796static const struct power_supply_desc sbs_default_desc = { 797 .type = POWER_SUPPLY_TYPE_BATTERY, 798 .properties = sbs_properties, 799 .num_properties = ARRAY_SIZE(sbs_properties), 800 .get_property = sbs_get_property, 801 .external_power_changed = sbs_external_power_changed, 802}; 803 804static int sbs_probe(struct i2c_client *client, 805 const struct i2c_device_id *id) 806{ 807 struct sbs_info *chip; 808 struct power_supply_desc *sbs_desc; 809 struct sbs_platform_data *pdata = client->dev.platform_data; 810 struct power_supply_config psy_cfg = {}; 811 int rc; 812 int irq; 813 814 sbs_desc = devm_kmemdup(&client->dev, &sbs_default_desc, 815 sizeof(*sbs_desc), GFP_KERNEL); 816 if (!sbs_desc) 817 return -ENOMEM; 818 819 sbs_desc->name = devm_kasprintf(&client->dev, GFP_KERNEL, "sbs-%s", 820 dev_name(&client->dev)); 821 if (!sbs_desc->name) 822 return -ENOMEM; 823 824 chip = kzalloc(sizeof(struct sbs_info), GFP_KERNEL); 825 if (!chip) 826 return -ENOMEM; 827 828 chip->client = client; 829 chip->enable_detection = false; 830 chip->gpio_detect = false; 831 psy_cfg.of_node = client->dev.of_node; 832 psy_cfg.drv_data = chip; 833 /* ignore first notification of external change, it is generated 834 * from the power_supply_register call back 835 */ 836 chip->ignore_changes = 1; 837 chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN; 838 839 pdata = sbs_of_populate_pdata(client); 840 841 if (pdata) { 842 chip->gpio_detect = gpio_is_valid(pdata->battery_detect); 843 chip->pdata = pdata; 844 } 845 846 i2c_set_clientdata(client, chip); 847 848 if (!chip->gpio_detect) 849 goto skip_gpio; 850 851 rc = gpio_request(pdata->battery_detect, dev_name(&client->dev)); 852 if (rc) { 853 dev_warn(&client->dev, "Failed to request gpio: %d\n", rc); 854 chip->gpio_detect = false; 855 goto skip_gpio; 856 } 857 858 rc = gpio_direction_input(pdata->battery_detect); 859 if (rc) { 860 dev_warn(&client->dev, "Failed to get gpio as input: %d\n", rc); 861 gpio_free(pdata->battery_detect); 862 chip->gpio_detect = false; 863 goto skip_gpio; 864 } 865 866 irq = gpio_to_irq(pdata->battery_detect); 867 if (irq <= 0) { 868 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq); 869 gpio_free(pdata->battery_detect); 870 chip->gpio_detect = false; 871 goto skip_gpio; 872 } 873 874 rc = request_irq(irq, sbs_irq, 875 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 876 dev_name(&client->dev), chip->power_supply); 877 if (rc) { 878 dev_warn(&client->dev, "Failed to request irq: %d\n", rc); 879 gpio_free(pdata->battery_detect); 880 chip->gpio_detect = false; 881 goto skip_gpio; 882 } 883 884 chip->irq = irq; 885 886skip_gpio: 887 /* 888 * Before we register, we need to make sure we can actually talk 889 * to the battery. 890 */ 891 rc = sbs_read_word_data(client, sbs_data[REG_STATUS].addr); 892 if (rc < 0) { 893 dev_err(&client->dev, "%s: Failed to get device status\n", 894 __func__); 895 goto exit_psupply; 896 } 897 898 chip->power_supply = power_supply_register(&client->dev, sbs_desc, 899 &psy_cfg); 900 if (IS_ERR(chip->power_supply)) { 901 dev_err(&client->dev, 902 "%s: Failed to register power supply\n", __func__); 903 rc = PTR_ERR(chip->power_supply); 904 goto exit_psupply; 905 } 906 907 dev_info(&client->dev, 908 "%s: battery gas gauge device registered\n", client->name); 909 910 INIT_DELAYED_WORK(&chip->work, sbs_delayed_work); 911 912 chip->enable_detection = true; 913 914 return 0; 915 916exit_psupply: 917 if (chip->irq) 918 free_irq(chip->irq, chip->power_supply); 919 if (chip->gpio_detect) 920 gpio_free(pdata->battery_detect); 921 922 kfree(chip); 923 924 return rc; 925} 926 927static int sbs_remove(struct i2c_client *client) 928{ 929 struct sbs_info *chip = i2c_get_clientdata(client); 930 931 if (chip->irq) 932 free_irq(chip->irq, chip->power_supply); 933 if (chip->gpio_detect) 934 gpio_free(chip->pdata->battery_detect); 935 936 power_supply_unregister(chip->power_supply); 937 938 cancel_delayed_work_sync(&chip->work); 939 940 kfree(chip); 941 chip = NULL; 942 943 return 0; 944} 945 946#if defined CONFIG_PM_SLEEP 947 948static int sbs_suspend(struct device *dev) 949{ 950 struct i2c_client *client = to_i2c_client(dev); 951 struct sbs_info *chip = i2c_get_clientdata(client); 952 s32 ret; 953 954 if (chip->poll_time > 0) 955 cancel_delayed_work_sync(&chip->work); 956 957 /* write to manufacturer access with sleep command */ 958 ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr, 959 MANUFACTURER_ACCESS_SLEEP); 960 if (chip->is_present && ret < 0) 961 return ret; 962 963 return 0; 964} 965 966static SIMPLE_DEV_PM_OPS(sbs_pm_ops, sbs_suspend, NULL); 967#define SBS_PM_OPS (&sbs_pm_ops) 968 969#else 970#define SBS_PM_OPS NULL 971#endif 972 973static const struct i2c_device_id sbs_id[] = { 974 { "bq20z75", 0 }, 975 { "sbs-battery", 1 }, 976 {} 977}; 978MODULE_DEVICE_TABLE(i2c, sbs_id); 979 980static struct i2c_driver sbs_battery_driver = { 981 .probe = sbs_probe, 982 .remove = sbs_remove, 983 .id_table = sbs_id, 984 .driver = { 985 .name = "sbs-battery", 986 .of_match_table = of_match_ptr(sbs_dt_ids), 987 .pm = SBS_PM_OPS, 988 }, 989}; 990module_i2c_driver(sbs_battery_driver); 991 992MODULE_DESCRIPTION("SBS battery monitor driver"); 993MODULE_LICENSE("GPL"); 994