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;
116 int otg5v_suspend_enable;
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;
154 u8 sleep_set_off_reg1;
161 static int rk818_reg_read(struct rk818_charger *cg, u8 reg)
165 ret = regmap_read(cg->regmap, reg, &val);
167 dev_err(cg->dev, "i2c read reg: 0x%2x failed\n", reg);
172 static int rk818_reg_write(struct rk818_charger *cg, u8 reg, u8 buf)
176 ret = regmap_write(cg->regmap, reg, buf);
178 dev_err(cg->dev, "i2c write reg: 0x%2x failed\n", reg);
183 static int rk818_reg_set_bits(struct rk818_charger *cg, u8 reg, u8 mask, u8 buf)
187 ret = regmap_update_bits(cg->regmap, reg, mask, buf);
189 dev_err(cg->dev, "i2c set reg: 0x%2x failed\n", reg);
194 static int rk818_reg_clear_bits(struct rk818_charger *cg, u8 reg, u8 mask)
198 ret = regmap_update_bits(cg->regmap, reg, mask, 0);
200 dev_err(cg->dev, "i2c clr reg: 0x%02x failed\n", reg);
205 static int rk818_cg_online(struct rk818_charger *cg)
207 return (cg->ac_in | cg->usb_in | cg->dc_in);
210 static int rk818_cg_get_dsoc(struct rk818_charger *cg)
212 return rk818_reg_read(cg, RK818_SOC_REG);
215 static int rk818_cg_get_avg_current(struct rk818_charger *cg)
219 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGL) << 0;
220 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGH) << 8;
224 cur = val * cg->res_div * 1506 / 1000;
229 static u64 get_boot_sec(void)
233 get_monotonic_boottime(&ts);
238 static int rk818_cg_lowpwr_check(struct rk818_charger *cg)
242 int current_avg, dsoc, fake_offline = 0;
244 buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
248 dsoc = rk818_cg_get_dsoc(cg);
249 current_avg = rk818_cg_get_avg_current(cg);
250 if ((current_avg < 0) && (dsoc == 0)) {
252 time = get_boot_sec();
253 if ((get_boot_sec() - time) >= 30) {
255 CG_INFO("low power....soc=%d, current=%d\n",
263 DBG("<%s>. t=%lld, dsoc=%d, current=%d, fake_offline=%d\n",
264 __func__, get_boot_sec() - time, dsoc, current_avg, fake_offline);
269 static enum power_supply_property rk818_ac_props[] = {
270 POWER_SUPPLY_PROP_ONLINE,
271 POWER_SUPPLY_PROP_STATUS,
274 static enum power_supply_property rk818_usb_props[] = {
275 POWER_SUPPLY_PROP_ONLINE,
276 POWER_SUPPLY_PROP_STATUS,
279 static int rk818_cg_ac_get_property(struct power_supply *psy,
280 enum power_supply_property psp,
281 union power_supply_propval *val)
283 struct rk818_charger *cg = power_supply_get_drvdata(psy);
284 int fake_offline = 0, ret = 0;
286 if (rk818_cg_online(cg))
287 fake_offline = rk818_cg_lowpwr_check(cg);
290 case POWER_SUPPLY_PROP_ONLINE:
291 if (cg->pdata->virtual_power)
293 else if (fake_offline)
296 val->intval = (cg->ac_in | cg->dc_in);
298 DBG("report online: %d\n", val->intval);
300 case POWER_SUPPLY_PROP_STATUS:
301 if (cg->pdata->virtual_power)
302 val->intval = POWER_SUPPLY_STATUS_CHARGING;
303 else if (fake_offline)
304 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
306 val->intval = cg->prop_status;
308 DBG("report prop: %d\n", val->intval);
318 static int rk818_cg_usb_get_property(struct power_supply *psy,
319 enum power_supply_property psp,
320 union power_supply_propval *val)
322 struct rk818_charger *cg = power_supply_get_drvdata(psy);
323 int fake_offline, ret = 0;
325 if (rk818_cg_online(cg))
326 fake_offline = rk818_cg_lowpwr_check(cg);
329 case POWER_SUPPLY_PROP_ONLINE:
330 if (cg->pdata->virtual_power)
332 else if (fake_offline)
335 val->intval = cg->usb_in;
337 DBG("report online: %d\n", val->intval);
339 case POWER_SUPPLY_PROP_STATUS:
340 if (cg->pdata->virtual_power)
341 val->intval = POWER_SUPPLY_STATUS_CHARGING;
342 else if (fake_offline)
343 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
345 val->intval = cg->prop_status;
347 DBG("report prop: %d\n", val->intval);
357 static const struct power_supply_desc rk818_ac_desc = {
359 .type = POWER_SUPPLY_TYPE_MAINS,
360 .properties = rk818_ac_props,
361 .num_properties = ARRAY_SIZE(rk818_ac_props),
362 .get_property = rk818_cg_ac_get_property,
365 static const struct power_supply_desc rk818_usb_desc = {
367 .type = POWER_SUPPLY_TYPE_USB,
368 .properties = rk818_usb_props,
369 .num_properties = ARRAY_SIZE(rk818_usb_props),
370 .get_property = rk818_cg_usb_get_property,
373 static int rk818_cg_init_power_supply(struct rk818_charger *cg)
375 struct power_supply_config psy_cfg = { .drv_data = cg, };
377 cg->usb_psy = devm_power_supply_register(cg->dev, &rk818_usb_desc,
379 if (IS_ERR(cg->usb_psy)) {
380 dev_err(cg->dev, "register usb power supply fail\n");
381 return PTR_ERR(cg->usb_psy);
384 cg->ac_psy = devm_power_supply_register(cg->dev, &rk818_ac_desc,
386 if (IS_ERR(cg->ac_psy)) {
387 dev_err(cg->dev, "register ac power supply fail\n");
388 return PTR_ERR(cg->ac_psy);
394 static void rk818_cg_pr_info(struct rk818_charger *cg)
396 u8 usb_ctrl, chrg_ctrl1;
398 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
399 chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
400 CG_INFO("ac=%d usb=%d dc=%d otg=%d v=%d chrg=%d input=%d virt=%d\n",
401 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in,
402 chrg_vol_sel_array[(chrg_ctrl1 & 0x70) >> 4],
403 chrg_cur_sel_array[chrg_ctrl1 & 0x0f] * cg->res_div,
404 chrg_cur_input_array[usb_ctrl & 0x0f],
405 cg->pdata->virtual_power);
408 static bool is_battery_exist(struct rk818_charger *cg)
410 return (rk818_reg_read(cg, RK818_SUP_STS_REG) & BAT_EXS) ? true : false;
413 static void rk818_cg_set_input_current(struct rk818_charger *cg,
418 if (cg->pdata->virtual_power) {
419 CG_INFO("warning: virtual power mode...\n");
420 input_current = cg->chrg_input;
423 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
424 usb_ctrl &= ~INPUT_CUR_MSK;
425 usb_ctrl |= (input_current);
426 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
429 static void rk818_cg_set_finish_sig(struct rk818_charger *cg, int mode)
433 buf = rk818_reg_read(cg, RK818_CHRG_CTRL_REG3);
434 buf &= ~CHRG_FINISH_MODE_MSK;
436 rk818_reg_write(cg, RK818_CHRG_CTRL_REG3, buf);
439 static void rk818_cg_finish_sig_work(struct work_struct *work)
441 struct rk818_charger *cg;
443 cg = container_of(work, struct rk818_charger, finish_sig_work.work);
444 if (rk818_cg_online(cg))
445 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
447 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
450 static void rk818_cg_set_chrg_param(struct rk818_charger *cg,
451 enum charger_t charger)
456 case USB_TYPE_NONE_CHARGER:
459 if (cg->dc_in == 0) {
460 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
461 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
463 power_supply_changed(cg->usb_psy);
464 power_supply_changed(cg->ac_psy);
466 case USB_TYPE_USB_CHARGER:
469 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
471 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
472 power_supply_changed(cg->usb_psy);
473 power_supply_changed(cg->ac_psy);
475 case USB_TYPE_AC_CHARGER:
476 case USB_TYPE_CDP_CHARGER:
479 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
480 if (charger == USB_TYPE_AC_CHARGER)
481 rk818_cg_set_input_current(cg, cg->chrg_input);
483 rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
484 power_supply_changed(cg->usb_psy);
485 power_supply_changed(cg->ac_psy);
487 case DC_TYPE_DC_CHARGER:
489 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
490 rk818_cg_set_input_current(cg, cg->chrg_input);
491 power_supply_changed(cg->usb_psy);
492 power_supply_changed(cg->ac_psy);
494 case DC_TYPE_NONE_CHARGER:
496 buf = rk818_reg_read(cg, RK818_VB_MON_REG);
497 if ((buf & PLUG_IN_STS) == 0) {
500 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
501 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
502 } else if (cg->usb_in) {
503 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
504 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
506 power_supply_changed(cg->usb_psy);
507 power_supply_changed(cg->ac_psy);
510 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
514 if (rk818_cg_online(cg) && rk818_cg_get_dsoc(cg) == 100)
515 cg->prop_status = POWER_SUPPLY_STATUS_FULL;
517 if (cg->finish_sig_wq)
518 queue_delayed_work(cg->finish_sig_wq, &cg->finish_sig_work,
519 msecs_to_jiffies(1000));
522 static void rk818_cg_set_otg_state(struct rk818_charger *cg, int state)
525 case USB_OTG_POWER_ON:
527 CG_INFO("otg5v is on yet, ignore..\n");
530 disable_irq(cg->plugin_irq);
531 disable_irq(cg->plugout_irq);
532 rk818_reg_set_bits(cg, RK818_DCDC_EN_REG,
533 OTG_EN_MASK, OTG_EN_MASK);
534 CG_INFO("enable otg5v\n");
537 case USB_OTG_POWER_OFF:
539 CG_INFO("otg5v is off yet, ignore..\n");
542 enable_irq(cg->plugin_irq);
543 enable_irq(cg->plugout_irq);
544 rk818_reg_clear_bits(cg, RK818_DCDC_EN_REG,
546 CG_INFO("disable otg5v\n");
550 dev_err(cg->dev, "error otg type\n");
555 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
559 if (!gpio_is_valid(cg->pdata->dc_det_pin))
560 return DC_TYPE_NONE_CHARGER;
562 level = gpio_get_value(cg->pdata->dc_det_pin);
564 return (level == cg->pdata->dc_det_level) ?
565 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
568 static void rk818_cg_dc_det_worker(struct work_struct *work)
570 enum charger_t charger;
571 struct rk818_charger *cg = container_of(work,
572 struct rk818_charger, dc_work.work);
574 charger = rk818_cg_get_dc_state(cg);
575 if (charger == DC_TYPE_DC_CHARGER) {
576 CG_INFO("detect dc charger in..\n");
577 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
578 /* check otg supply */
579 if (cg->otg_in && cg->pdata->power_dc2otg) {
580 CG_INFO("otg power from dc adapter\n");
581 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
584 CG_INFO("detect dc charger out..\n");
585 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
586 /* check otg supply, power on anyway */
588 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
591 rk_send_wakeup_key();
592 rk818_cg_pr_info(cg);
595 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg)
600 chrg_vol = cg->pdata->max_chrg_voltage;
601 for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
602 if (chrg_vol < chrg_vol_sel_array[index])
607 DBG("<%s>. vol=0x%x\n", __func__, val);
611 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg)
616 input_current = cg->pdata->max_input_current;
617 for (index = 0; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
618 if (input_current < chrg_cur_input_array[index])
623 DBG("<%s>. input=0x%x\n", __func__, val);
627 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg)
632 chrg_current = cg->pdata->max_chrg_current;
633 if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
634 if (chrg_current > 2000)
635 chrg_current /= cg->res_div;
640 for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
641 if (chrg_current < chrg_cur_sel_array[index])
646 DBG("<%s>. sel=0x%x\n", __func__, val);
650 static void rk818_cg_init_config(struct rk818_charger *cg)
652 u8 usb_ctrl, sup_sts, chrg_ctrl1;
654 cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg);
655 cg->chrg_current = rk818_cg_decode_chrg_current(cg);
656 cg->chrg_input = rk818_cg_decode_input_current(cg);
658 sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
659 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
661 /* set charge current and voltage */
662 usb_ctrl &= ~INPUT_CUR_MSK;
663 usb_ctrl |= cg->chrg_input;
664 chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
666 /* disable voltage limit and enable input current limit */
667 sup_sts &= ~USB_VLIMIT_EN;
668 sup_sts |= USB_CLIMIT_EN;
670 rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
671 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
672 rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
675 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
676 unsigned long event, void *ptr)
678 struct rk818_charger *cg =
679 container_of(nb, struct rk818_charger, cable_cg_nb);
681 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
682 msecs_to_jiffies(10));
687 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
688 unsigned long event, void *ptr)
690 struct rk818_charger *cg =
691 container_of(nb, struct rk818_charger, cable_discnt_nb);
693 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
694 msecs_to_jiffies(10));
699 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
700 unsigned long event, void *ptr)
702 struct rk818_charger *cg =
703 container_of(nb, struct rk818_charger, cable_host_nb);
705 queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
706 msecs_to_jiffies(10));
711 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
712 unsigned long event, void *ptr)
714 struct rk818_charger *cg =
715 container_of(nb, struct rk818_charger, bc_nb);
717 cg->bc_event = event;
718 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
719 msecs_to_jiffies(10));
724 static void rk818_cg_bc_evt_worker(struct work_struct *work)
726 struct rk818_charger *cg = container_of(work,
727 struct rk818_charger, usb_work.work);
728 const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
729 "UNKNOWN", "OTG ON", "OTG OFF"};
731 switch (cg->bc_event) {
732 case USB_BC_TYPE_DISCNT:
733 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
735 case USB_BC_TYPE_SDP:
736 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
738 case USB_BC_TYPE_DCP:
739 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
741 case USB_BC_TYPE_CDP:
742 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
744 case USB_OTG_POWER_ON:
745 if (cg->pdata->power_dc2otg && cg->dc_in)
746 CG_INFO("otg power from dc adapter\n");
748 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
750 case USB_OTG_POWER_OFF:
751 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
757 CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
759 rk818_cg_pr_info(cg);
762 static void rk818_cg_irq_delay_work(struct work_struct *work)
764 struct rk818_charger *cg = container_of(work,
765 struct rk818_charger, irq_work.work);
767 if (cg->plugin_trigger) {
768 CG_INFO("pmic: plug in\n");
769 cg->plugin_trigger = 0;
770 rk_send_wakeup_key();
771 } else if (cg->plugout_trigger) {
772 CG_INFO("pmic: plug out\n");
773 cg->plugout_trigger = 0;
774 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
775 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
776 rk_send_wakeup_key();
777 rk818_cg_pr_info(cg);
779 CG_INFO("pmic: unknown irq\n");
783 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
785 struct rk818_charger *icg;
787 icg = (struct rk818_charger *)cg;
788 icg->plugin_trigger = 1;
789 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
790 msecs_to_jiffies(10));
795 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
797 struct rk818_charger *icg;
799 icg = (struct rk818_charger *)cg;
800 icg->plugout_trigger = 1;
801 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
802 msecs_to_jiffies(10));
807 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
809 struct rk818_charger *cg = (struct rk818_charger *)charger;
811 if (gpio_get_value(cg->pdata->dc_det_pin))
812 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
814 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
816 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
817 msecs_to_jiffies(10));
822 static int rk818_cg_init_irqs(struct rk818_charger *cg)
824 struct rk808 *rk818 = cg->rk818;
825 struct platform_device *pdev = cg->pdev;
826 int ret, plug_in_irq, plug_out_irq;
828 plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
829 if (plug_in_irq < 0) {
830 dev_err(cg->dev, "plug_in_irq request failed!\n");
834 plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
835 if (plug_out_irq < 0) {
836 dev_err(cg->dev, "plug_out_irq request failed!\n");
840 ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
843 "rk818_plug_in", cg);
845 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
849 ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
851 IRQF_TRIGGER_FALLING,
852 "rk818_plug_out", cg);
854 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
858 cg->plugin_irq = plug_in_irq;
859 cg->plugout_irq = plug_out_irq;
861 INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
866 static int rk818_cg_init_dc(struct rk818_charger *cg)
869 unsigned long irq_flags;
870 unsigned int dc_det_irq;
872 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
873 WQ_MEM_RECLAIM | WQ_FREEZABLE,
875 INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
876 cg->dc_charger = DC_TYPE_NONE_CHARGER;
878 if (!cg->pdata->support_dc_det)
881 ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
883 dev_err(cg->dev, "failed to request gpio %d\n",
884 cg->pdata->dc_det_pin);
888 ret = gpio_direction_input(cg->pdata->dc_det_pin);
890 dev_err(cg->dev, "failed to set gpio input\n");
894 level = gpio_get_value(cg->pdata->dc_det_pin);
895 if (level == cg->pdata->dc_det_level)
896 cg->dc_charger = DC_TYPE_DC_CHARGER;
898 cg->dc_charger = DC_TYPE_NONE_CHARGER;
901 irq_flags = IRQF_TRIGGER_LOW;
903 irq_flags = IRQF_TRIGGER_HIGH;
905 dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
906 ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
907 irq_flags, "rk818_dc_det", cg);
909 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
913 enable_irq_wake(dc_det_irq);
918 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
920 struct rk818_charger *cg = container_of(work,
921 struct rk818_charger, discnt_work.work);
923 if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
924 CG_INFO("receive type-c notifier event: DISCNT...\n");
925 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
926 rk818_cg_pr_info(cg);
930 static void rk818_cg_host_evt_worker(struct work_struct *work)
932 struct rk818_charger *cg = container_of(work,
933 struct rk818_charger, host_work.work);
934 struct extcon_dev *edev = cg->cable_edev;
936 /* Determine cable/charger type */
937 if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
938 CG_INFO("receive type-c notifier event: OTG ON...\n");
939 if (cg->dc_in && cg->pdata->power_dc2otg)
940 CG_INFO("otg power from dc adapter\n");
942 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
943 } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
944 CG_INFO("receive type-c notifier event: OTG OFF...\n");
945 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
948 rk818_cg_pr_info(cg);
951 static void rk818_cg_charger_evt_worker(struct work_struct *work)
953 struct rk818_charger *cg = container_of(work,
954 struct rk818_charger, usb_work.work);
955 struct extcon_dev *edev = cg->cable_edev;
956 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
957 const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
959 /* Determine cable/charger type */
960 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
961 charger = USB_TYPE_USB_CHARGER;
962 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
963 charger = USB_TYPE_AC_CHARGER;
964 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
965 charger = USB_TYPE_CDP_CHARGER;
967 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
968 CG_INFO("receive type-c notifier event: %s...\n",
970 cg->usb_charger = charger;
971 rk818_cg_set_chrg_param(cg, charger);
972 rk818_cg_pr_info(cg);
976 static long rk818_cg_init_usb(struct rk818_charger *cg)
978 enum charger_t charger;
979 enum bc_port_type bc_type;
980 struct extcon_dev *edev;
981 struct device *dev = cg->dev;
984 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
985 WQ_MEM_RECLAIM | WQ_FREEZABLE,
987 cg->usb_charger = USB_TYPE_NONE_CHARGER;
990 if (cg->pdata->extcon) {
991 edev = extcon_get_edev_by_phandle(dev->parent, 0);
993 if (PTR_ERR(edev) != -EPROBE_DEFER)
994 dev_err(dev, "Invalid or missing extcon\n");
995 return PTR_ERR(edev);
998 /* Register chargers */
999 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
1000 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
1001 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
1004 dev_err(dev, "failed to register notifier for SDP\n");
1008 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1011 dev_err(dev, "failed to register notifier for DCP\n");
1012 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1017 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1020 dev_err(dev, "failed to register notifier for CDP\n");
1021 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1023 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1029 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1030 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1031 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
1032 &cg->cable_host_nb);
1034 dev_err(dev, "failed to register notifier for HOST\n");
1035 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1037 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1039 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1045 /* Register discnt usb */
1046 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1047 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1048 ret = extcon_register_notifier(edev, EXTCON_USB,
1049 &cg->cable_discnt_nb);
1051 dev_err(dev, "failed to register notifier for HOST\n");
1052 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1054 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1056 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1058 extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
1059 &cg->cable_host_nb);
1063 cg->cable_edev = edev;
1065 schedule_delayed_work(&cg->host_work, 0);
1066 schedule_delayed_work(&cg->usb_work, 0);
1068 CG_INFO("register typec extcon evt notifier\n");
1070 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1071 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1072 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1074 dev_err(dev, "failed to register notifier for bc\n");
1079 case USB_BC_TYPE_DISCNT:
1080 charger = USB_TYPE_NONE_CHARGER;
1082 case USB_BC_TYPE_SDP:
1083 case USB_BC_TYPE_CDP:
1084 charger = USB_TYPE_USB_CHARGER;
1086 case USB_BC_TYPE_DCP:
1087 charger = USB_TYPE_AC_CHARGER;
1090 charger = USB_TYPE_NONE_CHARGER;
1094 cg->usb_charger = charger;
1095 CG_INFO("register bc evt notifier\n");
1101 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1103 if (rk818_cg_online(cg))
1104 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1106 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1108 cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1109 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1110 "rk818-finish-sig-wq");
1111 INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1114 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1116 rk818_cg_init_config(cg);
1117 rk818_cg_init_finish_sig(cg);
1118 rk818_cg_set_chrg_param(cg, cg->dc_charger);
1119 rk818_cg_set_chrg_param(cg, cg->usb_charger);
1120 CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d\n",
1121 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1125 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1127 struct device_node *np;
1128 struct charger_platform_data *pdata;
1129 enum of_gpio_flags flags;
1130 struct device *dev = cg->dev;
1133 np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1135 dev_err(dev, "battery node not found!\n");
1139 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1144 pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1145 pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1146 pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1148 pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1150 ret = of_property_read_u32(np, "max_chrg_current",
1151 &pdata->max_chrg_current);
1153 dev_err(dev, "max_chrg_current missing!\n");
1155 ret = of_property_read_u32(np, "max_input_current",
1156 &pdata->max_input_current);
1158 dev_err(dev, "max_input_current missing!\n");
1160 ret = of_property_read_u32(np, "max_chrg_voltage",
1161 &pdata->max_chrg_voltage);
1163 dev_err(dev, "max_chrg_voltage missing!\n");
1165 ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1167 dev_err(dev, "virtual_power missing!\n");
1169 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1171 dev_err(dev, "power_dc2otg missing!\n");
1173 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1175 pdata->sample_res = SAMPLE_RES_20MR;
1176 dev_err(dev, "sample_res missing!\n");
1179 ret = of_property_read_u32(np, "otg5v_suspend_enable",
1180 &pdata->otg5v_suspend_enable);
1182 pdata->otg5v_suspend_enable = 1;
1183 dev_err(dev, "otg5v_suspend_enable missing!\n");
1186 if (!is_battery_exist(cg))
1187 pdata->virtual_power = 1;
1189 cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1190 SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1192 if (!of_find_property(np, "dc_det_gpio", &ret)) {
1193 pdata->support_dc_det = false;
1194 CG_INFO("not support dc\n");
1196 pdata->support_dc_det = true;
1197 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1199 if (gpio_is_valid(pdata->dc_det_pin)) {
1200 CG_INFO("support dc\n");
1201 pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1204 dev_err(dev, "invalid dc det gpio!\n");
1209 DBG("input_current:%d\n"
1214 "virtual_power:%d\n"
1215 "power_dc2otg:%d\n",
1216 pdata->max_input_current, pdata->max_chrg_current,
1217 pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1218 pdata->virtual_power, pdata->power_dc2otg);
1223 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1229 static int rk818_charger_probe(struct platform_device *pdev)
1231 struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1232 struct rk818_charger *cg;
1235 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1241 cg->dev = &pdev->dev;
1242 cg->regmap = rk818->regmap;
1243 platform_set_drvdata(pdev, cg);
1245 ret = rk818_cg_parse_dt(cg);
1247 dev_err(cg->dev, "parse dt failed!\n");
1251 ret = rk818_cg_init_irqs(cg);
1253 dev_err(cg->dev, "init irqs failed!\n");
1257 ret = rk818_cg_init_dc(cg);
1259 dev_err(cg->dev, "init dc failed!\n");
1263 ret = rk818_cg_init_usb(cg);
1265 dev_err(cg->dev, "init usb failed!\n");
1269 ret = rk818_cg_init_power_supply(cg);
1271 dev_err(cg->dev, "init power supply fail!\n");
1275 rk818_cg_init_charger_state(cg);
1277 CG_INFO("driver version: %s\n", DRIVER_VERSION);
1282 static void rk818_charger_shutdown(struct platform_device *pdev)
1284 struct rk818_charger *cg = platform_get_drvdata(pdev);
1286 cancel_delayed_work_sync(&cg->host_work);
1287 cancel_delayed_work_sync(&cg->usb_work);
1288 cancel_delayed_work_sync(&cg->discnt_work);
1289 cancel_delayed_work_sync(&cg->dc_work);
1290 cancel_delayed_work_sync(&cg->finish_sig_work);
1291 cancel_delayed_work_sync(&cg->irq_work);
1292 destroy_workqueue(cg->usb_charger_wq);
1293 destroy_workqueue(cg->dc_charger_wq);
1294 destroy_workqueue(cg->finish_sig_wq);
1296 if (cg->pdata->extcon) {
1297 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1299 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1301 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1303 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
1304 &cg->cable_host_nb);
1305 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1306 &cg->cable_discnt_nb);
1308 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1311 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
1312 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1314 CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1315 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1318 static int rk818_charger_suspend(struct platform_device *pdev,
1321 struct rk818_charger *cg = platform_get_drvdata(pdev);
1323 cg->sleep_set_off_reg1 = rk818_reg_read(cg, RK818_SLEEP_SET_OFF_REG1);
1325 /* enable sleep boost5v and otg5v */
1326 if (cg->pdata->otg5v_suspend_enable) {
1327 if ((cg->otg_in && !cg->dc_in) ||
1328 (cg->otg_in && cg->dc_in && !cg->pdata->power_dc2otg)) {
1329 rk818_reg_clear_bits(cg, RK818_SLEEP_SET_OFF_REG1,
1331 CG_INFO("suspend: otg 5v on\n");
1336 /* disable sleep otg5v */
1337 rk818_reg_set_bits(cg, RK818_SLEEP_SET_OFF_REG1,
1338 OTG_SLP_SET_OFF, OTG_SLP_SET_OFF);
1339 CG_INFO("suspend: otg 5v off\n");
1344 static int rk818_charger_resume(struct platform_device *pdev)
1346 struct rk818_charger *cg = platform_get_drvdata(pdev);
1348 /* resume sleep boost5v and otg5v */
1349 rk818_reg_set_bits(cg, RK818_SLEEP_SET_OFF_REG1,
1350 OTG_BOOST_SLP_OFF, cg->sleep_set_off_reg1);
1355 static struct platform_driver rk818_charger_driver = {
1356 .probe = rk818_charger_probe,
1357 .suspend = rk818_charger_suspend,
1358 .resume = rk818_charger_resume,
1359 .shutdown = rk818_charger_shutdown,
1361 .name = "rk818-charger",
1365 static int __init charger_init(void)
1367 return platform_driver_register(&rk818_charger_driver);
1369 module_init(charger_init);
1371 static void __exit charger_exit(void)
1373 platform_driver_unregister(&rk818_charger_driver);
1375 module_exit(charger_exit);
1377 MODULE_LICENSE("GPL");
1378 MODULE_ALIAS("platform:rk818-charger");
1379 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");