drivers/power/supply/max77693_charger.c

   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");