809 lines · c
1// SPDX-License-Identifier: GPL-2.0+2//3// max77693_charger.c - Battery charger driver for the Maxim 776934//5// Copyright (C) 2014 Samsung Electronics6// 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"17static const char *max77693_charger_model = "MAX77693";18static const char *max77693_charger_manufacturer = "Maxim Integrated";19 20struct 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 32static 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 73static 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 between89 * 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_DEAD119 * - POWER_SUPPLY_HEALTH_GOOD120 * - POWER_SUPPLY_HEALTH_OVERVOLTAGE121 * - POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE122 * - POWER_SUPPLY_HEALTH_UNKNOWN123 * - POWER_SUPPLY_HEALTH_UNSPEC_FAILURE124 */125static 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 168static 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 be175 * 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 186static 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/*201 * There are *two* current limit registers:202 * - CHGIN limit, which limits the input current from the external charger;203 * - Fast charge current limit, which limits the current going to the battery.204 */205 206static int max77693_get_input_current_limit(struct regmap *regmap, int *val)207{208 unsigned int data;209 int ret;210 211 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_CNFG_09, &data);212 if (ret < 0)213 return ret;214 215 data &= CHG_CNFG_09_CHGIN_ILIM_MASK;216 data >>= CHG_CNFG_09_CHGIN_ILIM_SHIFT;217 218 if (data <= 0x03)219 /* The first four values (0x00..0x03) are 60mA */220 *val = 60000;221 else222 *val = data * 20000; /* 20mA steps */223 224 return 0;225}226 227static int max77693_get_fast_charge_current(struct regmap *regmap, int *val)228{229 unsigned int data;230 int ret;231 232 ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_CNFG_02, &data);233 if (ret < 0)234 return ret;235 236 data &= CHG_CNFG_02_CC_MASK;237 data >>= CHG_CNFG_02_CC_SHIFT;238 239 *val = data * 33300; /* 33.3mA steps */240 241 return 0;242}243 244static enum power_supply_property max77693_charger_props[] = {245 POWER_SUPPLY_PROP_STATUS,246 POWER_SUPPLY_PROP_CHARGE_TYPE,247 POWER_SUPPLY_PROP_HEALTH,248 POWER_SUPPLY_PROP_PRESENT,249 POWER_SUPPLY_PROP_ONLINE,250 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,251 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,252 POWER_SUPPLY_PROP_MODEL_NAME,253 POWER_SUPPLY_PROP_MANUFACTURER,254};255 256static int max77693_charger_get_property(struct power_supply *psy,257 enum power_supply_property psp,258 union power_supply_propval *val)259{260 struct max77693_charger *chg = power_supply_get_drvdata(psy);261 struct regmap *regmap = chg->max77693->regmap;262 int ret = 0;263 264 switch (psp) {265 case POWER_SUPPLY_PROP_STATUS:266 ret = max77693_get_charger_state(regmap, &val->intval);267 break;268 case POWER_SUPPLY_PROP_CHARGE_TYPE:269 ret = max77693_get_charge_type(regmap, &val->intval);270 break;271 case POWER_SUPPLY_PROP_HEALTH:272 ret = max77693_get_battery_health(regmap, &val->intval);273 break;274 case POWER_SUPPLY_PROP_PRESENT:275 ret = max77693_get_present(regmap, &val->intval);276 break;277 case POWER_SUPPLY_PROP_ONLINE:278 ret = max77693_get_online(regmap, &val->intval);279 break;280 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:281 ret = max77693_get_input_current_limit(regmap, &val->intval);282 break;283 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:284 ret = max77693_get_fast_charge_current(regmap, &val->intval);285 break;286 case POWER_SUPPLY_PROP_MODEL_NAME:287 val->strval = max77693_charger_model;288 break;289 case POWER_SUPPLY_PROP_MANUFACTURER:290 val->strval = max77693_charger_manufacturer;291 break;292 default:293 return -EINVAL;294 }295 296 return ret;297}298 299static const struct power_supply_desc max77693_charger_desc = {300 .name = MAX77693_CHARGER_NAME,301 .type = POWER_SUPPLY_TYPE_BATTERY,302 .properties = max77693_charger_props,303 .num_properties = ARRAY_SIZE(max77693_charger_props),304 .get_property = max77693_charger_get_property,305};306 307static ssize_t device_attr_store(struct device *dev,308 struct device_attribute *attr, const char *buf, size_t count,309 int (*fn)(struct max77693_charger *, unsigned long))310{311 struct max77693_charger *chg = dev_get_drvdata(dev);312 unsigned long val;313 int ret;314 315 ret = kstrtoul(buf, 10, &val);316 if (ret)317 return ret;318 319 ret = fn(chg, val);320 if (ret)321 return ret;322 323 return count;324}325 326static ssize_t fast_charge_timer_show(struct device *dev,327 struct device_attribute *attr, char *buf)328{329 struct max77693_charger *chg = dev_get_drvdata(dev);330 unsigned int data, val;331 int ret;332 333 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01,334 &data);335 if (ret < 0)336 return ret;337 338 data &= CHG_CNFG_01_FCHGTIME_MASK;339 data >>= CHG_CNFG_01_FCHGTIME_SHIFT;340 switch (data) {341 case 0x1 ... 0x7:342 /* Starting from 4 hours, step by 2 hours */343 val = 4 + (data - 1) * 2;344 break;345 case 0x0:346 default:347 val = 0;348 break;349 }350 351 return sysfs_emit(buf, "%u\n", val);352}353 354static int max77693_set_fast_charge_timer(struct max77693_charger *chg,355 unsigned long hours)356{357 unsigned int data;358 359 /*360 * 0x00 - disable361 * 0x01 - 4h362 * 0x02 - 6h363 * ...364 * 0x07 - 16h365 * Round down odd values.366 */367 switch (hours) {368 case 4 ... 16:369 data = (hours - 4) / 2 + 1;370 break;371 case 0:372 /* Disable */373 data = 0;374 break;375 default:376 return -EINVAL;377 }378 data <<= CHG_CNFG_01_FCHGTIME_SHIFT;379 380 return regmap_update_bits(chg->max77693->regmap,381 MAX77693_CHG_REG_CHG_CNFG_01,382 CHG_CNFG_01_FCHGTIME_MASK, data);383}384 385static ssize_t fast_charge_timer_store(struct device *dev,386 struct device_attribute *attr, const char *buf, size_t count)387{388 return device_attr_store(dev, attr, buf, count,389 max77693_set_fast_charge_timer);390}391 392static ssize_t top_off_threshold_current_show(struct device *dev,393 struct device_attribute *attr, char *buf)394{395 struct max77693_charger *chg = dev_get_drvdata(dev);396 unsigned int data, val;397 int ret;398 399 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,400 &data);401 if (ret < 0)402 return ret;403 404 data &= CHG_CNFG_03_TOITH_MASK;405 data >>= CHG_CNFG_03_TOITH_SHIFT;406 407 if (data <= 0x04)408 val = 100000 + data * 25000;409 else410 val = data * 50000;411 412 return sysfs_emit(buf, "%u\n", val);413}414 415static int max77693_set_top_off_threshold_current(struct max77693_charger *chg,416 unsigned long uamp)417{418 unsigned int data;419 420 if (uamp < 100000 || uamp > 350000)421 return -EINVAL;422 423 if (uamp <= 200000)424 data = (uamp - 100000) / 25000;425 else426 /* (200000, 350000> */427 data = uamp / 50000;428 429 data <<= CHG_CNFG_03_TOITH_SHIFT;430 431 return regmap_update_bits(chg->max77693->regmap,432 MAX77693_CHG_REG_CHG_CNFG_03,433 CHG_CNFG_03_TOITH_MASK, data);434}435 436static ssize_t top_off_threshold_current_store(struct device *dev,437 struct device_attribute *attr, const char *buf, size_t count)438{439 return device_attr_store(dev, attr, buf, count,440 max77693_set_top_off_threshold_current);441}442 443static ssize_t top_off_timer_show(struct device *dev,444 struct device_attribute *attr, char *buf)445{446 struct max77693_charger *chg = dev_get_drvdata(dev);447 unsigned int data, val;448 int ret;449 450 ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,451 &data);452 if (ret < 0)453 return ret;454 455 data &= CHG_CNFG_03_TOTIME_MASK;456 data >>= CHG_CNFG_03_TOTIME_SHIFT;457 458 val = data * 10;459 460 return sysfs_emit(buf, "%u\n", val);461}462 463static int max77693_set_top_off_timer(struct max77693_charger *chg,464 unsigned long minutes)465{466 unsigned int data;467 468 if (minutes > 70)469 return -EINVAL;470 471 data = minutes / 10;472 data <<= CHG_CNFG_03_TOTIME_SHIFT;473 474 return regmap_update_bits(chg->max77693->regmap,475 MAX77693_CHG_REG_CHG_CNFG_03,476 CHG_CNFG_03_TOTIME_MASK, data);477}478 479static ssize_t top_off_timer_store(struct device *dev,480 struct device_attribute *attr, const char *buf, size_t count)481{482 return device_attr_store(dev, attr, buf, count,483 max77693_set_top_off_timer);484}485 486static DEVICE_ATTR_RW(fast_charge_timer);487static DEVICE_ATTR_RW(top_off_threshold_current);488static DEVICE_ATTR_RW(top_off_timer);489 490static int max77693_set_constant_volt(struct max77693_charger *chg,491 unsigned int uvolt)492{493 unsigned int data;494 495 /*496 * 0x00 - 3.650 V497 * 0x01 - 3.675 V498 * ...499 * 0x1b - 4.325 V500 * 0x1c - 4.340 V501 * 0x1d - 4.350 V502 * 0x1e - 4.375 V503 * 0x1f - 4.400 V504 */505 if (uvolt >= 3650000 && uvolt < 4340000)506 data = (uvolt - 3650000) / 25000;507 else if (uvolt >= 4340000 && uvolt < 4350000)508 data = 0x1c;509 else if (uvolt >= 4350000 && uvolt <= 4400000)510 data = 0x1d + (uvolt - 4350000) / 25000;511 else {512 dev_err(chg->dev, "Wrong value for charging constant voltage\n");513 return -EINVAL;514 }515 516 data <<= CHG_CNFG_04_CHGCVPRM_SHIFT;517 518 dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt,519 data);520 521 return regmap_update_bits(chg->max77693->regmap,522 MAX77693_CHG_REG_CHG_CNFG_04,523 CHG_CNFG_04_CHGCVPRM_MASK, data);524}525 526static int max77693_set_min_system_volt(struct max77693_charger *chg,527 unsigned int uvolt)528{529 unsigned int data;530 531 if (uvolt < 3000000 || uvolt > 3700000) {532 dev_err(chg->dev, "Wrong value for minimum system regulation voltage\n");533 return -EINVAL;534 }535 536 data = (uvolt - 3000000) / 100000;537 538 data <<= CHG_CNFG_04_MINVSYS_SHIFT;539 540 dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n",541 uvolt, data);542 543 return regmap_update_bits(chg->max77693->regmap,544 MAX77693_CHG_REG_CHG_CNFG_04,545 CHG_CNFG_04_MINVSYS_MASK, data);546}547 548static int max77693_set_thermal_regulation_temp(struct max77693_charger *chg,549 unsigned int cels)550{551 unsigned int data;552 553 switch (cels) {554 case 70:555 case 85:556 case 100:557 case 115:558 data = (cels - 70) / 15;559 break;560 default:561 dev_err(chg->dev, "Wrong value for thermal regulation loop temperature\n");562 return -EINVAL;563 }564 565 data <<= CHG_CNFG_07_REGTEMP_SHIFT;566 567 dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n",568 cels, data);569 570 return regmap_update_bits(chg->max77693->regmap,571 MAX77693_CHG_REG_CHG_CNFG_07,572 CHG_CNFG_07_REGTEMP_MASK, data);573}574 575static int max77693_set_batttery_overcurrent(struct max77693_charger *chg,576 unsigned int uamp)577{578 unsigned int data;579 580 if (uamp && (uamp < 2000000 || uamp > 3500000)) {581 dev_err(chg->dev, "Wrong value for battery overcurrent\n");582 return -EINVAL;583 }584 585 if (uamp)586 data = ((uamp - 2000000) / 250000) + 1;587 else588 data = 0; /* disable */589 590 data <<= CHG_CNFG_12_B2SOVRC_SHIFT;591 592 dev_dbg(chg->dev, "Battery overcurrent: %u (0x%x)\n", uamp, data);593 594 return regmap_update_bits(chg->max77693->regmap,595 MAX77693_CHG_REG_CHG_CNFG_12,596 CHG_CNFG_12_B2SOVRC_MASK, data);597}598 599static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg,600 unsigned int uvolt)601{602 unsigned int data;603 604 switch (uvolt) {605 case 4300000:606 data = 0x0;607 break;608 case 4700000:609 case 4800000:610 case 4900000:611 data = (uvolt - 4700000) / 100000;612 break;613 default:614 dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold\n");615 return -EINVAL;616 }617 618 data <<= CHG_CNFG_12_VCHGINREG_SHIFT;619 620 dev_dbg(chg->dev, "Charge input voltage regulation threshold: %u (0x%x)\n",621 uvolt, data);622 623 return regmap_update_bits(chg->max77693->regmap,624 MAX77693_CHG_REG_CHG_CNFG_12,625 CHG_CNFG_12_VCHGINREG_MASK, data);626}627 628/*629 * Sets charger registers to proper and safe default values.630 */631static int max77693_reg_init(struct max77693_charger *chg)632{633 int ret;634 unsigned int data;635 636 /* Unlock charger register protection */637 data = (0x3 << CHG_CNFG_06_CHGPROT_SHIFT);638 ret = regmap_update_bits(chg->max77693->regmap,639 MAX77693_CHG_REG_CHG_CNFG_06,640 CHG_CNFG_06_CHGPROT_MASK, data);641 if (ret) {642 dev_err(chg->dev, "Error unlocking registers: %d\n", ret);643 return ret;644 }645 646 ret = max77693_set_fast_charge_timer(chg, DEFAULT_FAST_CHARGE_TIMER);647 if (ret)648 return ret;649 650 ret = max77693_set_top_off_threshold_current(chg,651 DEFAULT_TOP_OFF_THRESHOLD_CURRENT);652 if (ret)653 return ret;654 655 ret = max77693_set_top_off_timer(chg, DEFAULT_TOP_OFF_TIMER);656 if (ret)657 return ret;658 659 ret = max77693_set_constant_volt(chg, chg->constant_volt);660 if (ret)661 return ret;662 663 ret = max77693_set_min_system_volt(chg, chg->min_system_volt);664 if (ret)665 return ret;666 667 ret = max77693_set_thermal_regulation_temp(chg,668 chg->thermal_regulation_temp);669 if (ret)670 return ret;671 672 ret = max77693_set_batttery_overcurrent(chg, chg->batttery_overcurrent);673 if (ret)674 return ret;675 676 return max77693_set_charge_input_threshold_volt(chg,677 chg->charge_input_threshold_volt);678}679 680#ifdef CONFIG_OF681static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)682{683 struct device_node *np = dev->of_node;684 685 if (!np) {686 dev_err(dev, "no charger OF node\n");687 return -EINVAL;688 }689 690 if (of_property_read_u32(np, "maxim,constant-microvolt",691 &chg->constant_volt))692 chg->constant_volt = DEFAULT_CONSTANT_VOLT;693 694 if (of_property_read_u32(np, "maxim,min-system-microvolt",695 &chg->min_system_volt))696 chg->min_system_volt = DEFAULT_MIN_SYSTEM_VOLT;697 698 if (of_property_read_u32(np, "maxim,thermal-regulation-celsius",699 &chg->thermal_regulation_temp))700 chg->thermal_regulation_temp = DEFAULT_THERMAL_REGULATION_TEMP;701 702 if (of_property_read_u32(np, "maxim,battery-overcurrent-microamp",703 &chg->batttery_overcurrent))704 chg->batttery_overcurrent = DEFAULT_BATTERY_OVERCURRENT;705 706 if (of_property_read_u32(np, "maxim,charge-input-threshold-microvolt",707 &chg->charge_input_threshold_volt))708 chg->charge_input_threshold_volt =709 DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT;710 711 return 0;712}713#else /* CONFIG_OF */714static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)715{716 return 0;717}718#endif /* CONFIG_OF */719 720static int max77693_charger_probe(struct platform_device *pdev)721{722 struct max77693_charger *chg;723 struct power_supply_config psy_cfg = {};724 struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent);725 int ret;726 727 chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);728 if (!chg)729 return -ENOMEM;730 731 platform_set_drvdata(pdev, chg);732 chg->dev = &pdev->dev;733 chg->max77693 = max77693;734 735 ret = max77693_dt_init(&pdev->dev, chg);736 if (ret)737 return ret;738 739 ret = max77693_reg_init(chg);740 if (ret)741 return ret;742 743 psy_cfg.drv_data = chg;744 745 ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);746 if (ret) {747 dev_err(&pdev->dev, "failed: create fast charge timer sysfs entry\n");748 goto err;749 }750 751 ret = device_create_file(&pdev->dev,752 &dev_attr_top_off_threshold_current);753 if (ret) {754 dev_err(&pdev->dev, "failed: create top off current sysfs entry\n");755 goto err;756 }757 758 ret = device_create_file(&pdev->dev, &dev_attr_top_off_timer);759 if (ret) {760 dev_err(&pdev->dev, "failed: create top off timer sysfs entry\n");761 goto err;762 }763 764 chg->charger = devm_power_supply_register(&pdev->dev,765 &max77693_charger_desc,766 &psy_cfg);767 if (IS_ERR(chg->charger)) {768 dev_err(&pdev->dev, "failed: power supply register\n");769 ret = PTR_ERR(chg->charger);770 goto err;771 }772 773 return 0;774 775err:776 device_remove_file(&pdev->dev, &dev_attr_top_off_timer);777 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);778 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);779 780 return ret;781}782 783static void max77693_charger_remove(struct platform_device *pdev)784{785 device_remove_file(&pdev->dev, &dev_attr_top_off_timer);786 device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);787 device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);788}789 790static const struct platform_device_id max77693_charger_id[] = {791 { "max77693-charger", 0, },792 { }793};794MODULE_DEVICE_TABLE(platform, max77693_charger_id);795 796static struct platform_driver max77693_charger_driver = {797 .driver = {798 .name = "max77693-charger",799 },800 .probe = max77693_charger_probe,801 .remove_new = max77693_charger_remove,802 .id_table = max77693_charger_id,803};804module_platform_driver(max77693_charger_driver);805 806MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");807MODULE_DESCRIPTION("Maxim 77693 charger driver");808MODULE_LICENSE("GPL");809