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/rk_keys.h>
34 #include <linux/rtc.h>
35 #include <linux/timer.h>
36 #include <linux/workqueue.h>
38 static int dbg_enable = 0;
39 module_param_named(dbg_level, dbg_enable, int, 0644);
41 #define DBG(args...) \
48 #define CG_INFO(fmt, args...) pr_info("rk818-charger: "fmt, ##args)
50 #define DEFAULT_CHRG_CURRENT 1400
51 #define DEFAULT_INPUT_CURRENT 2000
52 #define DEFAULT_CHRG_VOLTAGE 4200
53 #define SAMPLE_RES_10MR 10
54 #define SAMPLE_RES_20MR 20
55 #define SAMPLE_RES_DIV1 1
56 #define SAMPLE_RES_DIV2 2
58 /* RK818_USB_CTRL_REG */
59 #define INPUT_CUR450MA (0x00)
60 #define INPUT_CUR1500MA (0x05)
61 #define INPUT_CUR_MSK (0x0f)
62 /* RK818_CHRG_CTRL_REG3 */
63 #define CHRG_FINISH_MODE_MSK BIT(5)
64 #define CHRG_FINISH_ANA_SIGNAL (0)
65 #define CHRG_FINISH_DIG_SIGNAL BIT(5)
66 /* RK818_SUP_STS_REG */
67 #define BAT_EXS BIT(7)
68 #define USB_VLIMIT_EN BIT(3)
69 #define USB_CLIMIT_EN BIT(2)
70 /* RK818_CHRG_CTRL_REG1 */
71 #define CHRG_EN BIT(7)
72 /* RK818_INT_STS_MSK_REG2 */
73 #define CHRG_CVTLMT_INT_MSK BIT(6)
74 #define PLUG_OUT_MSK BIT(1)
75 #define PLUG_IN_MSK BIT(0)
76 /* RK818_VB_MON_REG */
77 #define PLUG_IN_STS BIT(6)
78 /* RK818_TS_CTRL_REG */
81 #define DRIVER_VERSION "1.0"
83 static const u16 chrg_vol_sel_array[] = {
84 4050, 4100, 4150, 4200, 4250, 4300, 4350
87 static const u16 chrg_cur_sel_array[] = {
88 1000, 1200, 1400, 1600, 1800, 2000, 2250, 2400, 2600, 2800, 3000
91 static const u16 chrg_cur_input_array[] = {
92 450, 800, 850, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000
96 USB_TYPE_UNKNOWN_CHARGER,
97 USB_TYPE_NONE_CHARGER,
100 USB_TYPE_CDP_CHARGER,
102 DC_TYPE_NONE_CHARGER,
105 struct charger_platform_data {
106 u32 max_input_current;
107 u32 max_chrg_current;
108 u32 max_chrg_voltage;
119 struct rk818_charger {
120 struct platform_device *pdev;
123 struct regmap *regmap;
124 struct power_supply *ac_psy;
125 struct power_supply *usb_psy;
126 struct extcon_dev *cable_edev;
127 struct charger_platform_data *pdata;
128 struct workqueue_struct *usb_charger_wq;
129 struct workqueue_struct *dc_charger_wq;
130 struct workqueue_struct *finish_sig_wq;
131 struct delayed_work dc_work;
132 struct delayed_work usb_work;
133 struct delayed_work host_work;
134 struct delayed_work discnt_work;
135 struct delayed_work finish_sig_work;
136 struct delayed_work irq_work;
137 struct notifier_block bc_nb;
138 struct notifier_block cable_cg_nb;
139 struct notifier_block cable_host_nb;
140 struct notifier_block cable_discnt_nb;
141 unsigned int bc_event;
142 enum charger_t usb_charger;
143 enum charger_t dc_charger;
159 static int rk818_reg_read(struct rk818_charger *cg, u8 reg)
163 ret = regmap_read(cg->regmap, reg, &val);
165 dev_err(cg->dev, "i2c read reg: 0x%2x failed\n", reg);
170 static int rk818_reg_write(struct rk818_charger *cg, u8 reg, u8 buf)
174 ret = regmap_write(cg->regmap, reg, buf);
176 dev_err(cg->dev, "i2c write reg: 0x%2x failed\n", reg);
181 static int rk818_reg_set_bits(struct rk818_charger *cg, u8 reg, u8 mask, u8 buf)
185 ret = regmap_update_bits(cg->regmap, reg, mask, buf);
187 dev_err(cg->dev, "i2c set reg: 0x%2x failed\n", reg);
192 static int rk818_reg_clear_bits(struct rk818_charger *cg, u8 reg, u8 mask)
196 ret = regmap_update_bits(cg->regmap, reg, mask, 0);
198 dev_err(cg->dev, "i2c clr reg: 0x%02x failed\n", reg);
203 static int rk818_cg_online(struct rk818_charger *cg)
205 return (cg->ac_in | cg->usb_in | cg->dc_in);
208 static int rk818_cg_get_dsoc(struct rk818_charger *cg)
210 return rk818_reg_read(cg, RK818_SOC_REG);
213 static int rk818_cg_get_avg_current(struct rk818_charger *cg)
217 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGL) << 0;
218 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGH) << 8;
222 cur = val * cg->res_div * 1506 / 1000;
227 static u64 get_boot_sec(void)
231 get_monotonic_boottime(&ts);
236 static int rk818_cg_lowpwr_check(struct rk818_charger *cg)
240 int current_avg, dsoc, fake_offline = 0;
242 buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
246 dsoc = rk818_cg_get_dsoc(cg);
247 current_avg = rk818_cg_get_avg_current(cg);
248 if ((current_avg < 0) && (dsoc == 0)) {
250 time = get_boot_sec();
251 if ((get_boot_sec() - time) >= 30) {
253 CG_INFO("low power....soc=%d, current=%d\n",
261 DBG("<%s>. t=%lld, dsoc=%d, current=%d, fake_offline=%d\n",
262 __func__, get_boot_sec() - time, dsoc, current_avg, fake_offline);
267 static enum power_supply_property rk818_ac_props[] = {
268 POWER_SUPPLY_PROP_ONLINE,
269 POWER_SUPPLY_PROP_STATUS,
272 static enum power_supply_property rk818_usb_props[] = {
273 POWER_SUPPLY_PROP_ONLINE,
274 POWER_SUPPLY_PROP_STATUS,
277 static int rk818_cg_ac_get_property(struct power_supply *psy,
278 enum power_supply_property psp,
279 union power_supply_propval *val)
281 struct rk818_charger *cg = power_supply_get_drvdata(psy);
282 int fake_offline = 0, ret = 0;
284 if (rk818_cg_online(cg))
285 fake_offline = rk818_cg_lowpwr_check(cg);
288 case POWER_SUPPLY_PROP_ONLINE:
289 if (cg->pdata->virtual_power)
291 else if (fake_offline)
294 val->intval = (cg->ac_in | cg->dc_in);
296 DBG("report online: %d\n", val->intval);
298 case POWER_SUPPLY_PROP_STATUS:
299 if (cg->pdata->virtual_power)
300 val->intval = POWER_SUPPLY_STATUS_CHARGING;
301 else if (fake_offline)
302 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
304 val->intval = cg->prop_status;
306 DBG("report prop: %d\n", val->intval);
316 static int rk818_cg_usb_get_property(struct power_supply *psy,
317 enum power_supply_property psp,
318 union power_supply_propval *val)
320 struct rk818_charger *cg = power_supply_get_drvdata(psy);
321 int fake_offline, ret = 0;
323 if (rk818_cg_online(cg))
324 fake_offline = rk818_cg_lowpwr_check(cg);
327 case POWER_SUPPLY_PROP_ONLINE:
328 if (cg->pdata->virtual_power)
330 else if (fake_offline)
333 val->intval = cg->usb_in;
335 DBG("report online: %d\n", val->intval);
337 case POWER_SUPPLY_PROP_STATUS:
338 if (cg->pdata->virtual_power)
339 val->intval = POWER_SUPPLY_STATUS_CHARGING;
340 else if (fake_offline)
341 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
343 val->intval = cg->prop_status;
345 DBG("report prop: %d\n", val->intval);
355 static const struct power_supply_desc rk818_ac_desc = {
357 .type = POWER_SUPPLY_TYPE_MAINS,
358 .properties = rk818_ac_props,
359 .num_properties = ARRAY_SIZE(rk818_ac_props),
360 .get_property = rk818_cg_ac_get_property,
363 static const struct power_supply_desc rk818_usb_desc = {
365 .type = POWER_SUPPLY_TYPE_USB,
366 .properties = rk818_usb_props,
367 .num_properties = ARRAY_SIZE(rk818_usb_props),
368 .get_property = rk818_cg_usb_get_property,
371 static int rk818_cg_init_power_supply(struct rk818_charger *cg)
373 struct power_supply_config psy_cfg = { .drv_data = cg, };
375 cg->usb_psy = devm_power_supply_register(cg->dev, &rk818_usb_desc,
377 if (IS_ERR(cg->usb_psy)) {
378 dev_err(cg->dev, "register usb power supply fail\n");
379 return PTR_ERR(cg->usb_psy);
382 cg->ac_psy = devm_power_supply_register(cg->dev, &rk818_ac_desc,
384 if (IS_ERR(cg->ac_psy)) {
385 dev_err(cg->dev, "register ac power supply fail\n");
386 return PTR_ERR(cg->ac_psy);
392 static void rk818_cg_pr_info(struct rk818_charger *cg)
394 u8 usb_ctrl, chrg_ctrl1;
396 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
397 chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
398 CG_INFO("ac=%d usb=%d dc=%d otg=%d v=%d chrg=%d input=%d virt=%d\n",
399 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in,
400 chrg_vol_sel_array[(chrg_ctrl1 & 0x70) >> 4],
401 chrg_cur_sel_array[chrg_ctrl1 & 0x0f] * cg->res_div,
402 chrg_cur_input_array[usb_ctrl & 0x0f],
403 cg->pdata->virtual_power);
406 static bool is_battery_exist(struct rk818_charger *cg)
408 return (rk818_reg_read(cg, RK818_SUP_STS_REG) & BAT_EXS) ? true : false;
411 static void rk818_cg_set_input_current(struct rk818_charger *cg,
416 if (cg->pdata->virtual_power) {
417 CG_INFO("warning: virtual power mode...\n");
418 input_current = cg->chrg_input;
421 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
422 usb_ctrl &= ~INPUT_CUR_MSK;
423 usb_ctrl |= (input_current);
424 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
427 static void rk818_cg_set_finish_sig(struct rk818_charger *cg, int mode)
431 buf = rk818_reg_read(cg, RK818_CHRG_CTRL_REG3);
432 buf &= ~CHRG_FINISH_MODE_MSK;
434 rk818_reg_write(cg, RK818_CHRG_CTRL_REG3, buf);
437 static void rk818_cg_finish_sig_work(struct work_struct *work)
439 struct rk818_charger *cg;
441 cg = container_of(work, struct rk818_charger, finish_sig_work.work);
442 if (rk818_cg_online(cg))
443 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
445 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
448 static void rk818_cg_set_chrg_param(struct rk818_charger *cg,
449 enum charger_t charger)
454 case USB_TYPE_NONE_CHARGER:
457 if (cg->dc_in == 0) {
458 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
459 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
461 power_supply_changed(cg->usb_psy);
462 power_supply_changed(cg->ac_psy);
464 case USB_TYPE_USB_CHARGER:
467 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
469 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
470 power_supply_changed(cg->usb_psy);
471 power_supply_changed(cg->ac_psy);
473 case USB_TYPE_AC_CHARGER:
474 case USB_TYPE_CDP_CHARGER:
477 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
478 if (charger == USB_TYPE_AC_CHARGER)
479 rk818_cg_set_input_current(cg, cg->chrg_input);
481 rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
482 power_supply_changed(cg->usb_psy);
483 power_supply_changed(cg->ac_psy);
485 case DC_TYPE_DC_CHARGER:
487 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
488 rk818_cg_set_input_current(cg, cg->chrg_input);
489 power_supply_changed(cg->usb_psy);
490 power_supply_changed(cg->ac_psy);
492 case DC_TYPE_NONE_CHARGER:
494 buf = rk818_reg_read(cg, RK818_VB_MON_REG);
495 if ((buf & PLUG_IN_STS) == 0) {
498 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
499 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
500 } else if (cg->usb_in) {
501 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
502 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
504 power_supply_changed(cg->usb_psy);
505 power_supply_changed(cg->ac_psy);
508 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
512 if (rk818_cg_online(cg) && rk818_cg_get_dsoc(cg) == 100)
513 cg->prop_status = POWER_SUPPLY_STATUS_FULL;
515 if (cg->finish_sig_wq)
516 queue_delayed_work(cg->finish_sig_wq, &cg->finish_sig_work,
517 msecs_to_jiffies(1000));
520 static void rk818_cg_set_otg_state(struct rk818_charger *cg, int state)
523 case USB_OTG_POWER_ON:
525 CG_INFO("otg5v is on yet, ignore..\n");
528 disable_irq(cg->plugin_irq);
529 disable_irq(cg->plugout_irq);
530 rk818_reg_set_bits(cg, RK818_DCDC_EN_REG,
531 OTG_EN_MASK, OTG_EN_MASK);
532 CG_INFO("enable otg5v\n");
535 case USB_OTG_POWER_OFF:
537 CG_INFO("otg5v is off yet, ignore..\n");
540 enable_irq(cg->plugin_irq);
541 enable_irq(cg->plugout_irq);
542 rk818_reg_clear_bits(cg, RK818_DCDC_EN_REG,
544 CG_INFO("disable otg5v\n");
548 dev_err(cg->dev, "error otg type\n");
553 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
557 if (!gpio_is_valid(cg->pdata->dc_det_pin))
558 return DC_TYPE_NONE_CHARGER;
560 level = gpio_get_value(cg->pdata->dc_det_pin);
562 return (level == cg->pdata->dc_det_level) ?
563 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
566 static void rk818_cg_dc_det_worker(struct work_struct *work)
568 enum charger_t charger;
569 struct rk818_charger *cg = container_of(work,
570 struct rk818_charger, dc_work.work);
572 charger = rk818_cg_get_dc_state(cg);
573 if (charger == DC_TYPE_DC_CHARGER) {
574 CG_INFO("detect dc charger in..\n");
575 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
576 /* check otg supply */
577 if (cg->otg_in && cg->pdata->power_dc2otg) {
578 CG_INFO("otg power from dc adapter\n");
579 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
582 CG_INFO("detect dc charger out..\n");
583 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
584 /* check otg supply, power on anyway */
586 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
589 rk_send_wakeup_key();
590 rk818_cg_pr_info(cg);
593 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg)
598 chrg_vol = cg->pdata->max_chrg_voltage;
599 for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
600 if (chrg_vol < chrg_vol_sel_array[index])
605 DBG("<%s>. vol=0x%x\n", __func__, val);
609 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg)
614 input_current = cg->pdata->max_input_current;
615 for (index = 0; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
616 if (input_current < chrg_cur_input_array[index])
621 DBG("<%s>. input=0x%x\n", __func__, val);
625 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg)
630 chrg_current = cg->pdata->max_chrg_current;
631 if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
632 if (chrg_current > 2000)
633 chrg_current /= cg->res_div;
638 for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
639 if (chrg_current < chrg_cur_sel_array[index])
644 DBG("<%s>. sel=0x%x\n", __func__, val);
648 static void rk818_cg_init_config(struct rk818_charger *cg)
650 u8 usb_ctrl, sup_sts, chrg_ctrl1;
652 cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg);
653 cg->chrg_current = rk818_cg_decode_chrg_current(cg);
654 cg->chrg_input = rk818_cg_decode_input_current(cg);
656 sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
657 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
659 /* set charge current and voltage */
660 usb_ctrl &= ~INPUT_CUR_MSK;
661 usb_ctrl |= cg->chrg_input;
662 chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
664 /* disable voltage limit and enable input current limit */
665 sup_sts &= ~USB_VLIMIT_EN;
666 sup_sts |= USB_CLIMIT_EN;
668 rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
669 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
670 rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
673 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
674 unsigned long event, void *ptr)
676 struct rk818_charger *cg =
677 container_of(nb, struct rk818_charger, cable_cg_nb);
679 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
680 msecs_to_jiffies(10));
685 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
686 unsigned long event, void *ptr)
688 struct rk818_charger *cg =
689 container_of(nb, struct rk818_charger, cable_discnt_nb);
691 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
692 msecs_to_jiffies(10));
697 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
698 unsigned long event, void *ptr)
700 struct rk818_charger *cg =
701 container_of(nb, struct rk818_charger, cable_host_nb);
703 queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
704 msecs_to_jiffies(10));
709 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
710 unsigned long event, void *ptr)
712 struct rk818_charger *cg =
713 container_of(nb, struct rk818_charger, bc_nb);
715 cg->bc_event = event;
716 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
717 msecs_to_jiffies(10));
722 static void rk818_cg_bc_evt_worker(struct work_struct *work)
724 struct rk818_charger *cg = container_of(work,
725 struct rk818_charger, usb_work.work);
726 const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
727 "UNKNOWN", "OTG ON", "OTG OFF"};
729 switch (cg->bc_event) {
730 case USB_BC_TYPE_DISCNT:
731 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
733 case USB_BC_TYPE_SDP:
734 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
736 case USB_BC_TYPE_DCP:
737 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
739 case USB_BC_TYPE_CDP:
740 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
742 case USB_OTG_POWER_ON:
743 if (cg->pdata->power_dc2otg && cg->dc_in)
744 CG_INFO("otg power from dc adapter\n");
746 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
748 case USB_OTG_POWER_OFF:
749 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
755 CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
757 rk818_cg_pr_info(cg);
760 static void rk818_cg_irq_delay_work(struct work_struct *work)
762 struct rk818_charger *cg = container_of(work,
763 struct rk818_charger, irq_work.work);
765 if (cg->plugin_trigger) {
766 CG_INFO("pmic: plug in\n");
767 cg->plugin_trigger = 0;
768 rk_send_wakeup_key();
769 } else if (cg->plugout_trigger) {
770 CG_INFO("pmic: plug out\n");
771 cg->plugout_trigger = 0;
772 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
773 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
774 rk_send_wakeup_key();
775 rk818_cg_pr_info(cg);
777 CG_INFO("pmic: unknown irq\n");
781 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
783 struct rk818_charger *icg;
785 icg = (struct rk818_charger *)cg;
786 icg->plugin_trigger = 1;
787 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
788 msecs_to_jiffies(10));
793 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
795 struct rk818_charger *icg;
797 icg = (struct rk818_charger *)cg;
798 icg->plugout_trigger = 1;
799 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
800 msecs_to_jiffies(10));
805 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
807 struct rk818_charger *cg = (struct rk818_charger *)charger;
809 if (gpio_get_value(cg->pdata->dc_det_pin))
810 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
812 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
814 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
815 msecs_to_jiffies(10));
820 static int rk818_cg_init_irqs(struct rk818_charger *cg)
822 struct rk808 *rk818 = cg->rk818;
823 struct platform_device *pdev = cg->pdev;
824 int ret, plug_in_irq, plug_out_irq;
826 plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
827 if (plug_in_irq < 0) {
828 dev_err(cg->dev, "plug_in_irq request failed!\n");
832 plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
833 if (plug_out_irq < 0) {
834 dev_err(cg->dev, "plug_out_irq request failed!\n");
838 ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
841 "rk818_plug_in", cg);
843 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
847 ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
849 IRQF_TRIGGER_FALLING,
850 "rk818_plug_out", cg);
852 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
856 cg->plugin_irq = plug_in_irq;
857 cg->plugout_irq = plug_out_irq;
859 INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
864 static int rk818_cg_init_dc(struct rk818_charger *cg)
867 unsigned long irq_flags;
868 unsigned int dc_det_irq;
870 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
871 WQ_MEM_RECLAIM | WQ_FREEZABLE,
873 INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
874 cg->dc_charger = DC_TYPE_NONE_CHARGER;
876 if (!cg->pdata->support_dc_det)
879 ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
881 dev_err(cg->dev, "failed to request gpio %d\n",
882 cg->pdata->dc_det_pin);
886 ret = gpio_direction_input(cg->pdata->dc_det_pin);
888 dev_err(cg->dev, "failed to set gpio input\n");
892 level = gpio_get_value(cg->pdata->dc_det_pin);
893 if (level == cg->pdata->dc_det_level)
894 cg->dc_charger = DC_TYPE_DC_CHARGER;
896 cg->dc_charger = DC_TYPE_NONE_CHARGER;
899 irq_flags = IRQF_TRIGGER_LOW;
901 irq_flags = IRQF_TRIGGER_HIGH;
903 dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
904 ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
905 irq_flags, "rk818_dc_det", cg);
907 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
911 enable_irq_wake(dc_det_irq);
916 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
918 struct rk818_charger *cg = container_of(work,
919 struct rk818_charger, discnt_work.work);
921 if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
922 CG_INFO("receive type-c notifier event: DISCNT...\n");
923 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
924 rk818_cg_pr_info(cg);
928 static void rk818_cg_host_evt_worker(struct work_struct *work)
930 struct rk818_charger *cg = container_of(work,
931 struct rk818_charger, host_work.work);
932 struct extcon_dev *edev = cg->cable_edev;
934 /* Determine cable/charger type */
935 if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
936 CG_INFO("receive type-c notifier event: OTG ON...\n");
937 if (cg->dc_in && cg->pdata->power_dc2otg)
938 CG_INFO("otg power from dc adapter\n");
940 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
941 } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
942 CG_INFO("receive type-c notifier event: OTG OFF...\n");
943 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
946 rk818_cg_pr_info(cg);
949 static void rk818_cg_charger_evt_worker(struct work_struct *work)
951 struct rk818_charger *cg = container_of(work,
952 struct rk818_charger, usb_work.work);
953 struct extcon_dev *edev = cg->cable_edev;
954 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
955 const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
957 /* Determine cable/charger type */
958 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
959 charger = USB_TYPE_USB_CHARGER;
960 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
961 charger = USB_TYPE_AC_CHARGER;
962 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
963 charger = USB_TYPE_CDP_CHARGER;
965 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
966 CG_INFO("receive type-c notifier event: %s...\n",
968 cg->usb_charger = charger;
969 rk818_cg_set_chrg_param(cg, charger);
970 rk818_cg_pr_info(cg);
974 static long rk818_cg_init_usb(struct rk818_charger *cg)
976 enum charger_t charger;
977 enum bc_port_type bc_type;
978 struct extcon_dev *edev;
979 struct device *dev = cg->dev;
982 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
983 WQ_MEM_RECLAIM | WQ_FREEZABLE,
985 cg->usb_charger = USB_TYPE_NONE_CHARGER;
988 if (cg->pdata->extcon) {
989 edev = extcon_get_edev_by_phandle(dev->parent, 0);
991 if (PTR_ERR(edev) != -EPROBE_DEFER)
992 dev_err(dev, "Invalid or missing extcon\n");
993 return PTR_ERR(edev);
996 /* Register chargers */
997 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
998 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
999 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
1002 dev_err(dev, "failed to register notifier for SDP\n");
1006 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1009 dev_err(dev, "failed to register notifier for DCP\n");
1010 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1015 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1018 dev_err(dev, "failed to register notifier for CDP\n");
1019 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1021 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1027 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1028 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1029 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
1030 &cg->cable_host_nb);
1032 dev_err(dev, "failed to register notifier for HOST\n");
1033 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1035 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1037 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1043 /* Register discnt usb */
1044 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1045 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1046 ret = extcon_register_notifier(edev, EXTCON_USB,
1047 &cg->cable_discnt_nb);
1049 dev_err(dev, "failed to register notifier for HOST\n");
1050 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1052 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1054 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1056 extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
1057 &cg->cable_host_nb);
1061 cg->cable_edev = edev;
1063 schedule_delayed_work(&cg->host_work, 0);
1064 schedule_delayed_work(&cg->usb_work, 0);
1066 CG_INFO("register typec extcon evt notifier\n");
1068 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1069 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1070 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1072 dev_err(dev, "failed to register notifier for bc\n");
1077 case USB_BC_TYPE_DISCNT:
1078 charger = USB_TYPE_NONE_CHARGER;
1080 case USB_BC_TYPE_SDP:
1081 case USB_BC_TYPE_CDP:
1082 charger = USB_TYPE_USB_CHARGER;
1084 case USB_BC_TYPE_DCP:
1085 charger = USB_TYPE_AC_CHARGER;
1088 charger = USB_TYPE_NONE_CHARGER;
1092 cg->usb_charger = charger;
1093 CG_INFO("register bc evt notifier\n");
1099 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1101 if (rk818_cg_online(cg))
1102 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1104 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1106 cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1107 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1108 "rk818-finish-sig-wq");
1109 INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1112 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1114 rk818_cg_init_config(cg);
1115 rk818_cg_init_finish_sig(cg);
1116 rk818_cg_set_chrg_param(cg, cg->dc_charger);
1117 rk818_cg_set_chrg_param(cg, cg->usb_charger);
1118 CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d\n",
1119 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1123 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1125 struct device_node *np;
1126 struct charger_platform_data *pdata;
1127 enum of_gpio_flags flags;
1128 struct device *dev = cg->dev;
1131 np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1133 dev_err(dev, "battery node not found!\n");
1137 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1142 pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1143 pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1144 pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1146 pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1148 ret = of_property_read_u32(np, "max_chrg_current",
1149 &pdata->max_chrg_current);
1151 dev_err(dev, "max_chrg_current missing!\n");
1153 ret = of_property_read_u32(np, "max_input_current",
1154 &pdata->max_input_current);
1156 dev_err(dev, "max_input_current missing!\n");
1158 ret = of_property_read_u32(np, "max_chrg_voltage",
1159 &pdata->max_chrg_voltage);
1161 dev_err(dev, "max_chrg_voltage missing!\n");
1163 ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1165 dev_err(dev, "virtual_power missing!\n");
1167 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1169 dev_err(dev, "power_dc2otg missing!\n");
1171 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1173 pdata->sample_res = SAMPLE_RES_20MR;
1174 dev_err(dev, "sample_res missing!\n");
1177 if (!is_battery_exist(cg))
1178 pdata->virtual_power = 1;
1180 cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1181 SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1183 if (!of_find_property(np, "dc_det_gpio", &ret)) {
1184 pdata->support_dc_det = false;
1185 CG_INFO("not support dc\n");
1187 pdata->support_dc_det = true;
1188 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1190 if (gpio_is_valid(pdata->dc_det_pin)) {
1191 CG_INFO("support dc\n");
1192 pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1195 dev_err(dev, "invalid dc det gpio!\n");
1200 DBG("input_current:%d\n"
1205 "virtual_power:%d\n"
1206 "power_dc2otg:%d\n",
1207 pdata->max_input_current, pdata->max_chrg_current,
1208 pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1209 pdata->virtual_power, pdata->power_dc2otg);
1214 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1220 static int rk818_charger_probe(struct platform_device *pdev)
1222 struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1223 struct rk818_charger *cg;
1226 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1232 cg->dev = &pdev->dev;
1233 cg->regmap = rk818->regmap;
1234 platform_set_drvdata(pdev, cg);
1236 ret = rk818_cg_parse_dt(cg);
1238 dev_err(cg->dev, "parse dt failed!\n");
1242 ret = rk818_cg_init_irqs(cg);
1244 dev_err(cg->dev, "init irqs failed!\n");
1248 ret = rk818_cg_init_dc(cg);
1250 dev_err(cg->dev, "init dc failed!\n");
1254 ret = rk818_cg_init_usb(cg);
1256 dev_err(cg->dev, "init usb failed!\n");
1260 ret = rk818_cg_init_power_supply(cg);
1262 dev_err(cg->dev, "init power supply fail!\n");
1266 rk818_cg_init_charger_state(cg);
1268 CG_INFO("driver version: %s\n", DRIVER_VERSION);
1273 static void rk818_charger_shutdown(struct platform_device *pdev)
1275 struct rk818_charger *cg = platform_get_drvdata(pdev);
1277 cancel_delayed_work_sync(&cg->host_work);
1278 cancel_delayed_work_sync(&cg->usb_work);
1279 cancel_delayed_work_sync(&cg->discnt_work);
1280 cancel_delayed_work_sync(&cg->dc_work);
1281 cancel_delayed_work_sync(&cg->finish_sig_work);
1282 cancel_delayed_work_sync(&cg->irq_work);
1283 destroy_workqueue(cg->usb_charger_wq);
1284 destroy_workqueue(cg->dc_charger_wq);
1285 destroy_workqueue(cg->finish_sig_wq);
1287 if (cg->pdata->extcon) {
1288 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1290 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1292 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1294 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
1295 &cg->cable_host_nb);
1296 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1297 &cg->cable_discnt_nb);
1299 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1302 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
1303 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1305 CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1306 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1309 static struct platform_driver rk818_charger_driver = {
1310 .probe = rk818_charger_probe,
1311 .shutdown = rk818_charger_shutdown,
1313 .name = "rk818-charger",
1317 static int __init charger_init(void)
1319 return platform_driver_register(&rk818_charger_driver);
1321 module_init(charger_init);
1323 static void __exit charger_exit(void)
1325 platform_driver_unregister(&rk818_charger_driver);
1327 module_exit(charger_exit);
1329 MODULE_LICENSE("GPL");
1330 MODULE_ALIAS("platform:rk818-charger");
1331 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");