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