4 * Copyright (C) 2016 Rockchip Electronics Co., Ltd
5 * chenjh <chenjh@rock-chips.com>
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.
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
18 #include <linux/delay.h>
19 #include <linux/extcon.h>
20 #include <linux/gpio.h>
21 #include <linux/irq.h>
22 #include <linux/irqdomain.h>
23 #include <linux/jiffies.h>
24 #include <linux/kernel.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>
37 static int dbg_enable = 0;
38 module_param_named(dbg_level, dbg_enable, int, 0644);
40 #define DBG(args...) \
47 #define CG_INFO(fmt, args...) pr_info("rk818-charger: "fmt, ##args)
49 #define DEFAULT_CHRG_CURRENT 1400
50 #define DEFAULT_INPUT_CURRENT 2000
51 #define DEFAULT_CHRG_VOLTAGE 4200
52 #define SAMPLE_RES_10MR 10
53 #define SAMPLE_RES_20MR 20
54 #define SAMPLE_RES_DIV1 1
55 #define SAMPLE_RES_DIV2 2
57 /* RK818_USB_CTRL_REG */
58 #define INPUT_CUR450MA (0x00)
59 #define INPUT_CUR1500MA (0x05)
60 #define INPUT_CUR_MSK (0x0f)
61 /* RK818_CHRG_CTRL_REG3 */
62 #define CHRG_FINISH_MODE_MSK BIT(5)
63 #define CHRG_FINISH_ANA_SIGNAL (0)
64 #define CHRG_FINISH_DIG_SIGNAL BIT(5)
65 /* RK818_SUP_STS_REG */
66 #define BAT_EXS BIT(7)
67 #define USB_VLIMIT_EN BIT(3)
68 #define USB_CLIMIT_EN BIT(2)
69 /* RK818_CHRG_CTRL_REG1 */
70 #define CHRG_EN BIT(7)
71 /* RK818_INT_STS_MSK_REG2 */
72 #define CHRG_CVTLMT_INT_MSK BIT(6)
73 #define PLUG_OUT_MSK BIT(1)
74 #define PLUG_IN_MSK BIT(0)
75 /* RK818_VB_MON_REG */
76 #define PLUG_IN_STS BIT(6)
77 /* RK818_TS_CTRL_REG */
80 #define DRIVER_VERSION "1.0"
82 extern void rk_send_wakeup_key(void);
84 static const u16 chrg_vol_sel_array[] = {
85 4050, 4100, 4150, 4200, 4250, 4300, 4350
88 static const u16 chrg_cur_sel_array[] = {
89 1000, 1200, 1400, 1600, 1800, 2000, 2250, 2400, 2600, 2800, 3000
92 static const u16 chrg_cur_input_array[] = {
93 450, 800, 850, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000
97 USB_TYPE_UNKNOWN_CHARGER,
98 USB_TYPE_NONE_CHARGER,
101 USB_TYPE_CDP_CHARGER,
103 DC_TYPE_NONE_CHARGER,
106 struct charger_platform_data {
107 u32 max_input_current;
108 u32 max_chrg_current;
109 u32 max_chrg_voltage;
120 struct rk818_charger {
121 struct platform_device *pdev;
124 struct regmap *regmap;
125 struct power_supply *ac_psy;
126 struct power_supply *usb_psy;
127 struct extcon_dev *cable_edev;
128 struct charger_platform_data *pdata;
129 struct workqueue_struct *usb_charger_wq;
130 struct workqueue_struct *dc_charger_wq;
131 struct workqueue_struct *finish_sig_wq;
132 struct delayed_work dc_work;
133 struct delayed_work usb_work;
134 struct delayed_work host_work;
135 struct delayed_work discnt_work;
136 struct delayed_work finish_sig_work;
137 struct delayed_work irq_work;
138 struct notifier_block bc_nb;
139 struct notifier_block cable_cg_nb;
140 struct notifier_block cable_host_nb;
141 struct notifier_block cable_discnt_nb;
142 unsigned int bc_event;
143 enum charger_t usb_charger;
144 enum charger_t dc_charger;
160 static int rk818_reg_read(struct rk818_charger *cg, u8 reg)
164 ret = regmap_read(cg->regmap, reg, &val);
166 dev_err(cg->dev, "i2c read reg: 0x%2x failed\n", reg);
171 static int rk818_reg_write(struct rk818_charger *cg, u8 reg, u8 buf)
175 ret = regmap_write(cg->regmap, reg, buf);
177 dev_err(cg->dev, "i2c write reg: 0x%2x failed\n", reg);
182 static int rk818_reg_set_bits(struct rk818_charger *cg, u8 reg, u8 mask, u8 buf)
186 ret = regmap_update_bits(cg->regmap, reg, mask, buf);
188 dev_err(cg->dev, "i2c set reg: 0x%2x failed\n", reg);
193 static int rk818_reg_clear_bits(struct rk818_charger *cg, u8 reg, u8 mask)
197 ret = regmap_update_bits(cg->regmap, reg, mask, 0);
199 dev_err(cg->dev, "i2c clr reg: 0x%02x failed\n", reg);
204 static int rk818_cg_online(struct rk818_charger *cg)
206 return (cg->ac_in | cg->usb_in | cg->dc_in);
209 static int rk818_cg_get_dsoc(struct rk818_charger *cg)
211 return rk818_reg_read(cg, RK818_SOC_REG);
214 static int rk818_cg_get_avg_current(struct rk818_charger *cg)
218 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGL) << 0;
219 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGH) << 8;
223 cur = val * cg->res_div * 1506 / 1000;
228 static u64 get_boot_sec(void)
232 get_monotonic_boottime(&ts);
237 static int rk818_cg_lowpwr_check(struct rk818_charger *cg)
241 int current_avg, dsoc, fake_offline = 0;
243 buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
247 dsoc = rk818_cg_get_dsoc(cg);
248 current_avg = rk818_cg_get_avg_current(cg);
249 if ((current_avg < 0) && (dsoc == 0)) {
251 time = get_boot_sec();
252 if ((get_boot_sec() - time) >= 30) {
254 CG_INFO("low power....soc=%d, current=%d\n",
262 DBG("<%s>. t=%lld, dsoc=%d, current=%d, fake_offline=%d\n",
263 __func__, get_boot_sec() - time, dsoc, current_avg, fake_offline);
268 static enum power_supply_property rk818_ac_props[] = {
269 POWER_SUPPLY_PROP_ONLINE,
270 POWER_SUPPLY_PROP_STATUS,
273 static enum power_supply_property rk818_usb_props[] = {
274 POWER_SUPPLY_PROP_ONLINE,
275 POWER_SUPPLY_PROP_STATUS,
278 static int rk818_cg_ac_get_property(struct power_supply *psy,
279 enum power_supply_property psp,
280 union power_supply_propval *val)
282 struct rk818_charger *cg = power_supply_get_drvdata(psy);
283 int fake_offline = 0, ret = 0;
285 if (rk818_cg_online(cg))
286 fake_offline = rk818_cg_lowpwr_check(cg);
289 case POWER_SUPPLY_PROP_ONLINE:
290 if (cg->pdata->virtual_power)
292 else if (fake_offline)
295 val->intval = (cg->ac_in | cg->dc_in);
297 DBG("report online: %d\n", val->intval);
299 case POWER_SUPPLY_PROP_STATUS:
300 if (cg->pdata->virtual_power)
301 val->intval = POWER_SUPPLY_STATUS_CHARGING;
302 else if (fake_offline)
303 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
305 val->intval = cg->prop_status;
307 DBG("report prop: %d\n", val->intval);
317 static int rk818_cg_usb_get_property(struct power_supply *psy,
318 enum power_supply_property psp,
319 union power_supply_propval *val)
321 struct rk818_charger *cg = power_supply_get_drvdata(psy);
322 int fake_offline, ret = 0;
324 if (rk818_cg_online(cg))
325 fake_offline = rk818_cg_lowpwr_check(cg);
328 case POWER_SUPPLY_PROP_ONLINE:
329 if (cg->pdata->virtual_power)
331 else if (fake_offline)
334 val->intval = cg->usb_in;
336 DBG("report online: %d\n", val->intval);
338 case POWER_SUPPLY_PROP_STATUS:
339 if (cg->pdata->virtual_power)
340 val->intval = POWER_SUPPLY_STATUS_CHARGING;
341 else if (fake_offline)
342 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
344 val->intval = cg->prop_status;
346 DBG("report prop: %d\n", val->intval);
356 static const struct power_supply_desc rk818_ac_desc = {
358 .type = POWER_SUPPLY_TYPE_MAINS,
359 .properties = rk818_ac_props,
360 .num_properties = ARRAY_SIZE(rk818_ac_props),
361 .get_property = rk818_cg_ac_get_property,
364 static const struct power_supply_desc rk818_usb_desc = {
366 .type = POWER_SUPPLY_TYPE_USB,
367 .properties = rk818_usb_props,
368 .num_properties = ARRAY_SIZE(rk818_usb_props),
369 .get_property = rk818_cg_usb_get_property,
372 static int rk818_cg_init_power_supply(struct rk818_charger *cg)
374 struct power_supply_config psy_cfg = { .drv_data = cg, };
376 cg->usb_psy = devm_power_supply_register(cg->dev, &rk818_usb_desc,
378 if (IS_ERR(cg->usb_psy)) {
379 dev_err(cg->dev, "register usb power supply fail\n");
380 return PTR_ERR(cg->usb_psy);
383 cg->ac_psy = devm_power_supply_register(cg->dev, &rk818_ac_desc,
385 if (IS_ERR(cg->ac_psy)) {
386 dev_err(cg->dev, "register ac power supply fail\n");
387 return PTR_ERR(cg->ac_psy);
393 static void rk818_cg_pr_info(struct rk818_charger *cg)
395 u8 usb_ctrl, chrg_ctrl1;
397 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
398 chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
399 CG_INFO("ac=%d usb=%d dc=%d otg=%d v=%d chrg=%d input=%d virt=%d\n",
400 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in,
401 chrg_vol_sel_array[(chrg_ctrl1 & 0x70) >> 4],
402 chrg_cur_sel_array[chrg_ctrl1 & 0x0f] * cg->res_div,
403 chrg_cur_input_array[usb_ctrl & 0x0f],
404 cg->pdata->virtual_power);
407 static bool is_battery_exist(struct rk818_charger *cg)
409 return (rk818_reg_read(cg, RK818_SUP_STS_REG) & BAT_EXS) ? true : false;
412 static void rk818_cg_set_input_current(struct rk818_charger *cg,
417 if (cg->pdata->virtual_power) {
418 CG_INFO("warning: virtual power mode...\n");
419 input_current = cg->chrg_input;
422 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
423 usb_ctrl &= ~INPUT_CUR_MSK;
424 usb_ctrl |= (input_current);
425 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
428 static void rk818_cg_set_finish_sig(struct rk818_charger *cg, int mode)
432 buf = rk818_reg_read(cg, RK818_CHRG_CTRL_REG3);
433 buf &= ~CHRG_FINISH_MODE_MSK;
435 rk818_reg_write(cg, RK818_CHRG_CTRL_REG3, buf);
438 static void rk818_cg_finish_sig_work(struct work_struct *work)
440 struct rk818_charger *cg;
442 cg = container_of(work, struct rk818_charger, finish_sig_work.work);
443 if (rk818_cg_online(cg))
444 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
446 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
449 static void rk818_cg_set_chrg_param(struct rk818_charger *cg,
450 enum charger_t charger)
455 case USB_TYPE_NONE_CHARGER:
458 if (cg->dc_in == 0) {
459 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
460 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
462 power_supply_changed(cg->usb_psy);
463 power_supply_changed(cg->ac_psy);
465 case USB_TYPE_USB_CHARGER:
468 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
470 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
471 power_supply_changed(cg->usb_psy);
472 power_supply_changed(cg->ac_psy);
474 case USB_TYPE_AC_CHARGER:
475 case USB_TYPE_CDP_CHARGER:
478 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
479 if (charger == USB_TYPE_AC_CHARGER)
480 rk818_cg_set_input_current(cg, cg->chrg_input);
482 rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
483 power_supply_changed(cg->usb_psy);
484 power_supply_changed(cg->ac_psy);
486 case DC_TYPE_DC_CHARGER:
488 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
489 rk818_cg_set_input_current(cg, cg->chrg_input);
490 power_supply_changed(cg->usb_psy);
491 power_supply_changed(cg->ac_psy);
493 case DC_TYPE_NONE_CHARGER:
495 buf = rk818_reg_read(cg, RK818_VB_MON_REG);
496 if ((buf & PLUG_IN_STS) == 0) {
499 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
500 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
501 } else if (cg->usb_in) {
502 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
503 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
505 power_supply_changed(cg->usb_psy);
506 power_supply_changed(cg->ac_psy);
509 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
513 if (rk818_cg_online(cg) && rk818_cg_get_dsoc(cg) == 100)
514 cg->prop_status = POWER_SUPPLY_STATUS_FULL;
516 if (cg->finish_sig_wq)
517 queue_delayed_work(cg->finish_sig_wq, &cg->finish_sig_work,
518 msecs_to_jiffies(1000));
521 static void rk818_cg_set_otg_state(struct rk818_charger *cg, int state)
524 case USB_OTG_POWER_ON:
526 CG_INFO("otg5v is on yet, ignore..\n");
529 disable_irq(cg->plugin_irq);
530 disable_irq(cg->plugout_irq);
531 rk818_reg_set_bits(cg, RK818_DCDC_EN_REG,
532 OTG_EN_MASK, OTG_EN_MASK);
533 CG_INFO("enable otg5v\n");
536 case USB_OTG_POWER_OFF:
538 CG_INFO("otg5v is off yet, ignore..\n");
541 enable_irq(cg->plugin_irq);
542 enable_irq(cg->plugout_irq);
543 rk818_reg_clear_bits(cg, RK818_DCDC_EN_REG,
545 CG_INFO("disable otg5v\n");
549 dev_err(cg->dev, "error otg type\n");
554 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
558 if (!gpio_is_valid(cg->pdata->dc_det_pin))
559 return DC_TYPE_NONE_CHARGER;
561 level = gpio_get_value(cg->pdata->dc_det_pin);
563 return (level == cg->pdata->dc_det_level) ?
564 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
567 static void rk818_cg_dc_det_worker(struct work_struct *work)
569 enum charger_t charger;
570 struct rk818_charger *cg = container_of(work,
571 struct rk818_charger, dc_work.work);
573 charger = rk818_cg_get_dc_state(cg);
574 if (charger == DC_TYPE_DC_CHARGER) {
575 CG_INFO("detect dc charger in..\n");
576 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
577 /* check otg supply */
578 if (cg->otg_in && cg->pdata->power_dc2otg) {
579 CG_INFO("otg power from dc adapter\n");
580 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
583 CG_INFO("detect dc charger out..\n");
584 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
585 /* check otg supply, power on anyway */
587 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
590 rk_send_wakeup_key();
591 rk818_cg_pr_info(cg);
594 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg)
599 chrg_vol = cg->pdata->max_chrg_voltage;
600 for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
601 if (chrg_vol < chrg_vol_sel_array[index])
606 DBG("<%s>. vol=0x%x\n", __func__, val);
610 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg)
615 input_current = cg->pdata->max_input_current;
616 for (index = 0; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
617 if (input_current < chrg_cur_input_array[index])
622 DBG("<%s>. input=0x%x\n", __func__, val);
626 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg)
631 chrg_current = cg->pdata->max_chrg_current;
632 if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
633 if (chrg_current > 2000)
634 chrg_current /= cg->res_div;
639 for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
640 if (chrg_current < chrg_cur_sel_array[index])
645 DBG("<%s>. sel=0x%x\n", __func__, val);
649 static void rk818_cg_init_config(struct rk818_charger *cg)
651 u8 usb_ctrl, sup_sts, chrg_ctrl1;
653 cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg);
654 cg->chrg_current = rk818_cg_decode_chrg_current(cg);
655 cg->chrg_input = rk818_cg_decode_input_current(cg);
657 sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
658 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
660 /* set charge current and voltage */
661 usb_ctrl &= ~INPUT_CUR_MSK;
662 usb_ctrl |= cg->chrg_input;
663 chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
665 /* disable voltage limit and enable input current limit */
666 sup_sts &= ~USB_VLIMIT_EN;
667 sup_sts |= USB_CLIMIT_EN;
669 rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
670 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
671 rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
674 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
675 unsigned long event, void *ptr)
677 struct rk818_charger *cg =
678 container_of(nb, struct rk818_charger, cable_cg_nb);
680 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
681 msecs_to_jiffies(10));
686 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
687 unsigned long event, void *ptr)
689 struct rk818_charger *cg =
690 container_of(nb, struct rk818_charger, cable_discnt_nb);
692 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
693 msecs_to_jiffies(10));
698 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
699 unsigned long event, void *ptr)
701 struct rk818_charger *cg =
702 container_of(nb, struct rk818_charger, cable_host_nb);
704 queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
705 msecs_to_jiffies(10));
710 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
711 unsigned long event, void *ptr)
713 struct rk818_charger *cg =
714 container_of(nb, struct rk818_charger, bc_nb);
716 cg->bc_event = event;
717 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
718 msecs_to_jiffies(10));
723 static void rk818_cg_bc_evt_worker(struct work_struct *work)
725 struct rk818_charger *cg = container_of(work,
726 struct rk818_charger, usb_work.work);
727 const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
728 "UNKNOWN", "OTG ON", "OTG OFF"};
730 switch (cg->bc_event) {
731 case USB_BC_TYPE_DISCNT:
732 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
734 case USB_BC_TYPE_SDP:
735 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
737 case USB_BC_TYPE_DCP:
738 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
740 case USB_BC_TYPE_CDP:
741 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
743 case USB_OTG_POWER_ON:
744 if (cg->pdata->power_dc2otg && cg->dc_in)
745 CG_INFO("otg power from dc adapter\n");
747 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
749 case USB_OTG_POWER_OFF:
750 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
756 CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
758 rk818_cg_pr_info(cg);
761 static void rk818_cg_irq_delay_work(struct work_struct *work)
763 struct rk818_charger *cg = container_of(work,
764 struct rk818_charger, irq_work.work);
766 if (cg->plugin_trigger) {
767 CG_INFO("pmic: plug in\n");
768 cg->plugin_trigger = 0;
769 rk_send_wakeup_key();
770 } else if (cg->plugout_trigger) {
771 CG_INFO("pmic: plug out\n");
772 cg->plugout_trigger = 0;
773 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
774 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
775 rk_send_wakeup_key();
776 rk818_cg_pr_info(cg);
778 CG_INFO("pmic: unknown irq\n");
782 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
784 struct rk818_charger *icg;
786 icg = (struct rk818_charger *)cg;
787 icg->plugin_trigger = 1;
788 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
789 msecs_to_jiffies(10));
794 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
796 struct rk818_charger *icg;
798 icg = (struct rk818_charger *)cg;
799 icg->plugout_trigger = 1;
800 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
801 msecs_to_jiffies(10));
806 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
808 struct rk818_charger *cg = (struct rk818_charger *)charger;
810 if (gpio_get_value(cg->pdata->dc_det_pin))
811 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
813 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
815 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
816 msecs_to_jiffies(10));
821 static int rk818_cg_init_irqs(struct rk818_charger *cg)
823 struct rk808 *rk818 = cg->rk818;
824 struct platform_device *pdev = cg->pdev;
825 int ret, plug_in_irq, plug_out_irq;
827 plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
828 if (plug_in_irq < 0) {
829 dev_err(cg->dev, "plug_in_irq request failed!\n");
833 plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
834 if (plug_out_irq < 0) {
835 dev_err(cg->dev, "plug_out_irq request failed!\n");
839 ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
842 "rk818_plug_in", cg);
844 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
848 ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
850 IRQF_TRIGGER_FALLING,
851 "rk818_plug_out", cg);
853 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
857 cg->plugin_irq = plug_in_irq;
858 cg->plugout_irq = plug_out_irq;
860 INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
865 static int rk818_cg_init_dc(struct rk818_charger *cg)
868 unsigned long irq_flags;
869 unsigned int dc_det_irq;
871 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
872 WQ_MEM_RECLAIM | WQ_FREEZABLE,
874 INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
875 cg->dc_charger = DC_TYPE_NONE_CHARGER;
877 if (!cg->pdata->support_dc_det)
880 ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
882 dev_err(cg->dev, "failed to request gpio %d\n",
883 cg->pdata->dc_det_pin);
887 ret = gpio_direction_input(cg->pdata->dc_det_pin);
889 dev_err(cg->dev, "failed to set gpio input\n");
893 level = gpio_get_value(cg->pdata->dc_det_pin);
894 if (level == cg->pdata->dc_det_level)
895 cg->dc_charger = DC_TYPE_DC_CHARGER;
897 cg->dc_charger = DC_TYPE_NONE_CHARGER;
900 irq_flags = IRQF_TRIGGER_LOW;
902 irq_flags = IRQF_TRIGGER_HIGH;
904 dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
905 ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
906 irq_flags, "rk818_dc_det", cg);
908 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
912 enable_irq_wake(dc_det_irq);
917 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
919 struct rk818_charger *cg = container_of(work,
920 struct rk818_charger, discnt_work.work);
922 if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
923 CG_INFO("receive type-c notifier event: DISCNT...\n");
924 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
925 rk818_cg_pr_info(cg);
929 static void rk818_cg_host_evt_worker(struct work_struct *work)
931 struct rk818_charger *cg = container_of(work,
932 struct rk818_charger, host_work.work);
933 struct extcon_dev *edev = cg->cable_edev;
935 /* Determine cable/charger type */
936 if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
937 CG_INFO("receive type-c notifier event: OTG ON...\n");
938 if (cg->dc_in && cg->pdata->power_dc2otg)
939 CG_INFO("otg power from dc adapter\n");
941 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
942 } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
943 CG_INFO("receive type-c notifier event: OTG OFF...\n");
944 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
947 rk818_cg_pr_info(cg);
950 static void rk818_cg_charger_evt_worker(struct work_struct *work)
952 struct rk818_charger *cg = container_of(work,
953 struct rk818_charger, usb_work.work);
954 struct extcon_dev *edev = cg->cable_edev;
955 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
956 const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
958 /* Determine cable/charger type */
959 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
960 charger = USB_TYPE_USB_CHARGER;
961 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
962 charger = USB_TYPE_AC_CHARGER;
963 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
964 charger = USB_TYPE_CDP_CHARGER;
966 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
967 CG_INFO("receive type-c notifier event: %s...\n",
969 cg->usb_charger = charger;
970 rk818_cg_set_chrg_param(cg, charger);
971 rk818_cg_pr_info(cg);
975 static long rk818_cg_init_usb(struct rk818_charger *cg)
977 enum charger_t charger;
978 enum bc_port_type bc_type;
979 struct extcon_dev *edev;
980 struct device *dev = cg->dev;
983 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
984 WQ_MEM_RECLAIM | WQ_FREEZABLE,
986 cg->usb_charger = USB_TYPE_NONE_CHARGER;
989 if (cg->pdata->extcon) {
990 edev = extcon_get_edev_by_phandle(dev->parent, 0);
992 if (PTR_ERR(edev) != -EPROBE_DEFER)
993 dev_err(dev, "Invalid or missing extcon\n");
994 return PTR_ERR(edev);
997 /* Register chargers */
998 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
999 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
1000 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
1003 dev_err(dev, "failed to register notifier for SDP\n");
1007 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1010 dev_err(dev, "failed to register notifier for DCP\n");
1011 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1016 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1019 dev_err(dev, "failed to register notifier for CDP\n");
1020 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1022 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1028 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1029 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1030 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
1031 &cg->cable_host_nb);
1033 dev_err(dev, "failed to register notifier for HOST\n");
1034 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1036 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1038 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1044 /* Register discnt usb */
1045 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1046 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1047 ret = extcon_register_notifier(edev, EXTCON_USB,
1048 &cg->cable_discnt_nb);
1050 dev_err(dev, "failed to register notifier for HOST\n");
1051 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1053 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1055 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1057 extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
1058 &cg->cable_host_nb);
1062 cg->cable_edev = edev;
1064 schedule_delayed_work(&cg->host_work, 0);
1065 schedule_delayed_work(&cg->usb_work, 0);
1067 CG_INFO("register typec extcon evt notifier\n");
1069 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1070 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1071 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1073 dev_err(dev, "failed to register notifier for bc\n");
1078 case USB_BC_TYPE_DISCNT:
1079 charger = USB_TYPE_NONE_CHARGER;
1081 case USB_BC_TYPE_SDP:
1082 case USB_BC_TYPE_CDP:
1083 charger = USB_TYPE_USB_CHARGER;
1085 case USB_BC_TYPE_DCP:
1086 charger = USB_TYPE_AC_CHARGER;
1089 charger = USB_TYPE_NONE_CHARGER;
1093 cg->usb_charger = charger;
1094 CG_INFO("register bc evt notifier\n");
1100 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1102 if (rk818_cg_online(cg))
1103 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1105 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1107 cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1108 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1109 "rk818-finish-sig-wq");
1110 INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1113 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1115 rk818_cg_init_config(cg);
1116 rk818_cg_init_finish_sig(cg);
1117 rk818_cg_set_chrg_param(cg, cg->dc_charger);
1118 rk818_cg_set_chrg_param(cg, cg->usb_charger);
1119 CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d\n",
1120 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1124 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1126 struct device_node *np;
1127 struct charger_platform_data *pdata;
1128 enum of_gpio_flags flags;
1129 struct device *dev = cg->dev;
1132 np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1134 dev_err(dev, "battery node not found!\n");
1138 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1143 pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1144 pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1145 pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1147 pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1149 ret = of_property_read_u32(np, "max_chrg_current",
1150 &pdata->max_chrg_current);
1152 dev_err(dev, "max_chrg_current missing!\n");
1154 ret = of_property_read_u32(np, "max_input_current",
1155 &pdata->max_input_current);
1157 dev_err(dev, "max_input_current missing!\n");
1159 ret = of_property_read_u32(np, "max_chrg_voltage",
1160 &pdata->max_chrg_voltage);
1162 dev_err(dev, "max_chrg_voltage missing!\n");
1164 ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1166 dev_err(dev, "virtual_power missing!\n");
1168 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1170 dev_err(dev, "power_dc2otg missing!\n");
1172 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1174 pdata->sample_res = SAMPLE_RES_20MR;
1175 dev_err(dev, "sample_res missing!\n");
1178 if (!is_battery_exist(cg))
1179 pdata->virtual_power = 1;
1181 cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1182 SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1184 if (!of_find_property(np, "dc_det_gpio", &ret)) {
1185 pdata->support_dc_det = false;
1186 CG_INFO("not support dc\n");
1188 pdata->support_dc_det = true;
1189 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1191 if (gpio_is_valid(pdata->dc_det_pin)) {
1192 CG_INFO("support dc\n");
1193 pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1196 dev_err(dev, "invalid dc det gpio!\n");
1201 DBG("input_current:%d\n"
1206 "virtual_power:%d\n"
1207 "power_dc2otg:%d\n",
1208 pdata->max_input_current, pdata->max_chrg_current,
1209 pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1210 pdata->virtual_power, pdata->power_dc2otg);
1215 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1221 static int rk818_charger_probe(struct platform_device *pdev)
1223 struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1224 struct rk818_charger *cg;
1227 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1233 cg->dev = &pdev->dev;
1234 cg->regmap = rk818->regmap;
1235 platform_set_drvdata(pdev, cg);
1237 ret = rk818_cg_parse_dt(cg);
1239 dev_err(cg->dev, "parse dt failed!\n");
1243 ret = rk818_cg_init_irqs(cg);
1245 dev_err(cg->dev, "init irqs failed!\n");
1249 ret = rk818_cg_init_dc(cg);
1251 dev_err(cg->dev, "init dc failed!\n");
1255 ret = rk818_cg_init_usb(cg);
1257 dev_err(cg->dev, "init usb failed!\n");
1261 ret = rk818_cg_init_power_supply(cg);
1263 dev_err(cg->dev, "init power supply fail!\n");
1267 rk818_cg_init_charger_state(cg);
1269 CG_INFO("driver version: %s\n", DRIVER_VERSION);
1274 static void rk818_charger_shutdown(struct platform_device *pdev)
1276 struct rk818_charger *cg = platform_get_drvdata(pdev);
1278 cancel_delayed_work_sync(&cg->host_work);
1279 cancel_delayed_work_sync(&cg->usb_work);
1280 cancel_delayed_work_sync(&cg->discnt_work);
1281 cancel_delayed_work_sync(&cg->dc_work);
1282 cancel_delayed_work_sync(&cg->finish_sig_work);
1283 cancel_delayed_work_sync(&cg->irq_work);
1284 destroy_workqueue(cg->usb_charger_wq);
1285 destroy_workqueue(cg->dc_charger_wq);
1286 destroy_workqueue(cg->finish_sig_wq);
1288 if (cg->pdata->extcon) {
1289 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1291 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1293 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1295 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
1296 &cg->cable_host_nb);
1297 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1298 &cg->cable_discnt_nb);
1300 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1303 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
1304 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1306 CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1307 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1310 static struct platform_driver rk818_charger_driver = {
1311 .probe = rk818_charger_probe,
1312 .shutdown = rk818_charger_shutdown,
1314 .name = "rk818-charger",
1318 static int __init charger_init(void)
1320 return platform_driver_register(&rk818_charger_driver);
1322 module_init(charger_init);
1324 static void __exit charger_exit(void)
1326 platform_driver_unregister(&rk818_charger_driver);
1328 module_exit(charger_exit);
1330 MODULE_LICENSE("GPL");
1331 MODULE_ALIAS("platform:rk818-charger");
1332 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");