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