power/supply/max77693_charger.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // max77693_charger.c - Battery charger driver for the Maxim 77693
0004 //
0005 // Copyright (C) 2014 Samsung Electronics
0006 // Krzysztof Kozlowski <krzk@kernel.org>
0007
0008 #include <linux/module.h>
0009 #include <linux/platform_device.h>
0010 #include <linux/power_supply.h>
0011 #include <linux/regmap.h>
0012 #include <linux/mfd/max77693.h>
0013 #include <linux/mfd/max77693-common.h>
0014 #include <linux/mfd/max77693-private.h>
0015
0016 #define MAX77693_CHARGER_NAME               "max77693-charger"
0017 static const char *max77693_charger_model       = "MAX77693";
0018 static const char *max77693_charger_manufacturer    = "Maxim Integrated";
0019
0020 struct max77693_charger {
0021     struct device       *dev;
0022     struct max77693_dev *max77693;
0023     struct power_supply *charger;
0024
0025     u32 constant_volt;
0026     u32 min_system_volt;
0027     u32 thermal_regulation_temp;
0028     u32 batttery_overcurrent;
0029     u32 charge_input_threshold_volt;
0030 };
0031
0032 static int max77693_get_charger_state(struct regmap *regmap, int *val)
0033 {
0034     int ret;
0035     unsigned int data;
0036
0037     ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
0038     if (ret < 0)
0039         return ret;
0040
0041     data &= CHG_DETAILS_01_CHG_MASK;
0042     data >>= CHG_DETAILS_01_CHG_SHIFT;
0043
0044     switch (data) {
0045     case MAX77693_CHARGING_PREQUALIFICATION:
0046     case MAX77693_CHARGING_FAST_CONST_CURRENT:
0047     case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
0048     case MAX77693_CHARGING_TOP_OFF:
0049     /* In high temp the charging current is reduced, but still charging */
0050     case MAX77693_CHARGING_HIGH_TEMP:
0051         *val = POWER_SUPPLY_STATUS_CHARGING;
0052         break;
0053     case MAX77693_CHARGING_DONE:
0054         *val = POWER_SUPPLY_STATUS_FULL;
0055         break;
0056     case MAX77693_CHARGING_TIMER_EXPIRED:
0057     case MAX77693_CHARGING_THERMISTOR_SUSPEND:
0058         *val = POWER_SUPPLY_STATUS_NOT_CHARGING;
0059         break;
0060     case MAX77693_CHARGING_OFF:
0061     case MAX77693_CHARGING_OVER_TEMP:
0062     case MAX77693_CHARGING_WATCHDOG_EXPIRED:
0063         *val = POWER_SUPPLY_STATUS_DISCHARGING;
0064         break;
0065     case MAX77693_CHARGING_RESERVED:
0066     default:
0067         *val = POWER_SUPPLY_STATUS_UNKNOWN;
0068     }
0069
0070     return 0;
0071 }
0072
0073 static int max77693_get_charge_type(struct regmap *regmap, int *val)
0074 {
0075     int ret;
0076     unsigned int data;
0077
0078     ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
0079     if (ret < 0)
0080         return ret;
0081
0082     data &= CHG_DETAILS_01_CHG_MASK;
0083     data >>= CHG_DETAILS_01_CHG_SHIFT;
0084
0085     switch (data) {
0086     case MAX77693_CHARGING_PREQUALIFICATION:
0087     /*
0088      * Top-off: trickle or fast? In top-off the current varies between
0089      * 100 and 250 mA. It is higher than prequalification current.
0090      */
0091     case MAX77693_CHARGING_TOP_OFF:
0092         *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
0093         break;
0094     case MAX77693_CHARGING_FAST_CONST_CURRENT:
0095     case MAX77693_CHARGING_FAST_CONST_VOLTAGE:
0096     /* In high temp the charging current is reduced, but still charging */
0097     case MAX77693_CHARGING_HIGH_TEMP:
0098         *val = POWER_SUPPLY_CHARGE_TYPE_FAST;
0099         break;
0100     case MAX77693_CHARGING_DONE:
0101     case MAX77693_CHARGING_TIMER_EXPIRED:
0102     case MAX77693_CHARGING_THERMISTOR_SUSPEND:
0103     case MAX77693_CHARGING_OFF:
0104     case MAX77693_CHARGING_OVER_TEMP:
0105     case MAX77693_CHARGING_WATCHDOG_EXPIRED:
0106         *val = POWER_SUPPLY_CHARGE_TYPE_NONE;
0107         break;
0108     case MAX77693_CHARGING_RESERVED:
0109     default:
0110         *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
0111     }
0112
0113     return 0;
0114 }
0115
0116 /*
0117  * Supported health statuses:
0118  *  - POWER_SUPPLY_HEALTH_DEAD
0119  *  - POWER_SUPPLY_HEALTH_GOOD
0120  *  - POWER_SUPPLY_HEALTH_OVERVOLTAGE
0121  *  - POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
0122  *  - POWER_SUPPLY_HEALTH_UNKNOWN
0123  *  - POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
0124  */
0125 static int max77693_get_battery_health(struct regmap *regmap, int *val)
0126 {
0127     int ret;
0128     unsigned int data;
0129
0130     ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_DETAILS_01, &data);
0131     if (ret < 0)
0132         return ret;
0133
0134     data &= CHG_DETAILS_01_BAT_MASK;
0135     data >>= CHG_DETAILS_01_BAT_SHIFT;
0136
0137     switch (data) {
0138     case MAX77693_BATTERY_NOBAT:
0139         *val = POWER_SUPPLY_HEALTH_DEAD;
0140         break;
0141     case MAX77693_BATTERY_PREQUALIFICATION:
0142     case MAX77693_BATTERY_GOOD:
0143     case MAX77693_BATTERY_LOWVOLTAGE:
0144         *val = POWER_SUPPLY_HEALTH_GOOD;
0145         break;
0146     case MAX77693_BATTERY_TIMER_EXPIRED:
0147         /*
0148          * Took longer to charge than expected, charging suspended.
0149          * Damaged battery?
0150          */
0151         *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
0152         break;
0153     case MAX77693_BATTERY_OVERVOLTAGE:
0154         *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
0155         break;
0156     case MAX77693_BATTERY_OVERCURRENT:
0157         *val = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
0158         break;
0159     case MAX77693_BATTERY_RESERVED:
0160     default:
0161         *val = POWER_SUPPLY_HEALTH_UNKNOWN;
0162         break;
0163     }
0164
0165     return 0;
0166 }
0167
0168 static int max77693_get_present(struct regmap *regmap, int *val)
0169 {
0170     unsigned int data;
0171     int ret;
0172
0173     /*
0174      * Read CHG_INT_OK register. High DETBAT bit here should be
0175      * equal to value 0x0 in CHG_DETAILS_01/BAT field.
0176      */
0177     ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
0178     if (ret < 0)
0179         return ret;
0180
0181     *val = (data & CHG_INT_OK_DETBAT_MASK) ? 0 : 1;
0182
0183     return 0;
0184 }
0185
0186 static int max77693_get_online(struct regmap *regmap, int *val)
0187 {
0188     unsigned int data;
0189     int ret;
0190
0191     ret = regmap_read(regmap, MAX77693_CHG_REG_CHG_INT_OK, &data);
0192     if (ret < 0)
0193         return ret;
0194
0195     *val = (data & CHG_INT_OK_CHGIN_MASK) ? 1 : 0;
0196
0197     return 0;
0198 }
0199
0200 static enum power_supply_property max77693_charger_props[] = {
0201     POWER_SUPPLY_PROP_STATUS,
0202     POWER_SUPPLY_PROP_CHARGE_TYPE,
0203     POWER_SUPPLY_PROP_HEALTH,
0204     POWER_SUPPLY_PROP_PRESENT,
0205     POWER_SUPPLY_PROP_ONLINE,
0206     POWER_SUPPLY_PROP_MODEL_NAME,
0207     POWER_SUPPLY_PROP_MANUFACTURER,
0208 };
0209
0210 static int max77693_charger_get_property(struct power_supply *psy,
0211                 enum power_supply_property psp,
0212                 union power_supply_propval *val)
0213 {
0214     struct max77693_charger *chg = power_supply_get_drvdata(psy);
0215     struct regmap *regmap = chg->max77693->regmap;
0216     int ret = 0;
0217
0218     switch (psp) {
0219     case POWER_SUPPLY_PROP_STATUS:
0220         ret = max77693_get_charger_state(regmap, &val->intval);
0221         break;
0222     case POWER_SUPPLY_PROP_CHARGE_TYPE:
0223         ret = max77693_get_charge_type(regmap, &val->intval);
0224         break;
0225     case POWER_SUPPLY_PROP_HEALTH:
0226         ret = max77693_get_battery_health(regmap, &val->intval);
0227         break;
0228     case POWER_SUPPLY_PROP_PRESENT:
0229         ret = max77693_get_present(regmap, &val->intval);
0230         break;
0231     case POWER_SUPPLY_PROP_ONLINE:
0232         ret = max77693_get_online(regmap, &val->intval);
0233         break;
0234     case POWER_SUPPLY_PROP_MODEL_NAME:
0235         val->strval = max77693_charger_model;
0236         break;
0237     case POWER_SUPPLY_PROP_MANUFACTURER:
0238         val->strval = max77693_charger_manufacturer;
0239         break;
0240     default:
0241         return -EINVAL;
0242     }
0243
0244     return ret;
0245 }
0246
0247 static const struct power_supply_desc max77693_charger_desc = {
0248     .name       = MAX77693_CHARGER_NAME,
0249     .type       = POWER_SUPPLY_TYPE_BATTERY,
0250     .properties = max77693_charger_props,
0251     .num_properties = ARRAY_SIZE(max77693_charger_props),
0252     .get_property   = max77693_charger_get_property,
0253 };
0254
0255 static ssize_t device_attr_store(struct device *dev,
0256         struct device_attribute *attr, const char *buf, size_t count,
0257         int (*fn)(struct max77693_charger *, unsigned long))
0258 {
0259     struct max77693_charger *chg = dev_get_drvdata(dev);
0260     unsigned long val;
0261     int ret;
0262
0263     ret = kstrtoul(buf, 10, &val);
0264     if (ret)
0265         return ret;
0266
0267     ret = fn(chg, val);
0268     if (ret)
0269         return ret;
0270
0271     return count;
0272 }
0273
0274 static ssize_t fast_charge_timer_show(struct device *dev,
0275         struct device_attribute *attr, char *buf)
0276 {
0277     struct max77693_charger *chg = dev_get_drvdata(dev);
0278     unsigned int data, val;
0279     int ret;
0280
0281     ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_01,
0282             &data);
0283     if (ret < 0)
0284         return ret;
0285
0286     data &= CHG_CNFG_01_FCHGTIME_MASK;
0287     data >>= CHG_CNFG_01_FCHGTIME_SHIFT;
0288     switch (data) {
0289     case 0x1 ... 0x7:
0290         /* Starting from 4 hours, step by 2 hours */
0291         val = 4 + (data - 1) * 2;
0292         break;
0293     case 0x0:
0294     default:
0295         val = 0;
0296         break;
0297     }
0298
0299     return scnprintf(buf, PAGE_SIZE, "%u\n", val);
0300 }
0301
0302 static int max77693_set_fast_charge_timer(struct max77693_charger *chg,
0303         unsigned long hours)
0304 {
0305     unsigned int data;
0306
0307     /*
0308      * 0x00 - disable
0309      * 0x01 - 4h
0310      * 0x02 - 6h
0311      * ...
0312      * 0x07 - 16h
0313      * Round down odd values.
0314      */
0315     switch (hours) {
0316     case 4 ... 16:
0317         data = (hours - 4) / 2 + 1;
0318         break;
0319     case 0:
0320         /* Disable */
0321         data = 0;
0322         break;
0323     default:
0324         return -EINVAL;
0325     }
0326     data <<= CHG_CNFG_01_FCHGTIME_SHIFT;
0327
0328     return regmap_update_bits(chg->max77693->regmap,
0329             MAX77693_CHG_REG_CHG_CNFG_01,
0330             CHG_CNFG_01_FCHGTIME_MASK, data);
0331 }
0332
0333 static ssize_t fast_charge_timer_store(struct device *dev,
0334         struct device_attribute *attr, const char *buf, size_t count)
0335 {
0336     return device_attr_store(dev, attr, buf, count,
0337             max77693_set_fast_charge_timer);
0338 }
0339
0340 static ssize_t top_off_threshold_current_show(struct device *dev,
0341         struct device_attribute *attr, char *buf)
0342 {
0343     struct max77693_charger *chg = dev_get_drvdata(dev);
0344     unsigned int data, val;
0345     int ret;
0346
0347     ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
0348             &data);
0349     if (ret < 0)
0350         return ret;
0351
0352     data &= CHG_CNFG_03_TOITH_MASK;
0353     data >>= CHG_CNFG_03_TOITH_SHIFT;
0354
0355     if (data <= 0x04)
0356         val = 100000 + data * 25000;
0357     else
0358         val = data * 50000;
0359
0360     return scnprintf(buf, PAGE_SIZE, "%u\n", val);
0361 }
0362
0363 static int max77693_set_top_off_threshold_current(struct max77693_charger *chg,
0364         unsigned long uamp)
0365 {
0366     unsigned int data;
0367
0368     if (uamp < 100000 || uamp > 350000)
0369         return -EINVAL;
0370
0371     if (uamp <= 200000)
0372         data = (uamp - 100000) / 25000;
0373     else
0374         /* (200000, 350000> */
0375         data = uamp / 50000;
0376
0377     data <<= CHG_CNFG_03_TOITH_SHIFT;
0378
0379     return regmap_update_bits(chg->max77693->regmap,
0380             MAX77693_CHG_REG_CHG_CNFG_03,
0381             CHG_CNFG_03_TOITH_MASK, data);
0382 }
0383
0384 static ssize_t top_off_threshold_current_store(struct device *dev,
0385         struct device_attribute *attr, const char *buf, size_t count)
0386 {
0387     return device_attr_store(dev, attr, buf, count,
0388             max77693_set_top_off_threshold_current);
0389 }
0390
0391 static ssize_t top_off_timer_show(struct device *dev,
0392         struct device_attribute *attr, char *buf)
0393 {
0394     struct max77693_charger *chg = dev_get_drvdata(dev);
0395     unsigned int data, val;
0396     int ret;
0397
0398     ret = regmap_read(chg->max77693->regmap, MAX77693_CHG_REG_CHG_CNFG_03,
0399             &data);
0400     if (ret < 0)
0401         return ret;
0402
0403     data &= CHG_CNFG_03_TOTIME_MASK;
0404     data >>= CHG_CNFG_03_TOTIME_SHIFT;
0405
0406     val = data * 10;
0407
0408     return scnprintf(buf, PAGE_SIZE, "%u\n", val);
0409 }
0410
0411 static int max77693_set_top_off_timer(struct max77693_charger *chg,
0412         unsigned long minutes)
0413 {
0414     unsigned int data;
0415
0416     if (minutes > 70)
0417         return -EINVAL;
0418
0419     data = minutes / 10;
0420     data <<= CHG_CNFG_03_TOTIME_SHIFT;
0421
0422     return regmap_update_bits(chg->max77693->regmap,
0423             MAX77693_CHG_REG_CHG_CNFG_03,
0424             CHG_CNFG_03_TOTIME_MASK, data);
0425 }
0426
0427 static ssize_t top_off_timer_store(struct device *dev,
0428         struct device_attribute *attr, const char *buf, size_t count)
0429 {
0430     return device_attr_store(dev, attr, buf, count,
0431             max77693_set_top_off_timer);
0432 }
0433
0434 static DEVICE_ATTR_RW(fast_charge_timer);
0435 static DEVICE_ATTR_RW(top_off_threshold_current);
0436 static DEVICE_ATTR_RW(top_off_timer);
0437
0438 static int max77693_set_constant_volt(struct max77693_charger *chg,
0439         unsigned int uvolt)
0440 {
0441     unsigned int data;
0442
0443     /*
0444      * 0x00 - 3.650 V
0445      * 0x01 - 3.675 V
0446      * ...
0447      * 0x1b - 4.325 V
0448      * 0x1c - 4.340 V
0449      * 0x1d - 4.350 V
0450      * 0x1e - 4.375 V
0451      * 0x1f - 4.400 V
0452      */
0453     if (uvolt >= 3650000 && uvolt < 4340000)
0454         data = (uvolt - 3650000) / 25000;
0455     else if (uvolt >= 4340000 && uvolt < 4350000)
0456         data = 0x1c;
0457     else if (uvolt >= 4350000 && uvolt <= 4400000)
0458         data = 0x1d + (uvolt - 4350000) / 25000;
0459     else {
0460         dev_err(chg->dev, "Wrong value for charging constant voltage\n");
0461         return -EINVAL;
0462     }
0463
0464     data <<= CHG_CNFG_04_CHGCVPRM_SHIFT;
0465
0466     dev_dbg(chg->dev, "Charging constant voltage: %u (0x%x)\n", uvolt,
0467             data);
0468
0469     return regmap_update_bits(chg->max77693->regmap,
0470             MAX77693_CHG_REG_CHG_CNFG_04,
0471             CHG_CNFG_04_CHGCVPRM_MASK, data);
0472 }
0473
0474 static int max77693_set_min_system_volt(struct max77693_charger *chg,
0475         unsigned int uvolt)
0476 {
0477     unsigned int data;
0478
0479     if (uvolt < 3000000 || uvolt > 3700000) {
0480         dev_err(chg->dev, "Wrong value for minimum system regulation voltage\n");
0481         return -EINVAL;
0482     }
0483
0484     data = (uvolt - 3000000) / 100000;
0485
0486     data <<= CHG_CNFG_04_MINVSYS_SHIFT;
0487
0488     dev_dbg(chg->dev, "Minimum system regulation voltage: %u (0x%x)\n",
0489             uvolt, data);
0490
0491     return regmap_update_bits(chg->max77693->regmap,
0492             MAX77693_CHG_REG_CHG_CNFG_04,
0493             CHG_CNFG_04_MINVSYS_MASK, data);
0494 }
0495
0496 static int max77693_set_thermal_regulation_temp(struct max77693_charger *chg,
0497         unsigned int cels)
0498 {
0499     unsigned int data;
0500
0501     switch (cels) {
0502     case 70:
0503     case 85:
0504     case 100:
0505     case 115:
0506         data = (cels - 70) / 15;
0507         break;
0508     default:
0509         dev_err(chg->dev, "Wrong value for thermal regulation loop temperature\n");
0510         return -EINVAL;
0511     }
0512
0513     data <<= CHG_CNFG_07_REGTEMP_SHIFT;
0514
0515     dev_dbg(chg->dev, "Thermal regulation loop temperature: %u (0x%x)\n",
0516             cels, data);
0517
0518     return regmap_update_bits(chg->max77693->regmap,
0519             MAX77693_CHG_REG_CHG_CNFG_07,
0520             CHG_CNFG_07_REGTEMP_MASK, data);
0521 }
0522
0523 static int max77693_set_batttery_overcurrent(struct max77693_charger *chg,
0524         unsigned int uamp)
0525 {
0526     unsigned int data;
0527
0528     if (uamp && (uamp < 2000000 || uamp > 3500000)) {
0529         dev_err(chg->dev, "Wrong value for battery overcurrent\n");
0530         return -EINVAL;
0531     }
0532
0533     if (uamp)
0534         data = ((uamp - 2000000) / 250000) + 1;
0535     else
0536         data = 0; /* disable */
0537
0538     data <<= CHG_CNFG_12_B2SOVRC_SHIFT;
0539
0540     dev_dbg(chg->dev, "Battery overcurrent: %u (0x%x)\n", uamp, data);
0541
0542     return regmap_update_bits(chg->max77693->regmap,
0543             MAX77693_CHG_REG_CHG_CNFG_12,
0544             CHG_CNFG_12_B2SOVRC_MASK, data);
0545 }
0546
0547 static int max77693_set_charge_input_threshold_volt(struct max77693_charger *chg,
0548         unsigned int uvolt)
0549 {
0550     unsigned int data;
0551
0552     switch (uvolt) {
0553     case 4300000:
0554         data = 0x0;
0555         break;
0556     case 4700000:
0557     case 4800000:
0558     case 4900000:
0559         data = (uvolt - 4700000) / 100000;
0560         break;
0561     default:
0562         dev_err(chg->dev, "Wrong value for charge input voltage regulation threshold\n");
0563         return -EINVAL;
0564     }
0565
0566     data <<= CHG_CNFG_12_VCHGINREG_SHIFT;
0567
0568     dev_dbg(chg->dev, "Charge input voltage regulation threshold: %u (0x%x)\n",
0569             uvolt, data);
0570
0571     return regmap_update_bits(chg->max77693->regmap,
0572             MAX77693_CHG_REG_CHG_CNFG_12,
0573             CHG_CNFG_12_VCHGINREG_MASK, data);
0574 }
0575
0576 /*
0577  * Sets charger registers to proper and safe default values.
0578  */
0579 static int max77693_reg_init(struct max77693_charger *chg)
0580 {
0581     int ret;
0582     unsigned int data;
0583
0584     /* Unlock charger register protection */
0585     data = (0x3 << CHG_CNFG_06_CHGPROT_SHIFT);
0586     ret = regmap_update_bits(chg->max77693->regmap,
0587                 MAX77693_CHG_REG_CHG_CNFG_06,
0588                 CHG_CNFG_06_CHGPROT_MASK, data);
0589     if (ret) {
0590         dev_err(chg->dev, "Error unlocking registers: %d\n", ret);
0591         return ret;
0592     }
0593
0594     ret = max77693_set_fast_charge_timer(chg, DEFAULT_FAST_CHARGE_TIMER);
0595     if (ret)
0596         return ret;
0597
0598     ret = max77693_set_top_off_threshold_current(chg,
0599             DEFAULT_TOP_OFF_THRESHOLD_CURRENT);
0600     if (ret)
0601         return ret;
0602
0603     ret = max77693_set_top_off_timer(chg, DEFAULT_TOP_OFF_TIMER);
0604     if (ret)
0605         return ret;
0606
0607     ret = max77693_set_constant_volt(chg, chg->constant_volt);
0608     if (ret)
0609         return ret;
0610
0611     ret = max77693_set_min_system_volt(chg, chg->min_system_volt);
0612     if (ret)
0613         return ret;
0614
0615     ret = max77693_set_thermal_regulation_temp(chg,
0616             chg->thermal_regulation_temp);
0617     if (ret)
0618         return ret;
0619
0620     ret = max77693_set_batttery_overcurrent(chg, chg->batttery_overcurrent);
0621     if (ret)
0622         return ret;
0623
0624     return max77693_set_charge_input_threshold_volt(chg,
0625             chg->charge_input_threshold_volt);
0626 }
0627
0628 #ifdef CONFIG_OF
0629 static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
0630 {
0631     struct device_node *np = dev->of_node;
0632
0633     if (!np) {
0634         dev_err(dev, "no charger OF node\n");
0635         return -EINVAL;
0636     }
0637
0638     if (of_property_read_u32(np, "maxim,constant-microvolt",
0639             &chg->constant_volt))
0640         chg->constant_volt = DEFAULT_CONSTANT_VOLT;
0641
0642     if (of_property_read_u32(np, "maxim,min-system-microvolt",
0643             &chg->min_system_volt))
0644         chg->min_system_volt = DEFAULT_MIN_SYSTEM_VOLT;
0645
0646     if (of_property_read_u32(np, "maxim,thermal-regulation-celsius",
0647             &chg->thermal_regulation_temp))
0648         chg->thermal_regulation_temp = DEFAULT_THERMAL_REGULATION_TEMP;
0649
0650     if (of_property_read_u32(np, "maxim,battery-overcurrent-microamp",
0651             &chg->batttery_overcurrent))
0652         chg->batttery_overcurrent = DEFAULT_BATTERY_OVERCURRENT;
0653
0654     if (of_property_read_u32(np, "maxim,charge-input-threshold-microvolt",
0655             &chg->charge_input_threshold_volt))
0656         chg->charge_input_threshold_volt =
0657             DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT;
0658
0659     return 0;
0660 }
0661 #else /* CONFIG_OF */
0662 static int max77693_dt_init(struct device *dev, struct max77693_charger *chg)
0663 {
0664     return 0;
0665 }
0666 #endif /* CONFIG_OF */
0667
0668 static int max77693_charger_probe(struct platform_device *pdev)
0669 {
0670     struct max77693_charger *chg;
0671     struct power_supply_config psy_cfg = {};
0672     struct max77693_dev *max77693 = dev_get_drvdata(pdev->dev.parent);
0673     int ret;
0674
0675     chg = devm_kzalloc(&pdev->dev, sizeof(*chg), GFP_KERNEL);
0676     if (!chg)
0677         return -ENOMEM;
0678
0679     platform_set_drvdata(pdev, chg);
0680     chg->dev = &pdev->dev;
0681     chg->max77693 = max77693;
0682
0683     ret = max77693_dt_init(&pdev->dev, chg);
0684     if (ret)
0685         return ret;
0686
0687     ret = max77693_reg_init(chg);
0688     if (ret)
0689         return ret;
0690
0691     psy_cfg.drv_data = chg;
0692
0693     ret = device_create_file(&pdev->dev, &dev_attr_fast_charge_timer);
0694     if (ret) {
0695         dev_err(&pdev->dev, "failed: create fast charge timer sysfs entry\n");
0696         goto err;
0697     }
0698
0699     ret = device_create_file(&pdev->dev,
0700             &dev_attr_top_off_threshold_current);
0701     if (ret) {
0702         dev_err(&pdev->dev, "failed: create top off current sysfs entry\n");
0703         goto err;
0704     }
0705
0706     ret = device_create_file(&pdev->dev, &dev_attr_top_off_timer);
0707     if (ret) {
0708         dev_err(&pdev->dev, "failed: create top off timer sysfs entry\n");
0709         goto err;
0710     }
0711
0712     chg->charger = power_supply_register(&pdev->dev,
0713                         &max77693_charger_desc,
0714                         &psy_cfg);
0715     if (IS_ERR(chg->charger)) {
0716         dev_err(&pdev->dev, "failed: power supply register\n");
0717         ret = PTR_ERR(chg->charger);
0718         goto err;
0719     }
0720
0721     return 0;
0722
0723 err:
0724     device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
0725     device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
0726     device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
0727
0728     return ret;
0729 }
0730
0731 static int max77693_charger_remove(struct platform_device *pdev)
0732 {
0733     struct max77693_charger *chg = platform_get_drvdata(pdev);
0734
0735     device_remove_file(&pdev->dev, &dev_attr_top_off_timer);
0736     device_remove_file(&pdev->dev, &dev_attr_top_off_threshold_current);
0737     device_remove_file(&pdev->dev, &dev_attr_fast_charge_timer);
0738
0739     power_supply_unregister(chg->charger);
0740
0741     return 0;
0742 }
0743
0744 static const struct platform_device_id max77693_charger_id[] = {
0745     { "max77693-charger", 0, },
0746     { }
0747 };
0748 MODULE_DEVICE_TABLE(platform, max77693_charger_id);
0749
0750 static struct platform_driver max77693_charger_driver = {
0751     .driver = {
0752         .name   = "max77693-charger",
0753     },
0754     .probe      = max77693_charger_probe,
0755     .remove     = max77693_charger_remove,
0756     .id_table   = max77693_charger_id,
0757 };
0758 module_platform_driver(max77693_charger_driver);
0759
0760 MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");
0761 MODULE_DESCRIPTION("Maxim 77693 charger driver");
0762 MODULE_LICENSE("GPL");