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