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