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
21struct 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
29struct 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
44static 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(map: regmap, reg: RT5033_REG_CHG_STAT, val: &reg_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
79static 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(map: regmap, reg: RT5033_REG_CHG_STAT, val: &reg_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
101static 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(map: regmap, reg: RT5033_REG_CHG_CTRL5, val: &reg_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
117static 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(map: regmap, reg: RT5033_REG_CHG_CTRL2, val: &reg_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
133static 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL2,
160 RT5033_CHGCTRL2_CV_MASK,
161 val: 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL4,
198 RT5033_CHGCTRL4_EOC_MASK, val: reg_data);
199 if (ret) {
200 dev_err(charger->dev, "Failed regmap update\n");
201 return -EINVAL;
202 }
203
204 return 0;
205}
206
207static 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(map: charger->regmap, reg: 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL5,
242 RT5033_CHGCTRL5_ICHG_MASK,
243 val: 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
252static 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL5,
279 RT5033_CHGCTRL5_VPREC_MASK, val: 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL4,
305 RT5033_CHGCTRL4_IPREC_MASK,
306 val: 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
315static int rt5033_charger_reg_init(struct rt5033_charger *charger)
316{
317 int ret = 0;
318
319 /* Enable charging termination */
320 ret = regmap_update_bits(map: charger->regmap, reg: 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(map: charger->regmap, reg: 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
353static 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL2,
361 RT5033_CHGCTRL2_CV_MASK,
362 val: 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(map: charger->regmap, reg: 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
384out_unlock:
385 mutex_unlock(lock: &charger->lock);
386
387 return ret;
388}
389
390static 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(map: charger->regmap, reg: RT5033_REG_CHG_CTRL2,
398 RT5033_CHGCTRL2_CV_MASK,
399 val: 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(map: charger->regmap, reg: 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
418static 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(lock: &charger->lock);
429 return -EINVAL;
430 }
431 }
432
433 charger->online = true;
434
435 mutex_unlock(lock: &charger->lock);
436
437 return 0;
438}
439
440static 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(map: charger->regmap, reg: 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(lock: &charger->lock);
458 return -EINVAL;
459 }
460
461 charger->mivr_enabled = true;
462
463 mutex_unlock(lock: &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
471static 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(map: charger->regmap,
480 reg: 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
503out_unlock:
504 mutex_unlock(lock: &charger->lock);
505
506 return ret;
507}
508
509static 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
519static 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
554static 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(psy: charger->psy, info_out: &info);
561 if (ret)
562 return dev_err_probe(dev: charger->dev, err: -EINVAL,
563 fmt: "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
575static 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, id: 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(msecs: 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(psy: charger->psy);
642}
643
644static 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(work: &charger->extcon_work);
651
652 return NOTIFY_OK;
653}
654
655static 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
663static 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(dev: &pdev->dev, size: sizeof(*charger), GFP_KERNEL);
671 if (!charger)
672 return -ENOMEM;
673
674 platform_set_drvdata(pdev, data: charger);
675 charger->dev = &pdev->dev;
676 charger->regmap = dev_get_regmap(dev: 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(parent: charger->dev,
683 desc: &rt5033_charger_desc,
684 cfg: &psy_cfg);
685 if (IS_ERR(ptr: charger->psy))
686 return dev_err_probe(dev: charger->dev, err: PTR_ERR(ptr: charger->psy),
687 fmt: "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(np: pdev->dev.of_node, phandle_name: "richtek,usb-connector", index: 0);
702 np_edev = of_get_parent(node: np_conn);
703 charger->edev = extcon_find_edev_by_node(node: np_edev);
704 of_node_put(node: np_edev);
705 of_node_put(node: np_conn);
706 if (IS_ERR(ptr: charger->edev)) {
707 dev_warn(charger->dev, "no extcon device found in device-tree\n");
708 goto out;
709 }
710
711 ret = devm_work_autocancel(dev: charger->dev, w: &charger->extcon_work,
712 worker: rt5033_charger_extcon_work);
713 if (ret) {
714 dev_err(charger->dev, "failed to initialize extcon work\n");
715 return ret;
716 }
717
718 charger->extcon_nb.notifier_call = rt5033_charger_extcon_notifier;
719 ret = devm_extcon_register_notifier_all(dev: charger->dev, edev: charger->edev,
720 nb: &charger->extcon_nb);
721 if (ret) {
722 dev_err(charger->dev, "failed to register extcon notifier\n");
723 return ret;
724 }
725out:
726 return 0;
727}
728
729static const struct platform_device_id rt5033_charger_id[] = {
730 { "rt5033-charger", },
731 { }
732};
733MODULE_DEVICE_TABLE(platform, rt5033_charger_id);
734
735static const struct of_device_id rt5033_charger_of_match[] = {
736 { .compatible = "richtek,rt5033-charger", },
737 { }
738};
739MODULE_DEVICE_TABLE(of, rt5033_charger_of_match);
740
741static struct platform_driver rt5033_charger_driver = {
742 .driver = {
743 .name = "rt5033-charger",
744 .of_match_table = rt5033_charger_of_match,
745 },
746 .probe = rt5033_charger_probe,
747 .id_table = rt5033_charger_id,
748};
749module_platform_driver(rt5033_charger_driver);
750
751MODULE_DESCRIPTION("Richtek RT5033 charger driver");
752MODULE_AUTHOR("Beomho Seo <beomho.seo@samsung.com>");
753MODULE_LICENSE("GPL v2");
754

source code of linux/drivers/power/supply/rt5033_charger.c