1/*
2 * rk817 charger driver
3 *
4 * Copyright (C) 2018 Rockchip Electronics Co., Ltd
5 * xsf <xsf@rock-chips.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14 * more details.
15 *
16 */
17
18#include <linux/delay.h>
19#include <linux/extcon.h>
20#include <linux/gpio.h>
21#include <linux/iio/consumer.h>
22#include <linux/iio/iio.h>
23#include <linux/irq.h>
24#include <linux/jiffies.h>
25#include <linux/mfd/rk808.h>
26#include <linux/module.h>
27#include <linux/of_device.h>
28#include <linux/of_gpio.h>
29#include <linux/platform_device.h>
30#include <linux/power_supply.h>
31#include <linux/power/rk_usbbc.h>
32#include <linux/regmap.h>
33#include <linux/rtc.h>
34#include <linux/timer.h>
35#include <linux/workqueue.h>
36
37static int dbg_enable;
38module_param_named(dbg_level, dbg_enable, int, 0644);
39
40#define DBG(args...) \
41	do { \
42		if (dbg_enable) { \
43			pr_info(args); \
44		} \
45	} while (0)
46
47#define CHARGE_DRIVER_VERSION		"1.0"
48
49#define DISABLE	0x00
50#define ENABLE	0x01
51#define OTG_SLP_ENABLE	0x01
52#define OTG_SLP_DISABLE	0x00
53#define OTG_ENABLE		0x11
54#define OTG_DISABLE		0x10
55#define RK817_BOOST_ENABLE	0x11
56#define RK817_BOOST_DISABLE	0x10
57#define OTG_MODE		0x01
58#define OTG_MODE_ON		0x01
59#define DEFAULT_INPUT_VOLTAGE	4500
60#define DEFAULT_INPUT_CURRENT	2000
61#define DEFAULT_CHRG_VOLTAGE	4200
62#define DEFAULT_CHRG_CURRENT	1400
63#define DEFAULT_CHRG_TERM_MODE	1
64#define DEFAULT_CHRG_TERM_CUR		150
65#define SAMPLE_RES_10MR		10
66#define SAMPLE_RES_20MR		20
67#define SAMPLE_RES_DIV1		1
68#define SAMPLE_RES_DIV2		2
69
70#define INPUT_450MA		450
71#define INPUT_1500MA	1500
72
73#define CURRENT_TO_ADC(current, samp_res)	\
74	(current * 1000 * samp_res / 172)
75
76enum charge_current {
77	CHRG_CUR_1000MA,
78	CHRG_CUR_1500MA,
79	CHRG_CUR_2000MA,
80	CHRG_CUR_2500MA,
81	CHRG_CUR_2750MA,
82	CHRG_CUR_3000MA,
83	CHRG_CUR_3500MA,
84	CHRG_CUR_500MA,
85};
86
87enum charge_voltage {
88	CHRG_VOL_4100MV,
89	CHRG_VOL_4150MV,
90	CHRG_VOL_4200MV,
91	CHRG_VOL_4250MV,
92	CHRG_VOL_4300MV,
93	CHRG_VOL_4350MV,
94	CHRG_VOL_4400MV,
95	CHRG_VOL_4450MV,
96};
97
98enum input_voltage {
99	INPUT_VOL_4000MV,
100	INPUT_VOL_4100MV,
101	INPUT_VOL_4200MV,
102	INPUT_VOL_4300MV,
103	INPUT_VOL_4400MV,
104	INPUT_VOL_4500MV,
105	INPUT_VOL_4600MV,
106	INPUT_VOL_4700MV,
107};
108
109enum input_current {
110	INPUT_CUR_450MA,
111	INPUT_CUR_80MA,
112	INPUT_CUR_850MA,
113	INPUT_CUR_1500MA,
114	INPUT_CUR_1750MA,
115	INPUT_CUR_2000MA,
116	INPUT_CUR_2500MA,
117	INPUT_CUR_3000MA,
118};
119
120enum charge_clk {
121	CHRG_CLK_1M,
122	CHRG_CLK_2M,
123};
124
125enum charge_term_sel {
126	CHRG_TERM_150MA,
127	CHRG_TERM_200MA,
128	CHRG_TERM_300MA,
129	CHRG_TERM_400MA,
130};
131
132enum charge_timer_trickle {
133	CHRG_TIMER_TRIKL_30MIN,
134	CHRG_TIMER_TRIKL_45MIN,
135	CHRG_TIMER_TRIKL_60MIN,
136	CHRG_TIMER_TRIKL_90MIN,
137	CHRG_TIMER_TRIKL_120MIN,
138	CHRG_TIMER_TRIKL_150MIN,
139	CHRG_TIMER_TRIKL_180MIN,
140	CHRG_TIMER_TRIKL_210MIN,
141};
142
143enum charge_timer_cccv {
144	CHRG_TIMER_CCCV_4H,
145	CHRG_TIMER_CCCV_5H,
146	CHRG_TIMER_CCCV_6H,
147	CHRG_TIMER_CCCV_8H,
148	CHRG_TIMER_CCCV_10H,
149	CHRG_TIMER_CCCV_12H,
150	CHRG_TIMER_CCCV_14H,
151	CHRG_TIMER_CCCV_16H,
152};
153
154enum charge_status {
155	CHRG_OFF,
156	DEAD_CHRG,
157	TRICKLE_CHRG,
158	CC_OR_CV_CHRG,
159	CHRG_TERM,
160	USB_OVER_VOL,
161	BAT_TMP_ERR,
162	BAT_TIM_ERR,
163};
164
165enum discharge_ilimit {
166	DISCHRG_2000MA,
167	DISCHRG_2500MA,
168	DISCHRG_3000MA,
169	DISCHRG_3500MA,
170	DISCHRG_4000MA,
171};
172
173enum bat_system_comp_time {
174	DLY_20US,
175	DLY_10US,
176	DLY_40US,
177	DLY_20US_AGAIN,
178};
179
180enum charge_term_mode {
181	CHRG_ANALOG,
182	CHRG_DIGITAL,
183};
184
185enum charger_t {
186	USB_TYPE_UNKNOWN_CHARGER,
187	USB_TYPE_NONE_CHARGER,
188	USB_TYPE_USB_CHARGER,
189	USB_TYPE_AC_CHARGER,
190	USB_TYPE_CDP_CHARGER,
191	DC_TYPE_DC_CHARGER,
192	DC_TYPE_NONE_CHARGER,
193};
194
195enum charger_state {
196	OFFLINE = 0,
197	ONLINE
198};
199
200enum rk817_charge_fields {
201	BOOST_EN, OTG_EN, OTG_SLP_EN, CHRG_CLK_SEL,
202	CHRG_EN, CHRG_VOL_SEL, CHRG_CT_EN, CHRG_CUR_SEL,
203	USB_VLIM_EN, USB_VLIM_SEL, USB_ILIM_EN, USB_ILIM_SEL,
204	SYS_CAN_SD,  USB_SYS_EN, BAT_OVP_EN, CHRG_TERM_ANA_DIG,
205	CHRG_TERM_ANA_SEL,
206	CHRG_TERM_DIG,
207	BAT_HTS_TS, BAT_LTS_TS,
208	CHRG_TIMER_TRIKL_EN, CHRG_TIMER_TRIKL,
209	CHRG_TIMER_CCCV_EN, CHRG_TIMER_CCCV,
210	BAT_EXS, CHG_STS, BAT_OVP_STS, CHRG_IN_CLAMP,
211	USB_EXS, USB_EFF,
212	BAT_DIS_ILIM_STS, BAT_SYS_CMP_DLY, BAT_DIS_ILIM_EN,
213	BAT_DISCHRG_ILIM,
214	PLUG_IN_STS, SOC_REG0, SOC_REG1, SOC_REG2,
215	F_MAX_FIELDS
216};
217
218static const struct reg_field rk817_charge_reg_fields[] = {
219	[SOC_REG0] = REG_FIELD(0x9A, 0, 7),
220	[SOC_REG1] = REG_FIELD(0x9B, 0, 7),
221	[SOC_REG2] = REG_FIELD(0x9C, 0, 7),
222	[BOOST_EN] = REG_FIELD(0xB4, 1, 5),
223	[OTG_EN] = REG_FIELD(0xB4, 2, 6),
224	[OTG_SLP_EN] = REG_FIELD(0xB5, 6, 6),
225	[CHRG_EN] = REG_FIELD(0xE4, 7, 7),
226	[CHRG_VOL_SEL] = REG_FIELD(0xE4, 4, 6),
227	[CHRG_CT_EN] = REG_FIELD(0xE4, 3, 3),
228	[CHRG_CUR_SEL] = REG_FIELD(0xE4, 0, 2),
229
230	[USB_VLIM_EN] = REG_FIELD(0xE5, 7, 7),
231	[USB_VLIM_SEL] = REG_FIELD(0xE5, 4, 6),
232	[USB_ILIM_EN] = REG_FIELD(0xE5, 3, 3),
233	[USB_ILIM_SEL] = REG_FIELD(0xE5, 0, 2),
234
235	[SYS_CAN_SD] = REG_FIELD(0xE6, 7, 7),
236	[USB_SYS_EN] = REG_FIELD(0xE6, 6, 6),
237	[BAT_OVP_EN] = REG_FIELD(0xE6, 3, 3),
238	[CHRG_TERM_ANA_DIG] = REG_FIELD(0xE6, 2, 2),
239	[CHRG_TERM_ANA_SEL] = REG_FIELD(0xE6, 0, 1),
240
241	[CHRG_TERM_DIG] = REG_FIELD(0xE7, 0, 7),
242
243	[BAT_HTS_TS] = REG_FIELD(0xE8, 0, 7),
244
245	[BAT_LTS_TS] = REG_FIELD(0xE9, 0, 7),
246
247	[CHRG_TIMER_TRIKL_EN] = REG_FIELD(0xEA, 7, 7),
248	[CHRG_TIMER_TRIKL] = REG_FIELD(0xEA, 4, 6),
249	[CHRG_TIMER_CCCV_EN] = REG_FIELD(0xEA, 3, 3),
250	[CHRG_TIMER_CCCV] = REG_FIELD(0xEA, 0, 2),
251
252	[BAT_EXS] = REG_FIELD(0xEB, 7, 7),
253	[CHG_STS] = REG_FIELD(0xEB, 4, 6),
254	[BAT_OVP_STS] = REG_FIELD(0xEB, 3, 3),
255	[CHRG_IN_CLAMP] = REG_FIELD(0xEB, 2, 2),
256	[USB_EXS] = REG_FIELD(0xEB, 1, 1),
257	[USB_EFF] = REG_FIELD(0xEB, 0, 0),
258
259	[BAT_DIS_ILIM_STS] = REG_FIELD(0xEC, 6, 6),
260	[BAT_SYS_CMP_DLY] = REG_FIELD(0xEC, 4, 5),
261	[BAT_DIS_ILIM_EN] = REG_FIELD(0xEC, 3, 3),
262	[BAT_DISCHRG_ILIM] = REG_FIELD(0xEC, 0, 2),
263	[PLUG_IN_STS] = REG_FIELD(0xf0, 6, 6),
264	[CHRG_CLK_SEL] = REG_FIELD(0xF3, 6, 6),
265};
266
267struct charger_platform_data {
268	u32 max_input_current;
269	u32 min_input_voltage;
270
271	u32 max_chrg_current;
272	u32 max_chrg_voltage;
273
274	u32 chrg_finish_cur;
275	u32 chrg_term_mode;
276
277	u32 power_dc2otg;
278	u32 dc_det_level;
279	int dc_det_pin;
280	bool support_dc_det;
281	int virtual_power;
282	int sample_res;
283	int otg5v_suspend_enable;
284	bool extcon;
285	int gate_function_disable;
286};
287
288struct rk817_charger {
289	struct i2c_client *client;
290	struct platform_device *pdev;
291	struct device *dev;
292	struct rk808 *rk817;
293	struct regmap *regmap;
294	struct regmap_field *rmap_fields[F_MAX_FIELDS];
295
296	struct power_supply *ac_psy;
297	struct power_supply *usb_psy;
298	struct extcon_dev *cable_edev;
299	struct charger_platform_data *pdata;
300	struct workqueue_struct *usb_charger_wq;
301	struct workqueue_struct *dc_charger_wq;
302	struct delayed_work dc_work;
303	struct delayed_work usb_work;
304	struct delayed_work host_work;
305	struct delayed_work discnt_work;
306	struct delayed_work irq_work;
307	struct notifier_block bc_nb;
308	struct notifier_block cable_cg_nb;
309	struct notifier_block cable_host_nb;
310	struct notifier_block cable_discnt_nb;
311	unsigned int bc_event;
312	enum charger_t usb_charger;
313	enum charger_t dc_charger;
314	struct regulator *otg5v_rdev;
315	u8 ac_in;
316	u8 usb_in;
317	u8 otg_in;
318	u8 dc_in;
319	u8 prop_status;
320
321	u32 max_input_current;
322	u32 min_input_voltage;
323
324	u32 max_chrg_current;
325	u32 max_chrg_voltage;
326
327	u32 chrg_finish_cur;
328	u32 chrg_term_mode;
329
330	u8 res_div;
331	u8 otg_slp_state;
332	u8 plugin_trigger;
333	u8 plugout_trigger;
334	int plugin_irq;
335	int plugout_irq;
336};
337
338static enum power_supply_property rk817_ac_props[] = {
339	POWER_SUPPLY_PROP_ONLINE,
340	POWER_SUPPLY_PROP_STATUS,
341	POWER_SUPPLY_PROP_VOLTAGE_MAX,
342	POWER_SUPPLY_PROP_CURRENT_MAX,
343};
344
345static enum power_supply_property rk817_usb_props[] = {
346	POWER_SUPPLY_PROP_ONLINE,
347	POWER_SUPPLY_PROP_STATUS,
348	POWER_SUPPLY_PROP_VOLTAGE_MAX,
349	POWER_SUPPLY_PROP_CURRENT_MAX,
350};
351
352static int rk817_charge_ac_get_property(struct power_supply *psy,
353					enum power_supply_property psp,
354					union power_supply_propval *val)
355{
356	struct rk817_charger *charge = power_supply_get_drvdata(psy);
357	int ret = 0;
358
359	switch (psp) {
360	case POWER_SUPPLY_PROP_ONLINE:
361		if (charge->pdata->virtual_power)
362			val->intval = 1;
363		else
364			val->intval = (charge->ac_in | charge->dc_in);
365
366		DBG("ac report online: %d\n", val->intval);
367		break;
368	case POWER_SUPPLY_PROP_STATUS:
369		if (charge->pdata->virtual_power)
370			val->intval = POWER_SUPPLY_STATUS_CHARGING;
371		else
372			val->intval = charge->prop_status;
373
374		DBG("report prop: %d\n", val->intval);
375		break;
376	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
377		val->intval = charge->max_chrg_voltage * 1000;	/* uV */
378		break;
379	case POWER_SUPPLY_PROP_CURRENT_MAX:
380		val->intval = charge->max_chrg_current * 1000;	/* uA */
381		break;
382	default:
383		ret = -EINVAL;
384		break;
385	}
386
387	return ret;
388}
389
390static int rk817_charge_usb_get_property(struct power_supply *psy,
391					 enum power_supply_property psp,
392					 union power_supply_propval *val)
393{
394	struct rk817_charger *charge = power_supply_get_drvdata(psy);
395	int ret = 0;
396
397	switch (psp) {
398	case POWER_SUPPLY_PROP_ONLINE:
399		if (charge->pdata->virtual_power)
400			val->intval = 1;
401		else
402			val->intval = charge->usb_in;
403
404		DBG("usb report online: %d\n", val->intval);
405		break;
406	case POWER_SUPPLY_PROP_STATUS:
407		if (charge->pdata->virtual_power)
408			val->intval = POWER_SUPPLY_STATUS_CHARGING;
409		else
410			val->intval = charge->prop_status;
411
412		DBG("report prop: %d\n", val->intval);
413		break;
414	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
415		val->intval = charge->max_chrg_voltage;
416		break;
417	case POWER_SUPPLY_PROP_CURRENT_MAX:
418		val->intval = charge->max_chrg_current;
419		break;
420	default:
421		ret = -EINVAL;
422		break;
423	}
424
425	return ret;
426}
427
428static const struct power_supply_desc rk817_ac_desc = {
429	.name		= "ac",
430	.type		= POWER_SUPPLY_TYPE_MAINS,
431	.properties	= rk817_ac_props,
432	.num_properties	= ARRAY_SIZE(rk817_ac_props),
433	.get_property	= rk817_charge_ac_get_property,
434};
435
436static const struct power_supply_desc rk817_usb_desc = {
437	.name		= "usb",
438	.type		= POWER_SUPPLY_TYPE_USB,
439	.properties	= rk817_usb_props,
440	.num_properties	= ARRAY_SIZE(rk817_usb_props),
441	.get_property	= rk817_charge_usb_get_property,
442};
443
444static int rk817_charge_init_power_supply(struct rk817_charger *charge)
445{
446	struct power_supply_config psy_cfg = { .drv_data = charge, };
447
448	charge->usb_psy = devm_power_supply_register(charge->dev,
449						     &rk817_usb_desc,
450						     &psy_cfg);
451	if (IS_ERR(charge->usb_psy)) {
452		dev_err(charge->dev, "register usb power supply fail\n");
453		return PTR_ERR(charge->usb_psy);
454	}
455
456	charge->ac_psy = devm_power_supply_register(charge->dev, &rk817_ac_desc,
457						&psy_cfg);
458	if (IS_ERR(charge->ac_psy)) {
459		dev_err(charge->dev, "register ac power supply fail\n");
460		return PTR_ERR(charge->ac_psy);
461	}
462
463	return 0;
464}
465
466static int rk817_charge_field_read(struct rk817_charger *charge,
467				   enum rk817_charge_fields field_id)
468{
469	int ret;
470	int val;
471
472	ret = regmap_field_read(charge->rmap_fields[field_id], &val);
473	if (ret < 0)
474		return ret;
475
476	return val;
477}
478
479static int rk817_charge_field_write(struct rk817_charger *charge,
480				    enum rk817_charge_fields field_id,
481				    unsigned int val)
482{
483	return regmap_field_write(charge->rmap_fields[field_id], val);
484}
485
486static int rk817_charge_get_otg_state(struct rk817_charger *charge)
487{
488	return regulator_is_enabled(charge->otg5v_rdev);
489}
490
491static void rk817_charge_boost_disable(struct rk817_charger *charge)
492{
493	rk817_charge_field_write(charge, BOOST_EN, RK817_BOOST_DISABLE);
494}
495
496static void rk817_charge_boost_enable(struct rk817_charger *charge)
497{
498	rk817_charge_field_write(charge, BOOST_EN, RK817_BOOST_ENABLE);
499}
500
501static void rk817_charge_otg_disable(struct rk817_charger *charge)
502{
503	int ret;
504
505	ret = regulator_disable(charge->otg5v_rdev);
506
507	if (ret) {
508		DBG("disable otg5v failed:%d\n", ret);
509		return;
510	}
511
512	return;
513}
514
515static void rk817_charge_otg_enable(struct rk817_charger *charge)
516{
517	int ret;
518
519	ret = regulator_enable(charge->otg5v_rdev);
520
521	if (ret) {
522		DBG("enable otg5v failed:%d\n", ret);
523		return;
524	}
525
526	return;
527}
528
529#ifdef CONFIG_PM_SLEEP
530static int rk817_charge_get_otg_slp_state(struct rk817_charger *charge)
531{
532	return (rk817_charge_field_read(charge, OTG_SLP_EN) & OTG_SLP_ENABLE);
533}
534
535static void rk817_charge_otg_slp_disable(struct rk817_charger *charge)
536{
537	rk817_charge_field_write(charge, OTG_SLP_EN, OTG_SLP_DISABLE);
538}
539
540static void rk817_charge_otg_slp_enable(struct rk817_charger *charge)
541{
542	rk817_charge_field_write(charge, OTG_SLP_EN, OTG_SLP_ENABLE);
543}
544#endif
545
546static int rk817_charge_get_charge_state(struct rk817_charger *charge)
547{
548	return rk817_charge_field_read(charge, CHRG_EN);
549}
550
551static void rk817_charge_enable_charge(struct rk817_charger *charge)
552{
553	rk817_charge_field_write(charge, CHRG_EN, ENABLE);
554}
555
556static void rk817_charge_usb_to_sys_enable(struct rk817_charger *charge)
557{
558	rk817_charge_field_write(charge, USB_SYS_EN, ENABLE);
559}
560
561static void rk817_charge_sys_can_sd_disable(struct rk817_charger *charge)
562{
563	rk817_charge_field_write(charge, SYS_CAN_SD, DISABLE);
564}
565
566static int rk817_charge_get_charge_status(struct rk817_charger *charge)
567{
568	int status;
569
570	status = rk817_charge_field_read(charge, CHG_STS);
571
572	switch (status) {
573	case CHRG_OFF:
574		DBG("charge off...\n");
575		break;
576	case DEAD_CHRG:
577		DBG("dead charge...\n");
578		break;
579	case TRICKLE_CHRG:
580		DBG("trickle charge...\n");
581		break;
582	case CC_OR_CV_CHRG:
583		DBG("CC or CV charge...\n");
584		break;
585	case CHRG_TERM:
586		DBG("charge TERM...\n");
587		break;
588	case USB_OVER_VOL:
589		DBG("USB over voltage...\n");
590		break;
591	case BAT_TMP_ERR:
592		DBG("battery temperature error...\n");
593		break;
594	case BAT_TIM_ERR:
595		DBG("battery timer error..\n");
596		break;
597	default:
598		break;
599	}
600
601	return status;
602}
603
604static int rk817_charge_get_plug_in_status(struct rk817_charger *charge)
605{
606	return rk817_charge_field_read(charge, PLUG_IN_STS);
607}
608
609static void rk817_charge_set_charge_clock(struct rk817_charger *charge,
610					  enum charge_clk clock)
611{
612	rk817_charge_field_write(charge, CHRG_CLK_SEL, clock);
613}
614
615static int is_battery_exist(struct rk817_charger *charge)
616{
617	return rk817_charge_field_read(charge, BAT_EXS);
618}
619
620static void rk817_charge_set_chrg_voltage(struct rk817_charger *charge,
621					  int chrg_vol)
622{
623	int voltage;
624
625	if (chrg_vol < 4100 || chrg_vol > 4500) {
626		dev_err(charge->dev, "the charge voltage is error!\n");
627	} else {
628		voltage = (chrg_vol - 4100) / 50;
629		rk817_charge_field_write(charge,
630					 CHRG_VOL_SEL,
631					 CHRG_VOL_4100MV + voltage);
632	}
633}
634
635static void rk817_charge_set_chrg_current(struct rk817_charger *charge,
636					  int chrg_current)
637{
638	if (chrg_current < 500 || chrg_current > 3500)
639		dev_err(charge->dev, "the charge current is error!\n");
640
641	if (chrg_current < 1000)
642		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_500MA);
643	else if (chrg_current < 1500)
644		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_1000MA);
645	else if (chrg_current < 2000)
646		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_1500MA);
647	else if (chrg_current < 2500)
648		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_2000MA);
649	else if (chrg_current < 3000)
650		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_2500MA);
651	else if (chrg_current < 3500)
652		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_3000MA);
653	else
654		rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_3500MA);
655}
656
657static void rk817_charge_vlimit_enable(struct rk817_charger *charge)
658{
659	rk817_charge_field_write(charge, USB_VLIM_EN, ENABLE);
660}
661
662static void rk817_charge_set_input_voltage(struct rk817_charger *charge,
663					   int input_voltage)
664{
665	int voltage;
666
667	if (input_voltage < 4000)
668		dev_err(charge->dev, "the input voltage is error.\n");
669
670	voltage = INPUT_VOL_4000MV + (input_voltage - 4000) / 100;
671
672	rk817_charge_field_write(charge, USB_VLIM_SEL, voltage);
673	rk817_charge_vlimit_enable(charge);
674}
675
676static void rk817_charge_ilimit_enable(struct rk817_charger *charge)
677{
678	rk817_charge_field_write(charge, USB_ILIM_EN, ENABLE);
679}
680
681static void rk817_charge_set_input_current(struct rk817_charger *charge,
682					   int input_current)
683{
684	if (input_current < 80 || input_current > 3000)
685		dev_err(charge->dev, "the input current is error.\n");
686
687	if (input_current < 450)
688		rk817_charge_field_write(charge, USB_ILIM_SEL,
689					 INPUT_CUR_80MA);
690	else if (input_current < 850)
691		rk817_charge_field_write(charge, USB_ILIM_SEL,
692					 INPUT_CUR_450MA);
693	else if (input_current < 1500)
694		rk817_charge_field_write(charge, USB_ILIM_SEL,
695					 INPUT_CUR_850MA);
696	else if (input_current < 1750)
697		rk817_charge_field_write(charge, USB_ILIM_SEL,
698					 INPUT_CUR_1500MA);
699	else if (input_current < 2000)
700		rk817_charge_field_write(charge, USB_ILIM_SEL,
701					 INPUT_CUR_1750MA);
702	else if (input_current < 2500)
703		rk817_charge_field_write(charge, USB_ILIM_SEL,
704					 INPUT_CUR_2000MA);
705	else if (input_current < 3000)
706		rk817_charge_field_write(charge, USB_ILIM_SEL,
707					 INPUT_CUR_2500MA);
708	else
709		rk817_charge_field_write(charge, USB_ILIM_SEL,
710					 INPUT_CUR_3000MA);
711
712	rk817_charge_ilimit_enable(charge);
713}
714
715static void rk817_charge_set_chrg_term_mod(struct rk817_charger *charge,
716					   int mode)
717{
718	rk817_charge_field_write(charge, CHRG_TERM_ANA_DIG, mode);
719}
720
721static void rk817_charge_set_term_current_analog(struct rk817_charger *charge,
722						 int chrg_current)
723{
724	int value;
725
726	if (chrg_current < 200)
727		value = CHRG_TERM_150MA;
728	else if (chrg_current < 300)
729		value = CHRG_TERM_200MA;
730	else if (chrg_current < 400)
731		value = CHRG_TERM_300MA;
732	else
733		value = CHRG_TERM_400MA;
734
735	rk817_charge_field_write(charge,
736				 CHRG_TERM_ANA_SEL,
737				 value);
738}
739
740static void rk817_charge_set_term_current_digital(struct rk817_charger *charge,
741						  int chrg_current)
742{
743	int value;
744	u8 current_adc;
745
746	value = CURRENT_TO_ADC(chrg_current, charge->res_div);
747
748	value &= (0xff << 5);
749	current_adc = value >> 5;
750	rk817_charge_field_write(charge, CHRG_TERM_DIG, current_adc);
751}
752
753static void rk817_charge_set_chrg_finish_condition(struct rk817_charger *charge)
754{
755	if (charge->chrg_term_mode == CHRG_ANALOG)
756		rk817_charge_set_term_current_analog(charge,
757						     charge->chrg_finish_cur);
758	else
759		rk817_charge_set_term_current_digital(charge,
760						      charge->chrg_finish_cur);
761
762	rk817_charge_set_chrg_term_mod(charge, charge->chrg_term_mode);
763}
764
765static int rk817_charge_online(struct rk817_charger *charge)
766{
767	return (charge->ac_in | charge->usb_in | charge->dc_in);
768}
769
770static int rk817_charge_get_dsoc(struct rk817_charger *charge)
771{
772	int soc_save;
773
774	soc_save = rk817_charge_field_read(charge, SOC_REG0);
775	soc_save |= (rk817_charge_field_read(charge, SOC_REG1) << 8);
776	soc_save |= (rk817_charge_field_read(charge, SOC_REG2) << 16);
777
778	return soc_save / 1000;
779}
780
781static void rk817_charge_set_otg_in(struct rk817_charger *charge, int online)
782{
783	charge->otg_in = online;
784}
785
786static void rk817_charge_set_chrg_param(struct rk817_charger *charge,
787					enum charger_t charger)
788{
789	switch (charger) {
790	case USB_TYPE_NONE_CHARGER:
791		charge->usb_in = 0;
792		charge->ac_in = 0;
793		if (charge->dc_in == 0) {
794			charge->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
795			rk817_charge_set_input_current(charge, INPUT_450MA);
796		}
797		power_supply_changed(charge->usb_psy);
798		power_supply_changed(charge->ac_psy);
799		break;
800	case USB_TYPE_USB_CHARGER:
801		charge->usb_in = 1;
802		charge->ac_in = 0;
803		charge->prop_status = POWER_SUPPLY_STATUS_CHARGING;
804		if (charge->dc_in == 0)
805			rk817_charge_set_input_current(charge, INPUT_450MA);
806		power_supply_changed(charge->usb_psy);
807		power_supply_changed(charge->ac_psy);
808		break;
809	case USB_TYPE_AC_CHARGER:
810	case USB_TYPE_CDP_CHARGER:
811		charge->ac_in = 1;
812		charge->usb_in = 0;
813		charge->prop_status = POWER_SUPPLY_STATUS_CHARGING;
814		if (charger == USB_TYPE_AC_CHARGER)
815			rk817_charge_set_input_current(charge,
816						       charge->max_input_current);
817		else
818			rk817_charge_set_input_current(charge,
819						       INPUT_1500MA);
820		power_supply_changed(charge->usb_psy);
821		power_supply_changed(charge->ac_psy);
822		break;
823	case DC_TYPE_DC_CHARGER:
824		charge->dc_in = 1;
825		charge->prop_status = POWER_SUPPLY_STATUS_CHARGING;
826		rk817_charge_set_input_current(charge,
827					       charge->max_input_current);
828		power_supply_changed(charge->usb_psy);
829		power_supply_changed(charge->ac_psy);
830		break;
831	case DC_TYPE_NONE_CHARGER:
832		charge->dc_in = 0;
833		if (!rk817_charge_get_plug_in_status(charge)) {
834			charge->ac_in = 0;
835			charge->usb_in = 0;
836			charge->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
837			rk817_charge_set_input_current(charge, INPUT_450MA);
838		} else if (charge->usb_in) {
839			rk817_charge_set_input_current(charge, INPUT_450MA);
840			charge->prop_status = POWER_SUPPLY_STATUS_CHARGING;
841		}
842		power_supply_changed(charge->usb_psy);
843		power_supply_changed(charge->ac_psy);
844		break;
845	default:
846		charge->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
847		rk817_charge_set_input_current(charge, INPUT_450MA);
848		break;
849	}
850
851	if (rk817_charge_online(charge) && rk817_charge_get_dsoc(charge) == 100)
852		charge->prop_status = POWER_SUPPLY_STATUS_FULL;
853}
854
855static void rk817_charge_set_otg_state(struct rk817_charger *charge, int state)
856{
857	switch (state) {
858	case USB_OTG_POWER_ON:
859		if (charge->otg_in) {
860			DBG("otg5v is on yet, ignore..\n");
861		} else {
862
863			if (!rk817_charge_get_otg_state(charge)) {
864				rk817_charge_otg_enable(charge);
865				if (!rk817_charge_get_otg_state(charge)) {
866					DBG("enable otg5v failed\n");
867					return;
868				}
869			}
870			disable_irq(charge->plugin_irq);
871			disable_irq(charge->plugout_irq);
872			DBG("enable otg5v\n");
873		}
874		break;
875
876	case USB_OTG_POWER_OFF:
877		if (!charge->otg_in) {
878			DBG("otg5v is off yet, ignore..\n");
879		} else {
880
881			if (rk817_charge_get_otg_state(charge)) {
882				rk817_charge_otg_disable(charge);
883				if (rk817_charge_get_otg_state(charge)) {
884					DBG("disable otg5v failed\n");
885					return;
886				}
887			}
888			enable_irq(charge->plugin_irq);
889			enable_irq(charge->plugout_irq);
890			DBG("disable otg5v\n");
891		}
892		break;
893	default:
894		dev_err(charge->dev, "error otg type\n");
895		break;
896	}
897}
898
899static irqreturn_t rk817_charge_dc_det_isr(int irq, void *charger)
900{
901	struct rk817_charger *charge = (struct rk817_charger *)charger;
902
903	if (gpio_get_value(charge->pdata->dc_det_pin))
904		irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
905	else
906		irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
907
908	queue_delayed_work(charge->dc_charger_wq, &charge->dc_work,
909			   msecs_to_jiffies(10));
910
911	return IRQ_HANDLED;
912}
913
914static enum charger_t rk817_charge_get_dc_state(struct rk817_charger *charge)
915{
916	int level;
917
918	if (!gpio_is_valid(charge->pdata->dc_det_pin))
919		return DC_TYPE_NONE_CHARGER;
920
921	level = gpio_get_value(charge->pdata->dc_det_pin);
922
923	return (level == charge->pdata->dc_det_level) ?
924		DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
925}
926
927static void rk817_charge_dc_det_worker(struct work_struct *work)
928{
929	enum charger_t charger;
930	struct rk817_charger *charge = container_of(work,
931			struct rk817_charger, dc_work.work);
932
933	charger = rk817_charge_get_dc_state(charge);
934	if (charger == DC_TYPE_DC_CHARGER) {
935		DBG("detect dc charger in..\n");
936		rk817_charge_set_chrg_param(charge, DC_TYPE_DC_CHARGER);
937		/* check otg supply */
938		if (charge->otg_in && charge->pdata->power_dc2otg) {
939			DBG("otg power from dc adapter\n");
940			rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF);
941		}
942
943		rk817_charge_boost_disable(charge);
944	} else {
945		DBG("detect dc charger out..\n");
946		rk817_charge_set_chrg_param(charge, DC_TYPE_NONE_CHARGER);
947		rk817_charge_boost_enable(charge);
948		/* check otg supply, power on anyway */
949		if (charge->otg_in)
950			rk817_charge_set_otg_state(charge, USB_OTG_POWER_ON);
951	}
952}
953
954static int rk817_charge_init_dc(struct rk817_charger *charge)
955{
956	int ret, level;
957	unsigned long irq_flags;
958	unsigned int dc_det_irq;
959
960	charge->dc_charger_wq = alloc_ordered_workqueue("%s",
961				WQ_MEM_RECLAIM | WQ_FREEZABLE,
962				"rk817-dc-wq");
963	INIT_DELAYED_WORK(&charge->dc_work, rk817_charge_dc_det_worker);
964	charge->dc_charger = DC_TYPE_NONE_CHARGER;
965
966	if (!charge->pdata->support_dc_det)
967		return 0;
968
969	ret = devm_gpio_request(charge->dev,
970				charge->pdata->dc_det_pin,
971				"rk817_dc_det");
972	if (ret < 0) {
973		dev_err(charge->dev, "failed to request gpio %d\n",
974			charge->pdata->dc_det_pin);
975		return ret;
976	}
977
978	ret = gpio_direction_input(charge->pdata->dc_det_pin);
979	if (ret) {
980		dev_err(charge->dev, "failed to set gpio input\n");
981		return ret;
982	}
983
984	level = gpio_get_value(charge->pdata->dc_det_pin);
985	if (level == charge->pdata->dc_det_level)
986		charge->dc_charger = DC_TYPE_DC_CHARGER;
987	else
988		charge->dc_charger = DC_TYPE_NONE_CHARGER;
989
990	if (level)
991		irq_flags = IRQF_TRIGGER_LOW;
992	else
993		irq_flags = IRQF_TRIGGER_HIGH;
994
995	dc_det_irq = gpio_to_irq(charge->pdata->dc_det_pin);
996	ret = devm_request_irq(charge->dev, dc_det_irq, rk817_charge_dc_det_isr,
997			       irq_flags, "rk817_dc_det", charge);
998	if (ret != 0) {
999		dev_err(charge->dev, "rk817_dc_det_irq request failed!\n");
1000		return ret;
1001	}
1002
1003	enable_irq_wake(dc_det_irq);
1004
1005	if (charge->dc_charger != DC_TYPE_NONE_CHARGER)
1006		rk817_charge_set_chrg_param(charge, charge->dc_charger);
1007
1008	return 0;
1009}
1010
1011static void rk817_charge_host_evt_worker(struct work_struct *work)
1012{
1013	struct rk817_charger *charge = container_of(work,
1014			struct rk817_charger, host_work.work);
1015	struct extcon_dev *edev = charge->cable_edev;
1016
1017	/* Determine cable/charger type */
1018	if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) > 0) {
1019		DBG("receive type-c notifier event: OTG ON...\n");
1020		if (charge->dc_in && charge->pdata->power_dc2otg) {
1021			if (charge->otg_in)
1022				rk817_charge_set_otg_state(charge,
1023							   USB_OTG_POWER_OFF);
1024			DBG("otg power from dc adapter\n");
1025		} else {
1026			rk817_charge_set_otg_state(charge, USB_OTG_POWER_ON);
1027		}
1028		rk817_charge_set_otg_in(charge, ONLINE);
1029	} else if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) == 0) {
1030		DBG("receive type-c notifier event: OTG OFF...\n");
1031		rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF);
1032		rk817_charge_set_otg_in(charge, OFFLINE);
1033	}
1034}
1035
1036static void rk817_charger_evt_worker(struct work_struct *work)
1037{
1038	struct rk817_charger *charge = container_of(work,
1039				struct rk817_charger, usb_work.work);
1040	struct extcon_dev *edev = charge->cable_edev;
1041	enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
1042	static const char * const event[] = {"UN", "NONE", "USB",
1043					     "AC", "CDP1.5A"};
1044
1045	/* Determine cable/charger type */
1046	if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0)
1047		charger = USB_TYPE_USB_CHARGER;
1048	else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0)
1049		charger = USB_TYPE_AC_CHARGER;
1050	else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0)
1051		charger = USB_TYPE_CDP_CHARGER;
1052
1053	if (charger != USB_TYPE_UNKNOWN_CHARGER) {
1054		DBG("receive type-c notifier event: %s...\n",
1055		    event[charger]);
1056		charge->usb_charger = charger;
1057		rk817_charge_set_chrg_param(charge, charger);
1058	}
1059}
1060
1061static void rk817_charge_discnt_evt_worker(struct work_struct *work)
1062{
1063	struct rk817_charger *charge = container_of(work,
1064			struct rk817_charger, discnt_work.work);
1065
1066	if (extcon_get_state(charge->cable_edev, EXTCON_USB) == 0) {
1067		DBG("receive type-c notifier event: DISCNT...\n");
1068
1069		rk817_charge_set_chrg_param(charge, USB_TYPE_NONE_CHARGER);
1070	}
1071}
1072
1073static void rk817_charge_bc_evt_worker(struct work_struct *work)
1074{
1075	struct rk817_charger *charge = container_of(work,
1076						    struct rk817_charger,
1077						    usb_work.work);
1078	static const char * const event_name[] = {"DISCNT", "USB", "AC",
1079						  "CDP1.5A", "UNKNOWN",
1080						  "OTG ON", "OTG OFF"};
1081
1082	switch (charge->bc_event) {
1083	case USB_BC_TYPE_DISCNT:
1084		rk817_charge_set_chrg_param(charge, USB_TYPE_NONE_CHARGER);
1085		break;
1086	case USB_BC_TYPE_SDP:
1087		rk817_charge_set_chrg_param(charge, USB_TYPE_USB_CHARGER);
1088		break;
1089	case USB_BC_TYPE_DCP:
1090		rk817_charge_set_chrg_param(charge, USB_TYPE_AC_CHARGER);
1091		break;
1092	case USB_BC_TYPE_CDP:
1093		rk817_charge_set_chrg_param(charge, USB_TYPE_CDP_CHARGER);
1094		break;
1095	case USB_OTG_POWER_ON:
1096		if (charge->pdata->power_dc2otg && charge->dc_in)
1097			DBG("otg power from dc adapter\n");
1098		else
1099			rk817_charge_set_otg_state(charge, USB_OTG_POWER_ON);
1100		break;
1101	case USB_OTG_POWER_OFF:
1102		rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF);
1103		break;
1104	default:
1105		break;
1106	}
1107
1108	DBG("receive bc notifier event: %s..\n", event_name[charge->bc_event]);
1109}
1110
1111static int rk817_charger_evt_notifier(struct notifier_block *nb,
1112				      unsigned long event, void *ptr)
1113{
1114	struct rk817_charger *charge =
1115		container_of(nb, struct rk817_charger, cable_cg_nb);
1116
1117	queue_delayed_work(charge->usb_charger_wq, &charge->usb_work,
1118			   msecs_to_jiffies(10));
1119
1120	return NOTIFY_DONE;
1121}
1122
1123static int rk817_charge_host_evt_notifier(struct notifier_block *nb,
1124					  unsigned long event, void *ptr)
1125{
1126	struct rk817_charger *charge =
1127		container_of(nb, struct rk817_charger, cable_host_nb);
1128
1129	queue_delayed_work(charge->usb_charger_wq, &charge->host_work,
1130			   msecs_to_jiffies(10));
1131
1132	return NOTIFY_DONE;
1133}
1134
1135static int rk817_charge_discnt_evt_notfier(struct notifier_block *nb,
1136					   unsigned long event, void *ptr)
1137{
1138	struct rk817_charger *charge =
1139		container_of(nb, struct rk817_charger, cable_discnt_nb);
1140
1141	queue_delayed_work(charge->usb_charger_wq, &charge->discnt_work,
1142			   msecs_to_jiffies(10));
1143
1144	return NOTIFY_DONE;
1145}
1146
1147static int rk817_charge_bc_evt_notifier(struct notifier_block *nb,
1148					unsigned long event, void *ptr)
1149{
1150	struct rk817_charger *charge =
1151		container_of(nb, struct rk817_charger, bc_nb);
1152
1153	charge->bc_event = event;
1154	queue_delayed_work(charge->usb_charger_wq, &charge->usb_work,
1155			   msecs_to_jiffies(10));
1156
1157	return NOTIFY_DONE;
1158}
1159
1160static int rk817_charge_usb_init(struct rk817_charger *charge)
1161{
1162	enum charger_t charger;
1163	enum bc_port_type bc_type;
1164	struct extcon_dev *edev;
1165	struct device *dev = charge->dev;
1166	int ret;
1167
1168	charge->usb_charger_wq = alloc_ordered_workqueue("%s",
1169				WQ_MEM_RECLAIM | WQ_FREEZABLE,
1170				"rk817-usb-wq");
1171
1172	/* type-C */
1173	if (charge->pdata->extcon) {
1174		edev = extcon_get_edev_by_phandle(dev, 0);
1175		if (IS_ERR(edev)) {
1176			if (PTR_ERR(edev) != -EPROBE_DEFER)
1177				dev_err(dev, "Invalid or missing extcon\n");
1178			return PTR_ERR(edev);
1179		}
1180
1181		/* Register chargers  */
1182		INIT_DELAYED_WORK(&charge->usb_work, rk817_charger_evt_worker);
1183		charge->cable_cg_nb.notifier_call = rk817_charger_evt_notifier;
1184		ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
1185					       &charge->cable_cg_nb);
1186		if (ret < 0) {
1187			dev_err(dev, "failed to register notifier for SDP\n");
1188			return ret;
1189		}
1190
1191		ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1192					       &charge->cable_cg_nb);
1193		if (ret < 0) {
1194			dev_err(dev, "failed to register notifier for DCP\n");
1195			extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1196						   &charge->cable_cg_nb);
1197			return ret;
1198		}
1199
1200		ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1201					       &charge->cable_cg_nb);
1202		if (ret < 0) {
1203			dev_err(dev, "failed to register notifier for CDP\n");
1204			extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1205						   &charge->cable_cg_nb);
1206			extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1207						   &charge->cable_cg_nb);
1208			return ret;
1209		}
1210
1211		/* Register host */
1212		INIT_DELAYED_WORK(&charge->host_work,
1213				  rk817_charge_host_evt_worker);
1214		charge->cable_host_nb.notifier_call =
1215			rk817_charge_host_evt_notifier;
1216		ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
1217					       &charge->cable_host_nb);
1218		if (ret < 0) {
1219			dev_err(dev, "failed to register notifier for HOST\n");
1220			extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1221						   &charge->cable_cg_nb);
1222			extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1223						   &charge->cable_cg_nb);
1224			extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1225						   &charge->cable_cg_nb);
1226
1227			return ret;
1228		}
1229
1230		/* Register discnt usb */
1231		INIT_DELAYED_WORK(&charge->discnt_work,
1232				  rk817_charge_discnt_evt_worker);
1233		charge->cable_discnt_nb.notifier_call =
1234			rk817_charge_discnt_evt_notfier;
1235		ret = extcon_register_notifier(edev, EXTCON_USB,
1236					       &charge->cable_discnt_nb);
1237		if (ret < 0) {
1238			dev_err(dev, "failed to register notifier for HOST\n");
1239			extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1240						   &charge->cable_cg_nb);
1241			extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1242						   &charge->cable_cg_nb);
1243			extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1244						   &charge->cable_cg_nb);
1245			extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
1246						   &charge->cable_host_nb);
1247			return ret;
1248		}
1249
1250		charge->cable_edev = edev;
1251
1252		DBG("register typec extcon evt notifier\n");
1253	} else {
1254		INIT_DELAYED_WORK(&charge->usb_work,
1255				  rk817_charge_bc_evt_worker);
1256		charge->bc_nb.notifier_call = rk817_charge_bc_evt_notifier;
1257		ret = rk_bc_detect_notifier_register(&charge->bc_nb, &bc_type);
1258		if (ret) {
1259			dev_err(dev, "failed to register notifier for bc\n");
1260			return -EINVAL;
1261	}
1262
1263		switch (bc_type) {
1264		case USB_BC_TYPE_DISCNT:
1265			charger = USB_TYPE_NONE_CHARGER;
1266			break;
1267		case USB_BC_TYPE_SDP:
1268		case USB_BC_TYPE_CDP:
1269			charger = USB_TYPE_USB_CHARGER;
1270			break;
1271		case USB_BC_TYPE_DCP:
1272			charger = USB_TYPE_AC_CHARGER;
1273			break;
1274		default:
1275			charger = USB_TYPE_NONE_CHARGER;
1276			break;
1277		}
1278
1279		charge->usb_charger = charger;
1280		if (charge->dc_charger != DC_TYPE_NONE_CHARGER)
1281			rk817_charge_set_chrg_param(charge,
1282						    charge->usb_charger);
1283
1284		DBG("register bc evt notifier\n");
1285	}
1286
1287	return 0;
1288}
1289
1290static void rk817_charge_pre_init(struct rk817_charger *charge)
1291{
1292	charge->max_chrg_current = charge->pdata->max_chrg_current;
1293	charge->max_input_current = charge->pdata->max_input_current;
1294	charge->max_chrg_voltage = charge->pdata->max_chrg_voltage;
1295	charge->min_input_voltage = charge->pdata->min_input_voltage;
1296	charge->chrg_finish_cur = charge->pdata->chrg_finish_cur;
1297	charge->chrg_term_mode = charge->pdata->chrg_term_mode;
1298
1299	rk817_charge_set_input_voltage(charge, charge->min_input_voltage);
1300
1301	rk817_charge_set_chrg_voltage(charge, charge->max_chrg_voltage);
1302	rk817_charge_set_chrg_current(charge, charge->max_chrg_current);
1303
1304	rk817_charge_set_chrg_finish_condition(charge);
1305
1306	if (rk817_charge_get_otg_state(charge))
1307		rk817_charge_otg_disable(charge);
1308	rk817_charge_field_write(charge, OTG_EN, OTG_DISABLE);
1309	rk817_charge_set_otg_in(charge, OFFLINE);
1310
1311	if (!charge->pdata->gate_function_disable)
1312		rk817_charge_sys_can_sd_disable(charge);
1313	rk817_charge_usb_to_sys_enable(charge);
1314	rk817_charge_enable_charge(charge);
1315
1316	rk817_charge_set_charge_clock(charge, CHRG_CLK_2M);
1317}
1318
1319static void rk817_chage_debug(struct rk817_charger *charge)
1320{
1321	rk817_charge_get_charge_status(charge);
1322	DBG("OTG state : %d\n", rk817_charge_get_otg_state(charge));
1323	DBG("charge state: %d\n", rk817_charge_get_charge_state(charge));
1324	DBG("max_chrg_current: %d\n"
1325	    "max_input_current: %d\n"
1326	    "min_input_voltage: %d\n"
1327	    "max_chrg_voltage: %d\n"
1328	    "max_chrg_finish_cur: %d\n"
1329	    "chrg_term_mode: %d\n",
1330	    charge->max_chrg_current,
1331	    charge->max_input_current,
1332	    charge->min_input_voltage,
1333	    charge->max_chrg_voltage,
1334	    charge->chrg_finish_cur,
1335	    charge->chrg_term_mode);
1336}
1337
1338static int rk817_charge_get_otg5v_regulator(struct rk817_charger *charge)
1339{
1340	int ret;
1341
1342	charge->otg5v_rdev = devm_regulator_get(charge->dev, "otg_switch");
1343	if (IS_ERR(charge->otg5v_rdev)) {
1344		ret = PTR_ERR(charge->otg5v_rdev);
1345		dev_warn(charge->dev, "failed to get otg regulator: %d\n", ret);
1346	}
1347
1348	return 0;
1349}
1350
1351#ifdef CONFIG_OF
1352static int rk817_charge_parse_dt(struct rk817_charger *charge)
1353{
1354	struct charger_platform_data *pdata;
1355	enum of_gpio_flags flags;
1356	struct device *dev = charge->dev;
1357	struct device_node *np = charge->dev->of_node;
1358	int ret;
1359
1360	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1361	if (!pdata)
1362		return -ENOMEM;
1363
1364	charge->pdata = pdata;
1365	pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1366	pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1367	pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1368	pdata->min_input_voltage = DEFAULT_INPUT_VOLTAGE;
1369	pdata->chrg_finish_cur = DEFAULT_CHRG_TERM_CUR;
1370	pdata->chrg_term_mode = DEFAULT_CHRG_TERM_MODE;
1371
1372	pdata->extcon = of_property_read_bool(np, "extcon");
1373
1374	ret = of_property_read_u32(np, "max_chrg_current",
1375				   &pdata->max_chrg_current);
1376	if (ret < 0)
1377		dev_err(dev, "max_chrg_current missing!\n");
1378
1379	ret = of_property_read_u32(np, "max_input_current",
1380				   &pdata->max_input_current);
1381	if (ret < 0)
1382		dev_err(dev, "max_input_current missing!\n");
1383
1384	ret = of_property_read_u32(np, "max_chrg_voltage",
1385				   &pdata->max_chrg_voltage);
1386	if (ret < 0)
1387		dev_err(dev, "max_chrg_voltage missing!\n");
1388
1389	ret = of_property_read_u32(np, "min_input_voltage",
1390				   &pdata->min_input_voltage);
1391	if (ret < 0)
1392		dev_WARN(dev, "min_input_voltage missing!\n");
1393
1394	ret = of_property_read_u32(np, "chrg_finish_cur",
1395				   &pdata->chrg_finish_cur);
1396
1397	if (ret < 0)
1398		dev_WARN(dev, "chrg_term_mode missing!\n");
1399
1400	ret = of_property_read_u32(np, "chrg_term_mode",
1401				   &pdata->chrg_term_mode);
1402	if (ret < 0)
1403		dev_WARN(dev, "chrg_term_mode missing!\n");
1404
1405	ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1406	if (ret < 0)
1407		dev_err(dev, "virtual_power missing!\n");
1408
1409	ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1410	if (ret < 0)
1411		dev_err(dev, "power_dc2otg missing!\n");
1412
1413	ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1414	if (ret < 0) {
1415		pdata->sample_res = SAMPLE_RES_10MR;
1416		dev_err(dev, "sample_res missing!\n");
1417	}
1418
1419	ret = of_property_read_u32(np, "otg5v_suspend_enable",
1420				   &pdata->otg5v_suspend_enable);
1421	if (ret < 0) {
1422		pdata->otg5v_suspend_enable = 1;
1423		dev_err(dev, "otg5v_suspend_enable missing!\n");
1424	}
1425
1426	ret = of_property_read_u32(np, "gate_function_disable",
1427				   &pdata->gate_function_disable);
1428	if (ret < 0)
1429		dev_err(dev, "gate_function_disable missing!\n");
1430
1431	if (!is_battery_exist(charge))
1432		pdata->virtual_power = 1;
1433
1434	charge->res_div = (charge->pdata->sample_res == SAMPLE_RES_10MR) ?
1435		       SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1436
1437	if (!of_find_property(np, "dc_det_gpio", &ret)) {
1438		pdata->support_dc_det = false;
1439		DBG("not support dc\n");
1440	} else {
1441		pdata->support_dc_det = true;
1442		pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1443							    0, &flags);
1444		if (gpio_is_valid(pdata->dc_det_pin)) {
1445			DBG("support dc\n");
1446			pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1447					       0 : 1;
1448		} else {
1449			dev_err(dev, "invalid dc det gpio!\n");
1450			return -EINVAL;
1451		}
1452	}
1453
1454	DBG("input_current:%d\n"
1455		"input_min_voltage: %d\n"
1456	    "chrg_current:%d\n"
1457	    "chrg_voltage:%d\n"
1458	    "sample_res:%d\n"
1459	    "extcon:%d\n"
1460	    "virtual_power:%d\n"
1461	    "power_dc2otg:%d\n",
1462	    pdata->max_input_current, pdata->min_input_voltage,
1463	    pdata->max_chrg_current,  pdata->max_chrg_voltage,
1464	    pdata->sample_res, pdata->extcon,
1465	    pdata->virtual_power, pdata->power_dc2otg);
1466
1467	return 0;
1468}
1469#else
1470static int rk817_charge_parse_dt(struct rk817_charger *charge)
1471{
1472	return -ENODEV;
1473}
1474#endif
1475
1476static void rk817_charge_irq_delay_work(struct work_struct *work)
1477{
1478	struct rk817_charger *charge = container_of(work,
1479			struct rk817_charger, irq_work.work);
1480
1481	if (charge->plugin_trigger) {
1482		DBG("pmic: plug in\n");
1483		charge->plugin_trigger = 0;
1484		if (charge->pdata->extcon)
1485			queue_delayed_work(charge->usb_charger_wq, &charge->usb_work,
1486					   msecs_to_jiffies(10));
1487	} else if (charge->plugout_trigger) {
1488		DBG("pmic: plug out\n");
1489		charge->plugout_trigger = 0;
1490		rk817_charge_set_chrg_param(charge, USB_TYPE_NONE_CHARGER);
1491		rk817_charge_set_chrg_param(charge, DC_TYPE_NONE_CHARGER);
1492	} else {
1493		DBG("pmic: unknown irq\n");
1494	}
1495}
1496
1497static irqreturn_t rk817_plug_in_isr(int irq, void *cg)
1498{
1499	struct rk817_charger *charge;
1500
1501	charge = (struct rk817_charger *)cg;
1502	charge->plugin_trigger = 1;
1503	queue_delayed_work(charge->usb_charger_wq, &charge->irq_work,
1504			   msecs_to_jiffies(10));
1505
1506	return IRQ_HANDLED;
1507}
1508
1509static irqreturn_t rk817_plug_out_isr(int irq, void *cg)
1510{
1511	struct rk817_charger *charge;
1512
1513	charge = (struct rk817_charger *)cg;
1514	charge->plugout_trigger = 1;
1515	queue_delayed_work(charge->usb_charger_wq, &charge->irq_work,
1516			   msecs_to_jiffies(10));
1517
1518	return IRQ_HANDLED;
1519}
1520
1521static int rk817_charge_init_irqs(struct rk817_charger *charge)
1522{
1523	struct rk808 *rk817 = charge->rk817;
1524	struct platform_device *pdev = charge->pdev;
1525	int ret, plug_in_irq, plug_out_irq;
1526
1527	plug_in_irq = regmap_irq_get_virq(rk817->irq_data, RK817_IRQ_PLUG_IN);
1528	if (plug_in_irq < 0) {
1529		dev_err(charge->dev, "plug_in_irq request failed!\n");
1530		return plug_in_irq;
1531	}
1532
1533	plug_out_irq = regmap_irq_get_virq(rk817->irq_data, RK817_IRQ_PLUG_OUT);
1534	if (plug_out_irq < 0) {
1535		dev_err(charge->dev, "plug_out_irq request failed!\n");
1536		return plug_out_irq;
1537	}
1538
1539	ret = devm_request_threaded_irq(charge->dev, plug_in_irq, NULL,
1540					rk817_plug_in_isr,
1541					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1542					"rk817_plug_in", charge);
1543	if (ret) {
1544		dev_err(&pdev->dev, "plug_in_irq request failed!\n");
1545		return ret;
1546	}
1547
1548	ret = devm_request_threaded_irq(charge->dev, plug_out_irq, NULL,
1549					rk817_plug_out_isr,
1550					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1551					"rk817_plug_out", charge);
1552	if (ret) {
1553		dev_err(&pdev->dev, "plug_out_irq request failed!\n");
1554		return ret;
1555	}
1556
1557	charge->plugin_irq = plug_in_irq;
1558	charge->plugout_irq = plug_out_irq;
1559
1560	INIT_DELAYED_WORK(&charge->irq_work, rk817_charge_irq_delay_work);
1561
1562	return 0;
1563}
1564
1565static const struct of_device_id rk817_charge_of_match[] = {
1566	{ .compatible = "rk817,charger", },
1567	{ },
1568};
1569
1570static int rk817_charge_probe(struct platform_device *pdev)
1571{
1572	struct rk808 *rk817 = dev_get_drvdata(pdev->dev.parent);
1573	const struct of_device_id *of_id =
1574			of_match_device(rk817_charge_of_match, &pdev->dev);
1575	struct i2c_client *client = rk817->i2c;
1576	struct rk817_charger *charge;
1577	int i;
1578	int ret;
1579
1580	if (!of_id) {
1581		dev_err(&pdev->dev, "Failed to find matching dt id\n");
1582		return -ENODEV;
1583	}
1584
1585	charge = devm_kzalloc(&pdev->dev, sizeof(*charge), GFP_KERNEL);
1586	if (!charge)
1587		return -EINVAL;
1588
1589	charge->rk817 = rk817;
1590	charge->pdev = pdev;
1591	charge->dev = &pdev->dev;
1592	charge->client = client;
1593	platform_set_drvdata(pdev, charge);
1594
1595	charge->regmap = rk817->regmap;
1596	if (IS_ERR(charge->regmap)) {
1597		dev_err(charge->dev, "Failed to initialize regmap\n");
1598		return -EINVAL;
1599	}
1600
1601	for (i = 0; i < ARRAY_SIZE(rk817_charge_reg_fields); i++) {
1602		const struct reg_field *reg_fields = rk817_charge_reg_fields;
1603
1604		charge->rmap_fields[i] =
1605			devm_regmap_field_alloc(charge->dev,
1606						charge->regmap,
1607						reg_fields[i]);
1608		if (IS_ERR(charge->rmap_fields[i])) {
1609			dev_err(charge->dev, "cannot allocate regmap field\n");
1610			return PTR_ERR(charge->rmap_fields[i]);
1611		}
1612	}
1613
1614	ret = rk817_charge_parse_dt(charge);
1615	if (ret < 0) {
1616		dev_err(charge->dev, "charge parse dt failed!\n");
1617		return ret;
1618	}
1619	rk817_charge_get_otg5v_regulator(charge);
1620
1621	rk817_charge_pre_init(charge);
1622
1623	ret = rk817_charge_init_power_supply(charge);
1624	if (ret) {
1625		dev_err(charge->dev, "init power supply fail!\n");
1626		return ret;
1627	}
1628
1629	ret = rk817_charge_init_dc(charge);
1630	if (ret) {
1631		dev_err(charge->dev, "init dc failed!\n");
1632		return ret;
1633	}
1634
1635	ret = rk817_charge_usb_init(charge);
1636	if (ret) {
1637		dev_err(charge->dev, "init usb failed!\n");
1638		return ret;
1639	}
1640
1641	ret = rk817_charge_init_irqs(charge);
1642	if (ret) {
1643		dev_err(charge->dev, "init irqs failed!\n");
1644		goto irq_fail;
1645	}
1646
1647	if (charge->pdata->extcon) {
1648		schedule_delayed_work(&charge->host_work, 0);
1649		schedule_delayed_work(&charge->usb_work, 0);
1650	}
1651
1652	rk817_chage_debug(charge);
1653	DBG("driver version: %s\n", CHARGE_DRIVER_VERSION);
1654
1655	return 0;
1656irq_fail:
1657	if (charge->pdata->extcon) {
1658		cancel_delayed_work_sync(&charge->host_work);
1659		cancel_delayed_work_sync(&charge->discnt_work);
1660	}
1661
1662	cancel_delayed_work_sync(&charge->usb_work);
1663	cancel_delayed_work_sync(&charge->dc_work);
1664	cancel_delayed_work_sync(&charge->irq_work);
1665	destroy_workqueue(charge->usb_charger_wq);
1666	destroy_workqueue(charge->dc_charger_wq);
1667
1668	if (charge->pdata->extcon) {
1669		extcon_unregister_notifier(charge->cable_edev,
1670					   EXTCON_CHG_USB_SDP,
1671					   &charge->cable_cg_nb);
1672		extcon_unregister_notifier(charge->cable_edev,
1673					   EXTCON_CHG_USB_DCP,
1674					   &charge->cable_cg_nb);
1675		extcon_unregister_notifier(charge->cable_edev,
1676					   EXTCON_CHG_USB_CDP,
1677					   &charge->cable_cg_nb);
1678		extcon_unregister_notifier(charge->cable_edev,
1679					   EXTCON_USB_VBUS_EN,
1680					   &charge->cable_host_nb);
1681		extcon_unregister_notifier(charge->cable_edev,
1682					   EXTCON_USB,
1683					   &charge->cable_discnt_nb);
1684	} else {
1685		rk_bc_detect_notifier_unregister(&charge->bc_nb);
1686	}
1687
1688	return ret;
1689}
1690
1691#ifdef CONFIG_PM_SLEEP
1692static int  rk817_charge_pm_suspend(struct device *dev)
1693{
1694	struct platform_device *pdev = to_platform_device(dev);
1695	struct rk817_charger *charge = dev_get_drvdata(&pdev->dev);
1696
1697	charge->otg_slp_state = rk817_charge_get_otg_slp_state(charge);
1698
1699	/* enable sleep boost5v and otg5v */
1700	if (charge->pdata->otg5v_suspend_enable) {
1701		if ((charge->otg_in && !charge->dc_in) ||
1702		    (charge->otg_in && charge->dc_in &&
1703		    !charge->pdata->power_dc2otg)) {
1704			rk817_charge_otg_slp_enable(charge);
1705			DBG("suspend: otg 5v on\n");
1706			return 0;
1707		}
1708	}
1709
1710	/* disable sleep otg5v */
1711	rk817_charge_otg_slp_disable(charge);
1712	DBG("suspend: otg 5v off\n");
1713	return 0;
1714}
1715
1716static int rk817_charge_pm_resume(struct device *dev)
1717{
1718	struct platform_device *pdev = to_platform_device(dev);
1719	struct rk817_charger *charge = dev_get_drvdata(&pdev->dev);
1720
1721	/* resume sleep boost5v and otg5v */
1722	if (charge->otg_slp_state)
1723		rk817_charge_otg_slp_enable(charge);
1724
1725	return 0;
1726}
1727#endif
1728static SIMPLE_DEV_PM_OPS(rk817_charge_pm_ops,
1729	rk817_charge_pm_suspend, rk817_charge_pm_resume);
1730
1731static void rk817_charger_shutdown(struct platform_device *dev)
1732{
1733	struct rk817_charger *charge =  platform_get_drvdata(dev);
1734
1735	/* type-c only */
1736	if (charge->pdata->extcon) {
1737		cancel_delayed_work_sync(&charge->host_work);
1738		cancel_delayed_work_sync(&charge->discnt_work);
1739	}
1740
1741	rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF);
1742	rk817_charge_boost_disable(charge);
1743	disable_irq(charge->plugin_irq);
1744	disable_irq(charge->plugout_irq);
1745
1746	cancel_delayed_work_sync(&charge->usb_work);
1747	cancel_delayed_work_sync(&charge->dc_work);
1748	cancel_delayed_work_sync(&charge->irq_work);
1749	flush_workqueue(charge->usb_charger_wq);
1750	flush_workqueue(charge->dc_charger_wq);
1751
1752	if (charge->pdata->extcon) {
1753		extcon_unregister_notifier(charge->cable_edev,
1754					   EXTCON_CHG_USB_SDP,
1755					   &charge->cable_cg_nb);
1756		extcon_unregister_notifier(charge->cable_edev,
1757					   EXTCON_CHG_USB_DCP,
1758					   &charge->cable_cg_nb);
1759		extcon_unregister_notifier(charge->cable_edev,
1760					   EXTCON_CHG_USB_CDP,
1761					   &charge->cable_cg_nb);
1762		extcon_unregister_notifier(charge->cable_edev,
1763					   EXTCON_USB_VBUS_EN,
1764					   &charge->cable_host_nb);
1765		extcon_unregister_notifier(charge->cable_edev, EXTCON_USB,
1766					   &charge->cable_discnt_nb);
1767	} else {
1768		rk_bc_detect_notifier_unregister(&charge->bc_nb);
1769	}
1770
1771	DBG("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1772	    charge->ac_in, charge->usb_in, charge->dc_in, charge->otg_in);
1773}
1774
1775static struct platform_driver rk817_charge_driver = {
1776	.probe = rk817_charge_probe,
1777	.shutdown = rk817_charger_shutdown,
1778	.driver = {
1779		.name = "rk817-charger",
1780		.pm = &rk817_charge_pm_ops,
1781		.of_match_table = of_match_ptr(rk817_charge_of_match),
1782	},
1783};
1784
1785static int __init rk817_charge_init(void)
1786{
1787	return platform_driver_register(&rk817_charge_driver);
1788}
1789fs_initcall_sync(rk817_charge_init);
1790
1791static void __exit rk817_charge_exit(void)
1792{
1793	platform_driver_unregister(&rk817_charge_driver);
1794}
1795module_exit(rk817_charge_exit);
1796
1797MODULE_DESCRIPTION("RK817 Charge driver");
1798MODULE_LICENSE("GPL");
1799