1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // max77693_charger.c - Battery charger driver for the Maxim 77693 4 // 5 // Copyright (C) 2014 Samsung Electronics 6 // Krzysztof Kozlowski <krzk@kernel.org> 7 8 #include <linux/module.h> 9 #include <linux/platform_device.h> 10 #include <linux/power_supply.h> 11 #include <linux/regmap.h> 12 #include <linux/mfd/max77693.h> 13 #include <linux/mfd/max77693-common.h> 14 #include <linux/mfd/max77693-private.h> 15 16 #define MAX77693_CHARGER_NAME "max77693-charger" 17 static const char *max77693_charger_model = "MAX77693"; 18 static const char *max77693_charger_manufacturer = "Maxim Integrated"; 19 20 struct max77693_charger { 21 struct device *dev; 22 struct max77693_dev *max77693; 23 struct power_supply *charger; 24 25 u32 constant_volt; 26 u32 min_system_volt; 27 u32 thermal_regulation_temp; 28 u32 batttery_overcurrent; 29 u32 charge_input_threshold_volt; 30 }; 31 32 static int max77693_get_charger_state(struct regmap *regmap, int *val) 33 { 34 int ret; 35 unsigned int data; 36 37 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data); 38 if (ret < 0) 39 return ret; 40 41 data &= CHG_DETAILS_01_CHG_MASK; 42 data >>= CHG_DETAILS_01_CHG_SHIFT; 43 44 switch (data) { 45 case MAX77693_CHARGING_PREQUALIFICATION: 46 case MAX77693_CHARGING_FAST_CONST_CURRENT: 47 case MAX77693_CHARGING_FAST_CONST_VOLTAGE: 48 case MAX77693_CHARGING_TOP_OFF: 49 /* In high temp the charging current is reduced, but still charging */ 50 case MAX77693_CHARGING_HIGH_TEMP: 51 *val = POWER_SUPPLY_STATUS_CHARGING; 52 break; 53 case MAX77693_CHARGING_DONE: 54 *val = POWER_SUPPLY_STATUS_FULL; 55 break; 56 case MAX77693_CHARGING_TIMER_EXPIRED: 57 case MAX77693_CHARGING_THERMISTOR_SUSPEND: 58 *val = POWER_SUPPLY_STATUS_NOT_CHARGING; 59 break; 60 case MAX77693_CHARGING_OFF: 61 case MAX77693_CHARGING_OVER_TEMP: 62 case MAX77693_CHARGING_WATCHDOG_EXPIRED: 63 *val = POWER_SUPPLY_STATUS_DISCHARGING; 64 break; 65 case MAX77693_CHARGING_RESERVED: 66 default: 67 *val = POWER_SUPPLY_STATUS_UNKNOWN; 68 } 69 70 return 0; 71 } 72 73 static int max77693_get_charge_type(struct regmap *regmap, int *val) 74 { 75 int ret; 76 unsigned int data; 77 78 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data); 79 if (ret < 0) 80 return ret; 81 82 data &= CHG_DETAILS_01_CHG_MASK; 83 data >>= CHG_DETAILS_01_CHG_SHIFT; 84 85 switch (data) { 86 case MAX77693_CHARGING_PREQUALIFICATION: 87 /* 88 * Top-off: trickle or fast? In top-off the current varies between 89 * 100 and 250 mA. It is higher than prequalification current. 90 */ 91 case MAX77693_CHARGING_TOP_OFF: 92 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 93 break; 94 case MAX77693_CHARGING_FAST_CONST_CURRENT: 95 case MAX77693_CHARGING_FAST_CONST_VOLTAGE: 96 /* In high temp the charging current is reduced, but still charging */ 97 case MAX77693_CHARGING_HIGH_TEMP: 98 *val = POWER_SUPPLY_CHARGE_TYPE_FAST; 99 break; 100 case MAX77693_CHARGING_DONE: 101 case MAX77693_CHARGING_TIMER_EXPIRED: 102 case MAX77693_CHARGING_THERMISTOR_SUSPEND: 103 case MAX77693_CHARGING_OFF: 104 case MAX77693_CHARGING_OVER_TEMP: 105 case MAX77693_CHARGING_WATCHDOG_EXPIRED: 106 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 107 break; 108 case MAX77693_CHARGING_RESERVED: 109 default: 110 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 111 } 112 113 return 0; 114 } 115 116 /* 117 * Supported health statuses: 118 * - POWER_SUPPLY_HEALTH_DEAD 119 * - POWER_SUPPLY_HEALTH_GOOD 120 * - POWER_SUPPLY_HEALTH_OVERVOLTAGE 121 * - POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE 122 * - POWER_SUPPLY_HEALTH_UNKNOWN 123 * - POWER_SUPPLY_HEALTH_UNSPEC_FAILURE 124 */ 125 static int max77693_get_battery_health(struct regmap *regmap, int *val) 126 { 127 int ret; 128 unsigned int data; 129 130 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data); 131 if (ret < 0) 132 return ret; 133 134 data &= CHG_DETAILS_01_BAT_MASK; 135 data >>= CHG_DETAILS_01_BAT_SHIFT; 136 137 switch (data) { 138 case MAX77693_BATTERY_NOBAT: 139 *val = POWER_SUPPLY_HEALTH_DEAD; 140 break; 141 case MAX77693_BATTERY_PREQUALIFICATION: 142 case MAX77693_BATTERY_GOOD: 143 case MAX77693_BATTERY_LOWVOLTAGE: 144 *val = POWER_SUPPLY_HEALTH_GOOD; 145 break; 146 case MAX77693_BATTERY_TIMER_EXPIRED: 147 /* 148 * Took longer to charge than expected, charging suspended. 149 * Damaged battery? 150 */ 151 *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 152 break; 153 case MAX77693_BATTERY_OVERVOLTAGE: 154 *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 155 break; 156 case MAX77693_BATTERY_OVERCURRENT: 157 *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 158 break; 159 case MAX77693_BATTERY_RESERVED: 160 default: 161 *val = POWER_SUPPLY_HEALTH_UNKNOWN; 162 break; 163 } 164 165 return 0; 166 } 167 168 static int max77693_get_present(struct regmap *regmap, int *val) 169 { 170 unsigned int data; 171 int ret; 172 173 /* 174 * Read CHG_INT_OK register. High DETBAT bit here should be 175 * equal to value 0x0 in CHG_DETAILS_01/BAT field. 176 */ 177 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data); 178 if (ret < 0) 179 return ret; 180 181 *val = (data & CHG_INT_OK_DETBAT_MASK) ? 0 : 1; 182 183 return 0; 184 } 185 186 static int max77693_get_online(struct regmap *regmap, int *val) 187 { 188 unsigned int data; 189 int ret; 190 191 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data); 192 if (ret < 0) 193 return ret; 194 195 *val = (data & CHG_INT_OK_CHGIN_MASK) ? 1 : 0; 196 197 return 0; 198 } 199 200 static enum power_supply_property max77693_charger_props[] = { 201 POWER_SUPPLY_PROP_STATUS, 202 POWER_SUPPLY_PROP_CHARGE_TYPE, 203 POWER_SUPPLY_PROP_HEALTH, 204 POWER_SUPPLY_PROP_PRESENT, 205 POWER_SUPPLY_PROP_ONLINE, 206 POWER_SUPPLY_PROP_MODEL_NAME, 207 POWER_SUPPLY_PROP_MANUFACTURER, 208 }; 209 210 static int max77693_charger_get_property(struct power_supply *psy, 211 enum power_supply_property psp, 212 union power_supply_propval *val) 213 { 214 struct max77693_charger *chg = power_supply_get_drvdata(psy); 215 struct regmap *regmap = chg->max77693->regmap; 216 int ret = 0; 217 218 switch (psp) { 219 case POWER_SUPPLY_PROP_STATUS: 220 ret = max77693_get_charger_state(regmap, &val->intval); 221 break; 222 case POWER_SUPPLY_PROP_CHARGE_TYPE: 223 ret = max77693_get_charge_type(regmap, &val->intval); 224 break; 225 case POWER_SUPPLY_PROP_HEALTH: 226 ret = max77693_get_battery_health(regmap, &val->intval); 227 break; 228 case POWER_SUPPLY_PROP_PRESENT: 229 ret = max77693_get_present(regmap, &val->intval); 230 break; 231 case POWER_SUPPLY_PROP_ONLINE: 232 ret = max77693_get_online(regmap, &val->intval); 233 break; 234 case POWER_SUPPLY_PROP_MODEL_NAME: 235 val->strval = max77693_charger_model; 236 break; 237 case POWER_SUPPLY_PROP_MANUFACTURER: 238 val->strval = max77693_charger_manufacturer; 239 break; 240 default: 241 return -EINVAL; 242 } 243 244 return ret; 245 } 246 247 static const struct power_supply_desc max77693_charger_desc = { 248 .name = MAX77693_CHARGER_NAME, 249 .type = POWER_SUPPLY_TYPE_BATTERY, 250 .properties = max77693_charger_props, 251 .num_properties = ARRAY_SIZE(max77693_charger_props), 252 .get_property = max77693_charger_get_property, 253 }; 254 255 static ssize_t device_attr_store(struct device *dev, 256 struct device_attribute *attr, const char *buf, size_t count, 257 int (*fn)(struct max77693_charger *, unsigned long)) 258 { 259 struct max77693_charger *chg = dev_get_drvdata(dev); 260 unsigned long val; 261 int ret; 262 263 ret = kstrtoul(buf, 10, &val); 264 if (ret) 265 return ret; 266 267 ret = fn(chg, val); 268 if (ret) 269 return ret; 270 271 return count; 272 } 273 274 static ssize_t fast_charge_timer_show(struct device *dev, 275 struct device_attribute *attr, char *buf) 276 { 277 struct max77693_charger *chg = dev_get_drvdata(dev); 278 unsigned int data, val; 279 int ret; 280 281 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01, 282 &data); 283 if (ret < 0) 284 return ret; 285 286 data &= CHG_CNFG_01_FCHGTIME_MASK; 287 data >>= CHG_CNFG_01_FCHGTIME_SHIFT; 288 switch (data) { 289 case 0x1 ... 0x7: 290 /* Starting from 4 hours, step by 2 hours */ 291 val = 4 + (data - 1) * 2; 292 break; 293 case 0x0: 294 default: 295 val = 0; 296 break; 297 } 298 299 return scnprintf(buf, PAGE_SIZE, "%u\n", val); 300 } 301 302 static int max77693_set_fast_charge_timer(struct max77693_charger *chg, 303 unsigned long hours) 304 { 305 unsigned int data; 306 307 /* 308 * 0x00 - disable 309 * 0x01 - 4h 310 * 0x02 - 6h 311 * ... 312 * 0x07 - 16h 313 * Round down odd values. 314 */ 315 switch (hours) { 316 case 4 ... 16: 317 data = (hours - 4) / 2 + 1; 318 break; 319 case 0: 320 /* Disable */ 321 data = 0; 322 break; 323 default: 324 return -EINVAL; 325 } 326 data <<= CHG_CNFG_01_FCHGTIME_SHIFT; 327 328 return regmap_update_bits(chg->max77693->regmap, 329 MAX77693_CHG_REG_CHG_CNFG_01, 330 CHG_CNFG_01_FCHGTIME_MASK, data); 331 } 332 333 static ssize_t fast_charge_timer_store(struct device *dev, 334 struct device_attribute *attr, const char *buf, size_t count) 335 { 336 return device_attr_store(dev, attr, buf, count, 337 max77693_set_fast_charge_timer); 338 } 339 340 static ssize_t top_off_threshold_current_show(struct device *dev, 341 struct device_attribute *attr, char *buf) 342 { 343 struct max77693_charger *chg = dev_get_drvdata(dev); 344 unsigned int data, val; 345 int ret; 346 347 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03, 348 &data); 349 if (ret < 0) 350 return ret; 351 352 data &= CHG_CNFG_03_TOITH_MASK; 353 data >>= CHG_CNFG_03_TOITH_SHIFT; 354 355 if (data <= 0x04) 356 val = 100000 + data * 25000; 357 else 358 val = data * 50000; 359 360 return scnprintf(buf, PAGE_SIZE, "%u\n", val); 361 } 362 363 static int max77693_set_top_off_threshold_current(struct max77693_charger *chg, 364 unsigned long uamp) 365 { 366 unsigned int data; 367 368 if (uamp < 100000 || uamp > 350000) 369 return -EINVAL; 370 371 if (uamp <= 200000) 372 data = (uamp - 100000) / 25000; 373 else 374 /* (200000, 350000> */ 375 data = uamp / 50000; 376 377 data <<= CHG_CNFG_03_TOITH_SHIFT; 378 379 return regmap_update_bits(chg->max77693->regmap, 380 MAX77693_CHG_REG_CHG_CNFG_03, 381 CHG_CNFG_03_TOITH_MASK, data); 382 } 383 384 static ssize_t top_off_threshold_current_store(struct device *dev, 385 struct device_attribute *attr, const char *buf, size_t count) 386 { 387 return device_attr_store(dev, attr, buf, count, 388 max77693_set_top_off_threshold_current); 389 } 390 391 static ssize_t top_off_timer_show(struct device *dev, 392 struct device_attribute *attr, char *buf) 393 { 394 struct max77693_charger *chg = dev_get_drvdata(dev); 395 unsigned int data, val; 396 int ret; 397 398 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03, 399 &data); 400 if (ret < 0) 401 return ret; 402 403 data &= CHG_CNFG_03_TOTIME_MASK; 404 data >>= CHG_CNFG_03_TOTIME_SHIFT; 405 406 val = data * 10; 407 408 return scnprintf(buf, PAGE_SIZE, "%u\n", val); 409 } 410 411 static int max77693_set_top_off_timer(struct max77693_charger *chg, 412 unsigned long minutes) 413 { 414 unsigned int data; 415 416 if (minutes > 70) 417 return -EINVAL; 418 419 data = minutes / 10; 420 data <<= CHG_CNFG_03_TOTIME_SHIFT; 421 422 return regmap_update_bits(chg->max77693->regmap, 423 MAX77693_CHG_REG_CHG_CNFG_03, 424 CHG_CNFG_03_TOTIME_MASK, data); 425 } 426 427 static ssize_t top_off_timer_store(struct device *dev, 428 struct device_attribute *attr, const char *buf, size_t count) 429 { 430 return device_attr_store(dev, attr, buf, count, 431 max77693_set_top_off_timer); 432 } 433 434 static DEVICE_ATTR_RW(fast_charge_timer); 435 static DEVICE_ATTR_RW(top_off_threshold_current); 436 static DEVICE_ATTR_RW(top_off_timer); 437 438 static int max77693_set_constant_volt(struct max77693_charger *chg, 439 unsigned int uvolt) 440 { 441 unsigned int data; 442 443 /* 444 * 0x00 - 3.650 V 445 * 0x01 - 3.675 V 446 * ... 447 * 0x1b - 4.325 V 448 * 0x1c - 4.340 V 449 * 0x1d - 4.350 V 450 * 0x1e - 4.375 V 451 * 0x1f - 4.400 V 452 */ 453 if (uvolt >= 3650000 && uvolt < 4340000) 454 data = (uvolt - 3650000) / 25000; 455 else if (uvolt >= 4340000 && uvolt < 4350000) 456 data = 0x1c; 457 else if (uvolt >= 4350000 && uvolt <= 4400000) 458 data = 0x1d + (uvolt - 4350000) / 25000; 459 else { 460 dev_err(chg->dev, "Wrong value for charging constant voltage\n"); 461 return -EINVAL; 462 } 463 464 data <<= CHG_CNFG_04_CHGCVPRM_SHIFT; 465 466 dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt, 467 data); 468 469 return regmap_update_bits(chg->max77693->regmap, 470 MAX77693_CHG_REG_CHG_CNFG_04, 471 CHG_CNFG_04_CHGCVPRM_MASK, data); 472 } 473 474 static int max77693_set_min_system_volt(struct max77693_charger *chg, 475 unsigned int uvolt) 476 { 477 unsigned int data; 478 479 if (uvolt < 3000000 || uvolt > 3700000) { 480 dev_err(chg->dev, "Wrong value for minimum system regulation voltage\n"); 481 return -EINVAL; 482 } 483 484 data = (uvolt - 3000000) / 100000; 485 486 data <<= CHG_CNFG_04_MINVSYS_SHIFT; 487 488 dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n", 489 uvolt, data); 490 491 return regmap_update_bits(chg->max77693->regmap, 492 MAX77693_CHG_REG_CHG_CNFG_04, 493 CHG_CNFG_04_MINVSYS_MASK, data); 494 } 495 496 static int max77693_set_thermal_regulation_temp(struct max77693_charger *chg, 497 unsigned int cels) 498 { 499 unsigned int data; 500 501 switch (cels) { 502 case 70: 503 case 85: 504 case 100: 505 case 115: 506 data = (cels - 70) / 15; 507 break; 508 default: 509 dev_err(chg->dev, "Wrong value for thermal regulation loop temperature\n"); 510 return -EINVAL; 511 } 512 513 data <<= CHG_CNFG_07_REGTEMP_SHIFT; 514 515 dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n", 516 cels, data); 517 518 return regmap_update_bits(chg->max77693->regmap, 519 MAX77693_CHG_REG_CHG_CNFG_07, 520 CHG_CNFG_07_REGTEMP_MASK, data); 521 } 522 523 static int max77693_set_batttery_overcurrent(struct max77693_charger *chg, 524 unsigned int uamp) 525 { 526 unsigned int data; 527 528 if (uamp && (uamp < 2000000 || uamp > 3500000)) { 529 dev_err(chg->dev, "Wrong value for battery overcurrent\n"); 530 return -EINVAL; 531 } 532 533 if (uamp) 534 data = ((uamp - 2000000) / 250000) + 1; 535 else 536 data = 0; /* disable */ 537 538 data <<= CHG_CNFG_12_B2SOVRC_SHIFT; 539 540 dev_dbg(chg->dev, "Battery overcurrent: %u (0x%x)\n", uamp, data); 541 542 return regmap_update_bits(chg->max77693->regmap, 543 MAX77693_CHG_REG_CHG_CNFG_12, 544 CHG_CNFG_12_B2SOVRC_MASK, data); 545 } 546 547 static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg, 548 unsigned int uvolt) 549 { 550 unsigned int data; 551 552 switch (uvolt) { 553 case 4300000: 554 data = 0x0; 555 break; 556 case 4700000: 557 case 4800000: 558 case 4900000: 559 data = (uvolt - 4700000) / 100000; 560 break; 561 default: 562 dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold\n"); 563 return -EINVAL; 564 } 565 566 data <<= CHG_CNFG_12_VCHGINREG_SHIFT; 567 568 dev_dbg(chg->dev, "Charge input voltage regulation threshold: %u (0x%x)\n", 569 uvolt, data); 570 571 return regmap_update_bits(chg->max77693->regmap, 572 MAX77693_CHG_REG_CHG_CNFG_12, 573 CHG_CNFG_12_VCHGINREG_MASK, data); 574 } 575 576 /* 577 * Sets charger registers to proper and safe default values. 578 */ 579 static int max77693_reg_init(struct max77693_charger *chg) 580 { 581 int ret; 582 unsigned int data; 583 584 /* Unlock charger register protection */ 585 data = (0x3 << CHG_CNFG_06_CHGPROT_SHIFT); 586 ret = regmap_update_bits(chg->max77693->regmap, 587 MAX77693_CHG_REG_CHG_CNFG_06, 588 CHG_CNFG_06_CHGPROT_MASK, data); 589 if (ret) { 590 dev_err(chg->dev, "Error unlocking registers: %d\n", ret); 591 return ret; 592 } 593 594 ret = max77693_set_fast_charge_timer(chg, DEFAULT_FAST_CHARGE_TIMER); 595 if (ret) 596 return ret; 597 598 ret = max77693_set_top_off_threshold_current(chg, 599 DEFAULT_TOP_OFF_THRESHOLD_CURRENT); 600 if (ret) 601 return ret; 602 603 ret = max77693_set_top_off_timer(chg, DEFAULT_TOP_OFF_TIMER); 604 if (ret) 605 return ret; 606 607 ret = max77693_set_constant_volt(chg, chg->constant_volt); 608 if (ret) 609 return ret; 610 611 ret = max77693_set_min_system_volt(chg, chg->min_system_volt); 612 if (ret) 613 return ret; 614 615 ret = max77693_set_thermal_regulation_temp(chg, 616 chg->thermal_regulation_temp); 617 if (ret) 618 return ret; 619 620 ret = max77693_set_batttery_overcurrent(chg, chg->batttery_overcurrent); 621 if (ret) 622 return ret; 623 624 return max77693_set_charge_input_threshold_volt(chg, 625 chg->charge_input_threshold_volt); 626 } 627 628 #ifdef CONFIG_OF 629 static int max77693_dt_init(struct device *dev, struct max77693_charger *chg) 630 { 631 struct device_node *np = dev->of_node; 632 633 if (!np) { 634 dev_err(dev, "no charger OF node\n"); 635 return -EINVAL; 636 } 637 638 if (of_property_read_u32(np, "maxim,constant-microvolt", 639 &chg->constant_volt)) 640 chg->constant_volt = DEFAULT_CONSTANT_VOLT; 641 642 if (of_property_read_u32(np, "maxim,min-system-microvolt", 643 &chg->min_system_volt)) 644 chg->min_system_volt = DEFAULT_MIN_SYSTEM_VOLT; 645 646 if (of_property_read_u32(np, "maxim,thermal-regulation-celsius", 647 &chg->thermal_regulation_temp)) 648 chg->thermal_regulation_temp = DEFAULT_THERMAL_REGULATION_TEMP; 649 650 if (of_property_read_u32(np, "maxim,battery-overcurrent-microamp", 651 &chg->batttery_overcurrent)) 652 chg->batttery_overcurrent = DEFAULT_BATTERY_OVERCURRENT; 653 654 if (of_property_read_u32(np, "maxim,charge-input-threshold-microvolt", 655 &chg->charge_input_threshold_volt)) 656 chg->charge_input_threshold_volt = 657 DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT; 658 659 return 0; 660 } 661 #else /* CONFIG_OF */ 662 static int max77693_dt_init(struct device *dev, struct max77693_charger *chg) 663 { 664 return 0; 665 } 666 #endif /* CONFIG_OF */ 667 668 static int max77693_charger_probe(struct platform_device *pdev) 669 { 670 struct max77693_charger *chg; 671 struct power_supply_config psy_cfg = {}; 672 struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent); 673 int ret; 674 675 chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL); 676 if (!chg) 677 return -ENOMEM; 678 679 platform_set_drvdata(pdev, chg); 680 chg->dev = &pdev->dev; 681 chg->max77693 = max77693; 682 683 ret = max77693_dt_init(&pdev->dev, chg); 684 if (ret) 685 return ret; 686 687 ret = max77693_reg_init(chg); 688 if (ret) 689 return ret; 690 691 psy_cfg.drv_data = chg; 692 693 ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer); 694 if (ret) { 695 dev_err(&pdev->dev, "failed: create fast charge timer sysfs entry\n"); 696 goto err; 697 } 698 699 ret = device_create_file(&pdev->dev, 700 &dev_attr_top_off_threshold_current); 701 if (ret) { 702 dev_err(&pdev->dev, "failed: create top off current sysfs entry\n"); 703 goto err; 704 } 705 706 ret = device_create_file(&pdev->dev, &dev_attr_top_off_timer); 707 if (ret) { 708 dev_err(&pdev->dev, "failed: create top off timer sysfs entry\n"); 709 goto err; 710 } 711 712 chg->charger = power_supply_register(&pdev->dev, 713 &max77693_charger_desc, 714 &psy_cfg); 715 if (IS_ERR(chg->charger)) { 716 dev_err(&pdev->dev, "failed: power supply register\n"); 717 ret = PTR_ERR(chg->charger); 718 goto err; 719 } 720 721 return 0; 722 723 err: 724 device_remove_file(&pdev->dev, &dev_attr_top_off_timer); 725 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current); 726 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer); 727 728 return ret; 729 } 730 731 static int max77693_charger_remove(struct platform_device *pdev) 732 { 733 struct max77693_charger *chg = platform_get_drvdata(pdev); 734 735 device_remove_file(&pdev->dev, &dev_attr_top_off_timer); 736 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current); 737 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer); 738 739 power_supply_unregister(chg->charger); 740 741 return 0; 742 } 743 744 static const struct platform_device_id max77693_charger_id[] = { 745 { "max77693-charger", 0, }, 746 { } 747 }; 748 MODULE_DEVICE_TABLE(platform, max77693_charger_id); 749 750 static struct platform_driver max77693_charger_driver = { 751 .driver = { 752 .name = "max77693-charger", 753 }, 754 .probe = max77693_charger_probe, 755 .remove = max77693_charger_remove, 756 .id_table = max77693_charger_id, 757 }; 758 module_platform_driver(max77693_charger_driver); 759 760 MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>"); 761 MODULE_DESCRIPTION("Maxim 77693 charger driver"); 762 MODULE_LICENSE("GPL"); 763