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#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(regmap, RT5033_REG_CHG_STAT, &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(regmap, RT5033_REG_CHG_STAT, &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(regmap, RT5033_REG_CHG_CTRL5, &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(regmap, RT5033_REG_CHG_CTRL2, &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(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
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(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
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(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
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(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
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(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
384out_unlock:
385	mutex_unlock(&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(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
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(&charger->lock);
429			return -EINVAL;
430		}
431	}
432
433	charger->online = true;
434
435	mutex_unlock(&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(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
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(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
503out_unlock:
504	mutex_unlock(&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(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
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, 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
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(&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(&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	of_node_put(np_edev);
705	of_node_put(np_conn);
706	if (IS_ERR(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(charger->dev, &charger->extcon_work,
712				   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(charger->dev, charger->edev,
720						&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");