drivers/power/supply/rt5033_charger.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Battery charger driver for RT5033
   4  *
   5  * Copyright (C) 2014 Samsung Electronics, Co., Ltd.
   6  * Author: Beomho Seo <beomho.seo@samsung.com>
   7  */
   8
   9 #include <linux/devm-helpers.h>
  10 #include <linux/extcon.h>
  11 #include <linux/mod_devicetable.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/power_supply.h>
  17 #include <linux/regmap.h>
  18 #include <linux/mfd/rt5033-private.h>
  19
  20 struct rt5033_charger_data {
  21         unsigned int pre_uamp;
  22         unsigned int pre_uvolt;
  23         unsigned int const_uvolt;
  24         unsigned int eoc_uamp;
  25         unsigned int fast_uamp;
  26 };
  27
  28 struct rt5033_charger {
  29         struct device                   *dev;
  30         struct regmap                   *regmap;
  31         struct power_supply             *psy;
  32         struct rt5033_charger_data      chg;
  33         struct extcon_dev               *edev;
  34         struct notifier_block           extcon_nb;
  35         struct work_struct              extcon_work;
  36         struct mutex                    lock;
  37         bool online;
  38         bool otg;
  39         bool mivr_enabled;
  40         u8 cv_regval;
  41 };
  42
  43 static int rt5033_get_charger_state(struct rt5033_charger *charger)
  44 {
  45         struct regmap *regmap = charger->regmap;
  46         unsigned int reg_data;
  47         int state;
  48
  49         if (!regmap)
  50                 return POWER_SUPPLY_STATUS_UNKNOWN;
  51
  52         regmap_read(regmap, RT5033_REG_CHG_STAT, &reg_data);
  53
  54         switch (reg_data & RT5033_CHG_STAT_MASK) {
  55         case RT5033_CHG_STAT_DISCHARGING:
  56                 state = POWER_SUPPLY_STATUS_DISCHARGING;
  57                 break;
  58         case RT5033_CHG_STAT_CHARGING:
  59                 state = POWER_SUPPLY_STATUS_CHARGING;
  60                 break;
  61         case RT5033_CHG_STAT_FULL:
  62                 state = POWER_SUPPLY_STATUS_FULL;
  63                 break;
  64         case RT5033_CHG_STAT_NOT_CHARGING:
  65                 state = POWER_SUPPLY_STATUS_NOT_CHARGING;
  66                 break;
  67         default:
  68                 state = POWER_SUPPLY_STATUS_UNKNOWN;
  69         }
  70
  71         /* For OTG mode, RT5033 would still report "charging" */
  72         if (charger->otg)
  73                 state = POWER_SUPPLY_STATUS_DISCHARGING;
  74
  75         return state;
  76 }
  77
  78 static int rt5033_get_charger_type(struct rt5033_charger *charger)
  79 {
  80         struct regmap *regmap = charger->regmap;
  81         unsigned int reg_data;
  82         int state;
  83
  84         regmap_read(regmap, RT5033_REG_CHG_STAT, &reg_data);
  85
  86         switch (reg_data & RT5033_CHG_STAT_TYPE_MASK) {
  87         case RT5033_CHG_STAT_TYPE_FAST:
  88                 state = POWER_SUPPLY_CHARGE_TYPE_FAST;
  89                 break;
  90         case RT5033_CHG_STAT_TYPE_PRE:
  91                 state = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  92                 break;
  93         default:
  94                 state = POWER_SUPPLY_CHARGE_TYPE_NONE;
  95         }
  96
  97         return state;
  98 }
  99
 100 static int rt5033_get_charger_current_limit(struct rt5033_charger *charger)
 101 {
 102         struct regmap *regmap = charger->regmap;
 103         unsigned int state, reg_data, data;
 104
 105         regmap_read(regmap, RT5033_REG_CHG_CTRL5, &reg_data);
 106
 107         state = (reg_data & RT5033_CHGCTRL5_ICHG_MASK)
 108                  >> RT5033_CHGCTRL5_ICHG_SHIFT;
 109
 110         data = RT5033_CHARGER_FAST_CURRENT_MIN +
 111                 RT5033_CHARGER_FAST_CURRENT_STEP_NUM * state;
 112
 113         return data;
 114 }
 115
 116 static int rt5033_get_charger_const_voltage(struct rt5033_charger *charger)
 117 {
 118         struct regmap *regmap = charger->regmap;
 119         unsigned int state, reg_data, data;
 120
 121         regmap_read(regmap, RT5033_REG_CHG_CTRL2, &reg_data);
 122
 123         state = (reg_data & RT5033_CHGCTRL2_CV_MASK)
 124                  >> RT5033_CHGCTRL2_CV_SHIFT;
 125
 126         data = RT5033_CHARGER_CONST_VOLTAGE_LIMIT_MIN +
 127                 RT5033_CHARGER_CONST_VOLTAGE_STEP_NUM * state;
 128
 129         return data;
 130 }
 131
 132 static inline int rt5033_init_const_charge(struct rt5033_charger *charger)
 133 {
 134         struct rt5033_charger_data *chg = &charger->chg;
 135         int ret;
 136         unsigned int val;
 137         u8 reg_data;
 138
 139         /* Set constant voltage mode */
 140         if (chg->const_uvolt < RT5033_CHARGER_CONST_VOLTAGE_LIMIT_MIN ||
 141             chg->const_uvolt > RT5033_CHARGER_CONST_VOLTAGE_LIMIT_MAX) {
 142                 dev_err(charger->dev,
 143                         "Value 'constant-charge-voltage-max-microvolt' out of range\n");
 144                 return -EINVAL;
 145         }
 146
 147         if (chg->const_uvolt == RT5033_CHARGER_CONST_VOLTAGE_LIMIT_MIN)
 148                 reg_data = 0x00;
 149         else if (chg->const_uvolt == RT5033_CHARGER_CONST_VOLTAGE_LIMIT_MAX)
 150                 reg_data = RT5033_CV_MAX_VOLTAGE;
 151         else {
 152                 val = chg->const_uvolt;
 153                 val -= RT5033_CHARGER_CONST_VOLTAGE_LIMIT_MIN;
 154                 val /= RT5033_CHARGER_CONST_VOLTAGE_STEP_NUM;
 155                 reg_data = val;
 156         }
 157
 158         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL2,
 159                         RT5033_CHGCTRL2_CV_MASK,
 160                         reg_data << RT5033_CHGCTRL2_CV_SHIFT);
 161         if (ret) {
 162                 dev_err(charger->dev, "Failed regmap update\n");
 163                 return -EINVAL;
 164         }
 165
 166         /* Store that value for later usage */
 167         charger->cv_regval = reg_data;
 168
 169         /* Set end of charge current */
 170         if (chg->eoc_uamp < RT5033_CHARGER_EOC_MIN ||
 171             chg->eoc_uamp > RT5033_CHARGER_EOC_MAX) {
 172                 dev_err(charger->dev,
 173                         "Value 'charge-term-current-microamp' out of range\n");
 174                 return -EINVAL;
 175         }
 176
 177         if (chg->eoc_uamp == RT5033_CHARGER_EOC_MIN)
 178                 reg_data = 0x01;
 179         else if (chg->eoc_uamp == RT5033_CHARGER_EOC_MAX)
 180                 reg_data = 0x07;
 181         else {
 182                 val = chg->eoc_uamp;
 183                 if (val < RT5033_CHARGER_EOC_REF) {
 184                         val -= RT5033_CHARGER_EOC_MIN;
 185                         val /= RT5033_CHARGER_EOC_STEP_NUM1;
 186                         reg_data = 0x01 + val;
 187                 } else if (val > RT5033_CHARGER_EOC_REF) {
 188                         val -= RT5033_CHARGER_EOC_REF;
 189                         val /= RT5033_CHARGER_EOC_STEP_NUM2;
 190                         reg_data = 0x04 + val;
 191                 } else {
 192                         reg_data = 0x04;
 193                 }
 194         }
 195
 196         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL4,
 197                         RT5033_CHGCTRL4_EOC_MASK, reg_data);
 198         if (ret) {
 199                 dev_err(charger->dev, "Failed regmap update\n");
 200                 return -EINVAL;
 201         }
 202
 203         return 0;
 204 }
 205
 206 static inline int rt5033_init_fast_charge(struct rt5033_charger *charger)
 207 {
 208         struct rt5033_charger_data *chg = &charger->chg;
 209         int ret;
 210         unsigned int val;
 211         u8 reg_data;
 212
 213         /* Set limit input current */
 214         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL1,
 215                         RT5033_CHGCTRL1_IAICR_MASK, RT5033_AICR_2000_MODE);
 216         if (ret) {
 217                 dev_err(charger->dev, "Failed regmap update\n");
 218                 return -EINVAL;
 219         }
 220
 221         /* Set fast-charge mode charging current */
 222         if (chg->fast_uamp < RT5033_CHARGER_FAST_CURRENT_MIN ||
 223             chg->fast_uamp > RT5033_CHARGER_FAST_CURRENT_MAX) {
 224                 dev_err(charger->dev,
 225                         "Value 'constant-charge-current-max-microamp' out of range\n");
 226                 return -EINVAL;
 227         }
 228
 229         if (chg->fast_uamp == RT5033_CHARGER_FAST_CURRENT_MIN)
 230                 reg_data = 0x00;
 231         else if (chg->fast_uamp == RT5033_CHARGER_FAST_CURRENT_MAX)
 232                 reg_data = RT5033_CHG_MAX_CURRENT;
 233         else {
 234                 val = chg->fast_uamp;
 235                 val -= RT5033_CHARGER_FAST_CURRENT_MIN;
 236                 val /= RT5033_CHARGER_FAST_CURRENT_STEP_NUM;
 237                 reg_data = val;
 238         }
 239
 240         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL5,
 241                         RT5033_CHGCTRL5_ICHG_MASK,
 242                         reg_data << RT5033_CHGCTRL5_ICHG_SHIFT);
 243         if (ret) {
 244                 dev_err(charger->dev, "Failed regmap update\n");
 245                 return -EINVAL;
 246         }
 247
 248         return 0;
 249 }
 250
 251 static inline int rt5033_init_pre_charge(struct rt5033_charger *charger)
 252 {
 253         struct rt5033_charger_data *chg = &charger->chg;
 254         int ret;
 255         unsigned int val;
 256         u8 reg_data;
 257
 258         /* Set pre-charge threshold voltage */
 259         if (chg->pre_uvolt < RT5033_CHARGER_PRE_THRESHOLD_LIMIT_MIN ||
 260             chg->pre_uvolt > RT5033_CHARGER_PRE_THRESHOLD_LIMIT_MAX) {
 261                 dev_err(charger->dev,
 262                         "Value 'precharge-upper-limit-microvolt' out of range\n");
 263                 return -EINVAL;
 264         }
 265
 266         if (chg->pre_uvolt == RT5033_CHARGER_PRE_THRESHOLD_LIMIT_MIN)
 267                 reg_data = 0x00;
 268         else if (chg->pre_uvolt == RT5033_CHARGER_PRE_THRESHOLD_LIMIT_MAX)
 269                 reg_data = 0x0f;
 270         else {
 271                 val = chg->pre_uvolt;
 272                 val -= RT5033_CHARGER_PRE_THRESHOLD_LIMIT_MIN;
 273                 val /= RT5033_CHARGER_PRE_THRESHOLD_STEP_NUM;
 274                 reg_data = val;
 275         }
 276
 277         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL5,
 278                         RT5033_CHGCTRL5_VPREC_MASK, reg_data);
 279         if (ret) {
 280                 dev_err(charger->dev, "Failed regmap update\n");
 281                 return -EINVAL;
 282         }
 283
 284         /* Set pre-charge mode charging current */
 285         if (chg->pre_uamp < RT5033_CHARGER_PRE_CURRENT_LIMIT_MIN ||
 286             chg->pre_uamp > RT5033_CHARGER_PRE_CURRENT_LIMIT_MAX) {
 287                 dev_err(charger->dev,
 288                         "Value 'precharge-current-microamp' out of range\n");
 289                 return -EINVAL;
 290         }
 291
 292         if (chg->pre_uamp == RT5033_CHARGER_PRE_CURRENT_LIMIT_MIN)
 293                 reg_data = 0x00;
 294         else if (chg->pre_uamp == RT5033_CHARGER_PRE_CURRENT_LIMIT_MAX)
 295                 reg_data = RT5033_CHG_MAX_PRE_CURRENT;
 296         else {
 297                 val = chg->pre_uamp;
 298                 val -= RT5033_CHARGER_PRE_CURRENT_LIMIT_MIN;
 299                 val /= RT5033_CHARGER_PRE_CURRENT_STEP_NUM;
 300                 reg_data = val;
 301         }
 302
 303         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL4,
 304                         RT5033_CHGCTRL4_IPREC_MASK,
 305                         reg_data << RT5033_CHGCTRL4_IPREC_SHIFT);
 306         if (ret) {
 307                 dev_err(charger->dev, "Failed regmap update\n");
 308                 return -EINVAL;
 309         }
 310
 311         return 0;
 312 }
 313
 314 static int rt5033_charger_reg_init(struct rt5033_charger *charger)
 315 {
 316         int ret = 0;
 317
 318         /* Enable charging termination */
 319         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL1,
 320                         RT5033_CHGCTRL1_TE_EN_MASK, RT5033_TE_ENABLE);
 321         if (ret) {
 322                 dev_err(charger->dev, "Failed to enable charging termination.\n");
 323                 return -EINVAL;
 324         }
 325
 326         /*
 327          * Disable minimum input voltage regulation (MIVR), this improves
 328          * the charging performance.
 329          */
 330         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL4,
 331                         RT5033_CHGCTRL4_MIVR_MASK, RT5033_CHARGER_MIVR_DISABLE);
 332         if (ret) {
 333                 dev_err(charger->dev, "Failed to disable MIVR.\n");
 334                 return -EINVAL;
 335         }
 336
 337         ret = rt5033_init_pre_charge(charger);
 338         if (ret)
 339                 return ret;
 340
 341         ret = rt5033_init_fast_charge(charger);
 342         if (ret)
 343                 return ret;
 344
 345         ret = rt5033_init_const_charge(charger);
 346         if (ret)
 347                 return ret;
 348
 349         return 0;
 350 }
 351
 352 static int rt5033_charger_set_otg(struct rt5033_charger *charger)
 353 {
 354         int ret;
 355
 356         mutex_lock(&charger->lock);
 357
 358         /* Set OTG boost v_out to 5 volts */
 359         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL2,
 360                         RT5033_CHGCTRL2_CV_MASK,
 361                         0x37 << RT5033_CHGCTRL2_CV_SHIFT);
 362         if (ret) {
 363                 dev_err(charger->dev, "Failed set OTG boost v_out\n");
 364                 ret = -EINVAL;
 365                 goto out_unlock;
 366         }
 367
 368         /* Set operation mode to OTG */
 369         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL1,
 370                         RT5033_CHGCTRL1_MODE_MASK, RT5033_BOOST_MODE);
 371         if (ret) {
 372                 dev_err(charger->dev, "Failed to update OTG mode.\n");
 373                 ret = -EINVAL;
 374                 goto out_unlock;
 375         }
 376
 377         /* In case someone switched from charging to OTG directly */
 378         if (charger->online)
 379                 charger->online = false;
 380
 381         charger->otg = true;
 382
 383 out_unlock:
 384         mutex_unlock(&charger->lock);
 385
 386         return ret;
 387 }
 388
 389 static int rt5033_charger_unset_otg(struct rt5033_charger *charger)
 390 {
 391         int ret;
 392         u8 data;
 393
 394         /* Restore constant voltage for charging */
 395         data = charger->cv_regval;
 396         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL2,
 397                         RT5033_CHGCTRL2_CV_MASK,
 398                         data << RT5033_CHGCTRL2_CV_SHIFT);
 399         if (ret) {
 400                 dev_err(charger->dev, "Failed to restore constant voltage\n");
 401                 return -EINVAL;
 402         }
 403
 404         /* Set operation mode to charging */
 405         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL1,
 406                         RT5033_CHGCTRL1_MODE_MASK, RT5033_CHARGER_MODE);
 407         if (ret) {
 408                 dev_err(charger->dev, "Failed to update charger mode.\n");
 409                 return -EINVAL;
 410         }
 411
 412         charger->otg = false;
 413
 414         return 0;
 415 }
 416
 417 static int rt5033_charger_set_charging(struct rt5033_charger *charger)
 418 {
 419         int ret;
 420
 421         mutex_lock(&charger->lock);
 422
 423         /* In case someone switched from OTG to charging directly */
 424         if (charger->otg) {
 425                 ret = rt5033_charger_unset_otg(charger);
 426                 if (ret) {
 427                         mutex_unlock(&charger->lock);
 428                         return -EINVAL;
 429                 }
 430         }
 431
 432         charger->online = true;
 433
 434         mutex_unlock(&charger->lock);
 435
 436         return 0;
 437 }
 438
 439 static int rt5033_charger_set_mivr(struct rt5033_charger *charger)
 440 {
 441         int ret;
 442
 443         mutex_lock(&charger->lock);
 444
 445         /*
 446          * When connected via USB connector type SDP (Standard Downstream Port),
 447          * the minimum input voltage regulation (MIVR) should be enabled. It
 448          * prevents an input voltage drop due to insufficient current provided
 449          * by the adapter or USB input. As a downside, it may reduces the
 450          * charging current and thus slows the charging.
 451          */
 452         ret = regmap_update_bits(charger->regmap, RT5033_REG_CHG_CTRL4,
 453                         RT5033_CHGCTRL4_MIVR_MASK, RT5033_CHARGER_MIVR_4600MV);
 454         if (ret) {
 455                 dev_err(charger->dev, "Failed to set MIVR level.\n");
 456                 mutex_unlock(&charger->lock);
 457                 return -EINVAL;
 458         }
 459
 460         charger->mivr_enabled = true;
 461
 462         mutex_unlock(&charger->lock);
 463
 464         /* Beyond this, do the same steps like setting charging */
 465         rt5033_charger_set_charging(charger);
 466
 467         return 0;
 468 }
 469
 470 static int rt5033_charger_set_disconnect(struct rt5033_charger *charger)
 471 {
 472         int ret = 0;
 473
 474         mutex_lock(&charger->lock);
 475
 476         /* Disable MIVR if enabled */
 477         if (charger->mivr_enabled) {
 478                 ret = regmap_update_bits(charger->regmap,
 479                                 RT5033_REG_CHG_CTRL4,
 480                                 RT5033_CHGCTRL4_MIVR_MASK,
 481                                 RT5033_CHARGER_MIVR_DISABLE);
 482                 if (ret) {
 483                         dev_err(charger->dev, "Failed to disable MIVR.\n");
 484                         ret = -EINVAL;
 485                         goto out_unlock;
 486                 }
 487
 488                 charger->mivr_enabled = false;
 489         }
 490
 491         if (charger->otg) {
 492                 ret = rt5033_charger_unset_otg(charger);
 493                 if (ret) {
 494                         ret = -EINVAL;
 495                         goto out_unlock;
 496                 }
 497         }
 498
 499         if (charger->online)
 500                 charger->online = false;
 501
 502 out_unlock:
 503         mutex_unlock(&charger->lock);
 504
 505         return ret;
 506 }
 507
 508 static enum power_supply_property rt5033_charger_props[] = {
 509         POWER_SUPPLY_PROP_STATUS,
 510         POWER_SUPPLY_PROP_CHARGE_TYPE,
 511         POWER_SUPPLY_PROP_CURRENT_MAX,
 512         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 513         POWER_SUPPLY_PROP_MODEL_NAME,
 514         POWER_SUPPLY_PROP_MANUFACTURER,
 515         POWER_SUPPLY_PROP_ONLINE,
 516 };
 517
 518 static int rt5033_charger_get_property(struct power_supply *psy,
 519                         enum power_supply_property psp,
 520                         union power_supply_propval *val)
 521 {
 522         struct rt5033_charger *charger = power_supply_get_drvdata(psy);
 523
 524         switch (psp) {
 525         case POWER_SUPPLY_PROP_STATUS:
 526                 val->intval = rt5033_get_charger_state(charger);
 527                 break;
 528         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 529                 val->intval = rt5033_get_charger_type(charger);
 530                 break;
 531         case POWER_SUPPLY_PROP_CURRENT_MAX:
 532                 val->intval = rt5033_get_charger_current_limit(charger);
 533                 break;
 534         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 535                 val->intval = rt5033_get_charger_const_voltage(charger);
 536                 break;
 537         case POWER_SUPPLY_PROP_MODEL_NAME:
 538                 val->strval = RT5033_CHARGER_MODEL;
 539                 break;
 540         case POWER_SUPPLY_PROP_MANUFACTURER:
 541                 val->strval = RT5033_MANUFACTURER;
 542                 break;
 543         case POWER_SUPPLY_PROP_ONLINE:
 544                 val->intval = charger->online;
 545                 break;
 546         default:
 547                 return -EINVAL;
 548         }
 549
 550         return 0;
 551 }
 552
 553 static int rt5033_charger_dt_init(struct rt5033_charger *charger)
 554 {
 555         struct rt5033_charger_data *chg = &charger->chg;
 556         struct power_supply_battery_info *info;
 557         int ret;
 558
 559         ret = power_supply_get_battery_info(charger->psy, &info);
 560         if (ret)
 561                 return dev_err_probe(charger->dev, -EINVAL,
 562                                      "missing battery info\n");
 563
 564         /* Assign data. Validity will be checked in the init functions. */
 565         chg->pre_uamp = info->precharge_current_ua;
 566         chg->fast_uamp = info->constant_charge_current_max_ua;
 567         chg->eoc_uamp = info->charge_term_current_ua;
 568         chg->pre_uvolt = info->precharge_voltage_max_uv;
 569         chg->const_uvolt = info->constant_charge_voltage_max_uv;
 570
 571         return 0;
 572 }
 573
 574 static void rt5033_charger_extcon_work(struct work_struct *work)
 575 {
 576         struct rt5033_charger *charger =
 577                 container_of(work, struct rt5033_charger, extcon_work);
 578         struct extcon_dev *edev = charger->edev;
 579         int connector, state;
 580         int ret;
 581
 582         for (connector = EXTCON_USB_HOST; connector <= EXTCON_CHG_USB_PD;
 583              connector++) {
 584                 state = extcon_get_state(edev, connector);
 585                 if (state == 1)
 586                         break;
 587         }
 588
 589         /*
 590          * Adding a delay between extcon notification and extcon action. This
 591          * makes extcon action execution more reliable. Without the delay the
 592          * execution sometimes fails, possibly because the chip is busy or not
 593          * ready.
 594          */
 595         msleep(100);
 596
 597         switch (connector) {
 598         case EXTCON_CHG_USB_SDP:
 599                 ret = rt5033_charger_set_mivr(charger);
 600                 if (ret) {
 601                         dev_err(charger->dev, "failed to set USB mode\n");
 602                         break;
 603                 }
 604                 dev_info(charger->dev, "USB mode. connector type: %d\n",
 605                          connector);
 606                 break;
 607         case EXTCON_CHG_USB_DCP:
 608         case EXTCON_CHG_USB_CDP:
 609         case EXTCON_CHG_USB_ACA:
 610         case EXTCON_CHG_USB_FAST:
 611         case EXTCON_CHG_USB_SLOW:
 612         case EXTCON_CHG_WPT:
 613         case EXTCON_CHG_USB_PD:
 614                 ret = rt5033_charger_set_charging(charger);
 615                 if (ret) {
 616                         dev_err(charger->dev, "failed to set charging\n");
 617                         break;
 618                 }
 619                 dev_info(charger->dev, "charging. connector type: %d\n",
 620                          connector);
 621                 break;
 622         case EXTCON_USB_HOST:
 623                 ret = rt5033_charger_set_otg(charger);
 624                 if (ret) {
 625                         dev_err(charger->dev, "failed to set OTG\n");
 626                         break;
 627                 }
 628                 dev_info(charger->dev, "OTG enabled\n");
 629                 break;
 630         default:
 631                 ret = rt5033_charger_set_disconnect(charger);
 632                 if (ret) {
 633                         dev_err(charger->dev, "failed to set disconnect\n");
 634                         break;
 635                 }
 636                 dev_info(charger->dev, "disconnected\n");
 637                 break;
 638         }
 639
 640         power_supply_changed(charger->psy);
 641 }
 642
 643 static int rt5033_charger_extcon_notifier(struct notifier_block *nb,
 644                                           unsigned long event, void *param)
 645 {
 646         struct rt5033_charger *charger =
 647                 container_of(nb, struct rt5033_charger, extcon_nb);
 648
 649         schedule_work(&charger->extcon_work);
 650
 651         return NOTIFY_OK;
 652 }
 653
 654 static const struct power_supply_desc rt5033_charger_desc = {
 655         .name = "rt5033-charger",
 656         .type = POWER_SUPPLY_TYPE_USB,
 657         .properties = rt5033_charger_props,
 658         .num_properties = ARRAY_SIZE(rt5033_charger_props),
 659         .get_property = rt5033_charger_get_property,
 660 };
 661
 662 static int rt5033_charger_probe(struct platform_device *pdev)
 663 {
 664         struct rt5033_charger *charger;
 665         struct power_supply_config psy_cfg = {};
 666         struct device_node *np_conn, *np_edev;
 667         int ret;
 668
 669         charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL);
 670         if (!charger)
 671                 return -ENOMEM;
 672
 673         platform_set_drvdata(pdev, charger);
 674         charger->dev = &pdev->dev;
 675         charger->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 676         mutex_init(&charger->lock);
 677
 678         psy_cfg.of_node = pdev->dev.of_node;
 679         psy_cfg.drv_data = charger;
 680
 681         charger->psy = devm_power_supply_register(charger->dev,
 682                                                   &rt5033_charger_desc,
 683                                                   &psy_cfg);
 684         if (IS_ERR(charger->psy))
 685                 return dev_err_probe(charger->dev, PTR_ERR(charger->psy),
 686                                      "Failed to register power supply\n");
 687
 688         ret = rt5033_charger_dt_init(charger);
 689         if (ret)
 690                 return ret;
 691
 692         ret = rt5033_charger_reg_init(charger);
 693         if (ret)
 694                 return ret;
 695
 696         /*
 697          * Extcon support is not vital for the charger to work. If no extcon
 698          * is available, just emit a warning and leave the probe function.
 699          */
 700         np_conn = of_parse_phandle(pdev->dev.of_node, "richtek,usb-connector", 0);
 701         np_edev = of_get_parent(np_conn);
 702         charger->edev = extcon_find_edev_by_node(np_edev);
 703         if (IS_ERR(charger->edev)) {
 704                 dev_warn(charger->dev, "no extcon device found in device-tree\n");
 705                 goto out;
 706         }
 707
 708         ret = devm_work_autocancel(charger->dev, &charger->extcon_work,
 709                                    rt5033_charger_extcon_work);
 710         if (ret) {
 711                 dev_err(charger->dev, "failed to initialize extcon work\n");
 712                 return ret;
 713         }
 714
 715         charger->extcon_nb.notifier_call = rt5033_charger_extcon_notifier;
 716         ret = devm_extcon_register_notifier_all(charger->dev, charger->edev,
 717                                                 &charger->extcon_nb);
 718         if (ret) {
 719                 dev_err(charger->dev, "failed to register extcon notifier\n");
 720                 return ret;
 721         }
 722 out:
 723         return 0;
 724 }
 725
 726 static const struct platform_device_id rt5033_charger_id[] = {
 727         { "rt5033-charger", },
 728         { }
 729 };
 730 MODULE_DEVICE_TABLE(platform, rt5033_charger_id);
 731
 732 static const struct of_device_id rt5033_charger_of_match[] = {
 733         { .compatible = "richtek,rt5033-charger", },
 734         { }
 735 };
 736 MODULE_DEVICE_TABLE(of, rt5033_charger_of_match);
 737
 738 static struct platform_driver rt5033_charger_driver = {
 739         .driver = {
 740                 .name = "rt5033-charger",
 741                 .of_match_table = rt5033_charger_of_match,
 742         },
 743         .probe = rt5033_charger_probe,
 744         .id_table = rt5033_charger_id,
 745 };
 746 module_platform_driver(rt5033_charger_driver);
 747
 748 MODULE_DESCRIPTION("Richtek RT5033 charger driver");
 749 MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
 750 MODULE_LICENSE("GPL v2");