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
37 static int dbg_enable;
38 module_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
76 enum 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
87 enum 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
98 enum 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
109 enum 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
120 enum charge_clk {
121 CHRG_CLK_1M,
122 CHRG_CLK_2M,
123 };
124
125 enum charge_term_sel {
126 CHRG_TERM_150MA,
127 CHRG_TERM_200MA,
128 CHRG_TERM_300MA,
129 CHRG_TERM_400MA,
130 };
131
132 enum 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
143 enum 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
154 enum 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
165 enum discharge_ilimit {
166 DISCHRG_2000MA,
167 DISCHRG_2500MA,
168 DISCHRG_3000MA,
169 DISCHRG_3500MA,
170 DISCHRG_4000MA,
171 };
172
173 enum bat_system_comp_time {
174 DLY_20US,
175 DLY_10US,
176 DLY_40US,
177 DLY_20US_AGAIN,
178 };
179
180 enum charge_term_mode {
181 CHRG_ANALOG,
182 CHRG_DIGITAL,
183 };
184
185 enum 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
195 enum charger_state {
196 OFFLINE = 0,
197 ONLINE
198 };
199
200 enum 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
218 static 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
267 struct 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
288 struct 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
338 static 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
345 static 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
rk817_charge_ac_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)352 static 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
rk817_charge_usb_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)390 static 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
428 static 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
436 static 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
rk817_charge_init_power_supply(struct rk817_charger * charge)444 static 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
rk817_charge_field_read(struct rk817_charger * charge,enum rk817_charge_fields field_id)466 static 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
rk817_charge_field_write(struct rk817_charger * charge,enum rk817_charge_fields field_id,unsigned int val)479 static 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
rk817_charge_get_otg_state(struct rk817_charger * charge)486 static int rk817_charge_get_otg_state(struct rk817_charger *charge)
487 {
488 return regulator_is_enabled(charge->otg5v_rdev);
489 }
490
rk817_charge_boost_disable(struct rk817_charger * charge)491 static void rk817_charge_boost_disable(struct rk817_charger *charge)
492 {
493 rk817_charge_field_write(charge, BOOST_EN, RK817_BOOST_DISABLE);
494 }
495
rk817_charge_boost_enable(struct rk817_charger * charge)496 static void rk817_charge_boost_enable(struct rk817_charger *charge)
497 {
498 rk817_charge_field_write(charge, BOOST_EN, RK817_BOOST_ENABLE);
499 }
500
rk817_charge_otg_disable(struct rk817_charger * charge)501 static 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
rk817_charge_otg_enable(struct rk817_charger * charge)515 static 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
rk817_charge_get_otg_slp_state(struct rk817_charger * charge)530 static 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
rk817_charge_otg_slp_disable(struct rk817_charger * charge)535 static 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
rk817_charge_otg_slp_enable(struct rk817_charger * charge)540 static 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
rk817_charge_get_charge_state(struct rk817_charger * charge)546 static int rk817_charge_get_charge_state(struct rk817_charger *charge)
547 {
548 return rk817_charge_field_read(charge, CHRG_EN);
549 }
550
rk817_charge_enable_charge(struct rk817_charger * charge)551 static void rk817_charge_enable_charge(struct rk817_charger *charge)
552 {
553 rk817_charge_field_write(charge, CHRG_EN, ENABLE);
554 }
555
rk817_charge_usb_to_sys_enable(struct rk817_charger * charge)556 static void rk817_charge_usb_to_sys_enable(struct rk817_charger *charge)
557 {
558 rk817_charge_field_write(charge, USB_SYS_EN, ENABLE);
559 }
560
rk817_charge_sys_can_sd_disable(struct rk817_charger * charge)561 static void rk817_charge_sys_can_sd_disable(struct rk817_charger *charge)
562 {
563 rk817_charge_field_write(charge, SYS_CAN_SD, DISABLE);
564 }
565
rk817_charge_get_charge_status(struct rk817_charger * charge)566 static 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
rk817_charge_get_plug_in_status(struct rk817_charger * charge)604 static int rk817_charge_get_plug_in_status(struct rk817_charger *charge)
605 {
606 return rk817_charge_field_read(charge, PLUG_IN_STS);
607 }
608
rk817_charge_set_charge_clock(struct rk817_charger * charge,enum charge_clk clock)609 static 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
is_battery_exist(struct rk817_charger * charge)615 static int is_battery_exist(struct rk817_charger *charge)
616 {
617 return rk817_charge_field_read(charge, BAT_EXS);
618 }
619
rk817_charge_set_chrg_voltage(struct rk817_charger * charge,int chrg_vol)620 static 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
rk817_charge_set_chrg_current(struct rk817_charger * charge,int chrg_current)635 static 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
rk817_charge_vlimit_enable(struct rk817_charger * charge)657 static void rk817_charge_vlimit_enable(struct rk817_charger *charge)
658 {
659 rk817_charge_field_write(charge, USB_VLIM_EN, ENABLE);
660 }
661
rk817_charge_set_input_voltage(struct rk817_charger * charge,int input_voltage)662 static 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
rk817_charge_ilimit_enable(struct rk817_charger * charge)676 static void rk817_charge_ilimit_enable(struct rk817_charger *charge)
677 {
678 rk817_charge_field_write(charge, USB_ILIM_EN, ENABLE);
679 }
680
rk817_charge_set_input_current(struct rk817_charger * charge,int input_current)681 static 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
rk817_charge_set_chrg_term_mod(struct rk817_charger * charge,int mode)715 static 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
rk817_charge_set_term_current_analog(struct rk817_charger * charge,int chrg_current)721 static 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
rk817_charge_set_term_current_digital(struct rk817_charger * charge,int chrg_current)740 static 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
rk817_charge_set_chrg_finish_condition(struct rk817_charger * charge)753 static 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
rk817_charge_online(struct rk817_charger * charge)765 static int rk817_charge_online(struct rk817_charger *charge)
766 {
767 return (charge->ac_in | charge->usb_in | charge->dc_in);
768 }
769
rk817_charge_get_dsoc(struct rk817_charger * charge)770 static 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
rk817_charge_set_otg_in(struct rk817_charger * charge,int online)781 static void rk817_charge_set_otg_in(struct rk817_charger *charge, int online)
782 {
783 charge->otg_in = online;
784 }
785
rk817_charge_set_chrg_param(struct rk817_charger * charge,enum charger_t charger)786 static 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
rk817_charge_set_otg_state(struct rk817_charger * charge,int state)855 static 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
rk817_charge_dc_det_isr(int irq,void * charger)899 static 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
rk817_charge_get_dc_state(struct rk817_charger * charge)914 static 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
rk817_charge_dc_det_worker(struct work_struct * work)927 static 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
rk817_charge_init_dc(struct rk817_charger * charge)954 static 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
rk817_charge_host_evt_worker(struct work_struct * work)1011 static 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
rk817_charger_evt_worker(struct work_struct * work)1036 static 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
rk817_charge_discnt_evt_worker(struct work_struct * work)1061 static 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
rk817_charge_bc_evt_worker(struct work_struct * work)1073 static 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
rk817_charger_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)1111 static 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
rk817_charge_host_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)1123 static 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
rk817_charge_discnt_evt_notfier(struct notifier_block * nb,unsigned long event,void * ptr)1135 static 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
rk817_charge_bc_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)1147 static 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
rk817_charge_usb_init(struct rk817_charger * charge)1160 static 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
rk817_charge_pre_init(struct rk817_charger * charge)1290 static 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
rk817_chage_debug(struct rk817_charger * charge)1319 static 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
rk817_charge_get_otg5v_regulator(struct rk817_charger * charge)1338 static 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
rk817_charge_parse_dt(struct rk817_charger * charge)1352 static 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
rk817_charge_parse_dt(struct rk817_charger * charge)1470 static int rk817_charge_parse_dt(struct rk817_charger *charge)
1471 {
1472 return -ENODEV;
1473 }
1474 #endif
1475
rk817_charge_irq_delay_work(struct work_struct * work)1476 static 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
rk817_plug_in_isr(int irq,void * cg)1497 static 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
rk817_plug_out_isr(int irq,void * cg)1509 static 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
rk817_charge_init_irqs(struct rk817_charger * charge)1521 static 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
1565 static const struct of_device_id rk817_charge_of_match[] = {
1566 { .compatible = "rk817,charger", },
1567 { },
1568 };
1569
rk817_charge_probe(struct platform_device * pdev)1570 static 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;
1656 irq_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
rk817_charge_pm_suspend(struct device * dev)1692 static 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
rk817_charge_pm_resume(struct device * dev)1716 static 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
1728 static SIMPLE_DEV_PM_OPS(rk817_charge_pm_ops,
1729 rk817_charge_pm_suspend, rk817_charge_pm_resume);
1730
rk817_charger_shutdown(struct platform_device * dev)1731 static 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
1775 static 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
rk817_charge_init(void)1785 static int __init rk817_charge_init(void)
1786 {
1787 return platform_driver_register(&rk817_charge_driver);
1788 }
1789 fs_initcall_sync(rk817_charge_init);
1790
rk817_charge_exit(void)1791 static void __exit rk817_charge_exit(void)
1792 {
1793 platform_driver_unregister(&rk817_charge_driver);
1794 }
1795 module_exit(rk817_charge_exit);
1796
1797 MODULE_DESCRIPTION("RK817 Charge driver");
1798 MODULE_LICENSE("GPL");
1799