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;
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:
524 rk818_reg_set_bits(cg, RK818_INT_STS_MSK_REG2,
525 PLUG_IN_MSK, PLUG_IN_MSK);
526 rk818_reg_set_bits(cg, RK818_INT_STS_MSK_REG2,
527 PLUG_OUT_MSK, PLUG_OUT_MSK);
528 rk818_reg_set_bits(cg, RK818_DCDC_EN_REG,
529 OTG_EN_MASK, OTG_EN_MASK);
531 case USB_OTG_POWER_OFF:
532 rk818_reg_clear_bits(cg, RK818_INT_STS_MSK_REG2, PLUG_IN_MSK);
533 rk818_reg_clear_bits(cg, RK818_INT_STS_MSK_REG2, PLUG_OUT_MSK);
534 rk818_reg_clear_bits(cg, RK818_DCDC_EN_REG, OTG_EN_MASK);
537 dev_err(cg->dev, "error otg type\n");
542 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
546 if (!gpio_is_valid(cg->pdata->dc_det_pin))
547 return DC_TYPE_NONE_CHARGER;
549 level = gpio_get_value(cg->pdata->dc_det_pin);
551 return (level == cg->pdata->dc_det_level) ?
552 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
555 static void rk818_cg_dc_det_worker(struct work_struct *work)
557 enum charger_t charger;
558 struct rk818_charger *cg = container_of(work,
559 struct rk818_charger, dc_work.work);
561 charger = rk818_cg_get_dc_state(cg);
562 if (charger == DC_TYPE_DC_CHARGER) {
563 CG_INFO("detect dc charger in..\n");
564 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
565 /* check otg supply */
566 if (cg->otg_in && cg->pdata->power_dc2otg) {
567 CG_INFO("otg power from dc adapter\n");
568 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
571 CG_INFO("detect dc charger out..\n");
572 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
573 /* check otg supply, power on anyway */
575 CG_INFO("disable charge, enable otg\n");
576 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
580 rk_send_wakeup_key();
581 rk818_cg_pr_info(cg);
584 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg)
589 chrg_vol = cg->pdata->max_chrg_voltage;
590 for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
591 if (chrg_vol < chrg_vol_sel_array[index])
596 DBG("<%s>. vol=0x%x\n", __func__, val);
600 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg)
605 input_current = cg->pdata->max_input_current;
606 for (index = 0; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
607 if (input_current < chrg_cur_input_array[index])
612 DBG("<%s>. input=0x%x\n", __func__, val);
616 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg)
621 chrg_current = cg->pdata->max_chrg_current;
622 if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
623 if (chrg_current > 2000)
624 chrg_current /= cg->res_div;
629 for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
630 if (chrg_current < chrg_cur_sel_array[index])
635 DBG("<%s>. sel=0x%x\n", __func__, val);
639 static void rk818_cg_init_config(struct rk818_charger *cg)
641 u8 usb_ctrl, sup_sts, chrg_ctrl1;
643 cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg);
644 cg->chrg_current = rk818_cg_decode_chrg_current(cg);
645 cg->chrg_input = rk818_cg_decode_input_current(cg);
647 sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
648 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
650 /* set charge current and voltage */
651 usb_ctrl &= ~INPUT_CUR_MSK;
652 usb_ctrl |= cg->chrg_input;
653 chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
655 /* disable voltage limit and enable input current limit */
656 sup_sts &= ~USB_VLIMIT_EN;
657 sup_sts |= USB_CLIMIT_EN;
659 rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
660 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
661 rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
664 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
665 unsigned long event, void *ptr)
667 struct rk818_charger *cg =
668 container_of(nb, struct rk818_charger, cable_cg_nb);
670 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
671 msecs_to_jiffies(10));
676 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
677 unsigned long event, void *ptr)
679 struct rk818_charger *cg =
680 container_of(nb, struct rk818_charger, cable_discnt_nb);
682 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
683 msecs_to_jiffies(10));
688 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
689 unsigned long event, void *ptr)
691 struct rk818_charger *cg =
692 container_of(nb, struct rk818_charger, cable_host_nb);
694 queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
695 msecs_to_jiffies(10));
700 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
701 unsigned long event, void *ptr)
703 struct rk818_charger *cg =
704 container_of(nb, struct rk818_charger, bc_nb);
706 cg->bc_event = event;
707 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
708 msecs_to_jiffies(10));
713 static void rk818_cg_bc_evt_worker(struct work_struct *work)
715 struct rk818_charger *cg = container_of(work,
716 struct rk818_charger, usb_work.work);
717 const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
718 "UNKNOWN", "OTG ON", "OTG OFF"};
720 switch (cg->bc_event) {
721 case USB_BC_TYPE_DISCNT:
722 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
724 case USB_BC_TYPE_SDP:
725 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
727 case USB_BC_TYPE_DCP:
728 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
730 case USB_BC_TYPE_CDP:
731 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
733 case USB_OTG_POWER_ON:
735 if (cg->pdata->power_dc2otg && cg->dc_in) {
736 CG_INFO("otg power from dc adapter\n");
738 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
739 CG_INFO("disable charge, enable otg\n");
742 case USB_OTG_POWER_OFF:
744 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
745 CG_INFO("enable charge, disable otg\n");
751 CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
753 rk818_cg_pr_info(cg);
756 static void rk818_cg_irq_delay_work(struct work_struct *work)
758 struct rk818_charger *cg = container_of(work,
759 struct rk818_charger, irq_work.work);
761 if (cg->plug_in_irq) {
762 CG_INFO("pmic: plug in\n");
764 rk_send_wakeup_key();
765 } else if (cg->plug_out_irq) {
766 CG_INFO("pmic: plug out\n");
767 cg->plug_out_irq = 0;
768 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
769 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
770 rk_send_wakeup_key();
771 rk818_cg_pr_info(cg);
773 CG_INFO("pmic: unknown irq\n");
777 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
779 struct rk818_charger *icg;
781 icg = (struct rk818_charger *)cg;
782 icg->plug_in_irq = 1;
783 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
784 msecs_to_jiffies(10));
789 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
791 struct rk818_charger *icg;
793 icg = (struct rk818_charger *)cg;
794 icg->plug_out_irq = 1;
795 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
796 msecs_to_jiffies(10));
801 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
803 struct rk818_charger *cg = (struct rk818_charger *)charger;
805 if (gpio_get_value(cg->pdata->dc_det_pin))
806 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
808 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
810 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
811 msecs_to_jiffies(10));
816 static int rk818_cg_init_irqs(struct rk818_charger *cg)
818 struct rk808 *rk818 = cg->rk818;
819 struct platform_device *pdev = cg->pdev;
820 int ret, plug_in_irq, plug_out_irq;
822 plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
823 if (plug_in_irq < 0) {
824 dev_err(cg->dev, "plug_in_irq request failed!\n");
828 plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
829 if (plug_out_irq < 0) {
830 dev_err(cg->dev, "plug_out_irq request failed!\n");
834 ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
837 "rk818_plug_in", cg);
839 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
843 ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
845 IRQF_TRIGGER_FALLING,
846 "rk818_plug_out", cg);
848 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
852 INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
857 static int rk818_cg_init_dc(struct rk818_charger *cg)
860 unsigned long irq_flags;
861 unsigned int dc_det_irq;
863 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
864 WQ_MEM_RECLAIM | WQ_FREEZABLE,
866 INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
867 cg->dc_charger = DC_TYPE_NONE_CHARGER;
869 if (!cg->pdata->support_dc_det)
872 ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
874 dev_err(cg->dev, "failed to request gpio %d\n",
875 cg->pdata->dc_det_pin);
879 ret = gpio_direction_input(cg->pdata->dc_det_pin);
881 dev_err(cg->dev, "failed to set gpio input\n");
885 level = gpio_get_value(cg->pdata->dc_det_pin);
886 if (level == cg->pdata->dc_det_level)
887 cg->dc_charger = DC_TYPE_DC_CHARGER;
889 cg->dc_charger = DC_TYPE_NONE_CHARGER;
892 irq_flags = IRQF_TRIGGER_LOW;
894 irq_flags = IRQF_TRIGGER_HIGH;
896 dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
897 ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
898 irq_flags, "rk818_dc_det", cg);
900 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
904 enable_irq_wake(dc_det_irq);
909 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
911 struct rk818_charger *cg = container_of(work,
912 struct rk818_charger, discnt_work.work);
914 if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
915 CG_INFO("receive type-c notifier event: DISCNT...\n");
916 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
917 rk818_cg_pr_info(cg);
921 static void rk818_cg_host_evt_worker(struct work_struct *work)
923 struct rk818_charger *cg = container_of(work,
924 struct rk818_charger, host_work.work);
925 struct extcon_dev *edev = cg->cable_edev;
927 /* Determine cable/charger type */
928 if (extcon_get_cable_state_(edev, EXTCON_USB_HOST) > 0) {
929 CG_INFO("receive type-c notifier event: OTG ON...\n");
931 if (cg->dc_in && cg->pdata->power_dc2otg) {
932 CG_INFO("otg power from dc adapter\n");
934 rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
935 CG_INFO("disable charge, enable otg\n");
937 } else if (extcon_get_cable_state_(edev, EXTCON_USB_HOST) == 0) {
938 CG_INFO("receive type-c notifier event: OTG OFF...\n");
940 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
941 CG_INFO("enble charge, disable otg\n");
944 rk818_cg_pr_info(cg);
947 static void rk818_cg_charger_evt_worker(struct work_struct *work)
949 struct rk818_charger *cg = container_of(work,
950 struct rk818_charger, usb_work.work);
951 struct extcon_dev *edev = cg->cable_edev;
952 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
953 const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
955 /* Determine cable/charger type */
956 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
957 charger = USB_TYPE_USB_CHARGER;
958 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
959 charger = USB_TYPE_AC_CHARGER;
960 else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
961 charger = USB_TYPE_CDP_CHARGER;
963 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
964 CG_INFO("receive type-c notifier event: %s...\n",
966 rk818_cg_set_chrg_param(cg, charger);
967 rk818_cg_pr_info(cg);
971 static long rk818_cg_init_usb(struct rk818_charger *cg)
973 enum charger_t charger;
974 enum bc_port_type bc_type;
975 struct extcon_dev *edev;
976 struct device *dev = cg->dev;
979 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
980 WQ_MEM_RECLAIM | WQ_FREEZABLE,
982 cg->usb_charger = USB_TYPE_NONE_CHARGER;
985 if (cg->pdata->extcon) {
986 edev = extcon_get_edev_by_phandle(dev->parent, 0);
988 if (PTR_ERR(edev) != -EPROBE_DEFER)
989 dev_err(dev, "Invalid or missing extcon\n");
990 return PTR_ERR(edev);
993 /* Register chargers */
994 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
995 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
996 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
999 dev_err(dev, "failed to register notifier for SDP\n");
1003 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1006 dev_err(dev, "failed to register notifier for DCP\n");
1007 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1012 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1015 dev_err(dev, "failed to register notifier for CDP\n");
1016 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1018 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1024 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1025 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1026 ret = extcon_register_notifier(edev, EXTCON_USB_HOST,
1027 &cg->cable_host_nb);
1029 dev_err(dev, "failed to register notifier for HOST\n");
1030 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1032 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1034 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1040 /* Register discnt usb */
1041 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1042 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1043 ret = extcon_register_notifier(edev, EXTCON_USB,
1044 &cg->cable_discnt_nb);
1046 dev_err(dev, "failed to register notifier for HOST\n");
1047 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1049 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1051 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1053 extcon_unregister_notifier(edev, EXTCON_USB_HOST,
1054 &cg->cable_host_nb);
1058 cg->cable_edev = edev;
1060 CG_INFO("register typec extcon evt notifier\n");
1062 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1063 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1064 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1066 dev_err(dev, "failed to register notifier for bc\n");
1071 case USB_BC_TYPE_DISCNT:
1072 charger = USB_TYPE_NONE_CHARGER;
1074 case USB_BC_TYPE_SDP:
1075 case USB_BC_TYPE_CDP:
1076 charger = USB_TYPE_USB_CHARGER;
1078 case USB_BC_TYPE_DCP:
1079 charger = USB_TYPE_AC_CHARGER;
1082 charger = USB_TYPE_NONE_CHARGER;
1086 cg->usb_charger = charger;
1087 CG_INFO("register bc evt notifier\n");
1093 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1095 if (rk818_cg_online(cg))
1096 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1098 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1100 cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1101 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1102 "rk818-finish-sig-wq");
1103 INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1106 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1108 rk818_cg_init_config(cg);
1109 rk818_cg_init_finish_sig(cg);
1110 rk818_cg_set_chrg_param(cg, cg->dc_charger);
1111 rk818_cg_set_chrg_param(cg, cg->usb_charger);
1112 CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d\n",
1113 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1117 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1119 struct device_node *np;
1120 struct charger_platform_data *pdata;
1121 enum of_gpio_flags flags;
1122 struct device *dev = cg->dev;
1125 np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1127 dev_err(dev, "battery node not found!\n");
1131 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1136 pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1137 pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1138 pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1140 pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1142 ret = of_property_read_u32(np, "max_chrg_current",
1143 &pdata->max_chrg_current);
1145 dev_err(dev, "max_chrg_current missing!\n");
1147 ret = of_property_read_u32(np, "max_input_current",
1148 &pdata->max_input_current);
1150 dev_err(dev, "max_input_current missing!\n");
1152 ret = of_property_read_u32(np, "max_chrg_voltage",
1153 &pdata->max_chrg_voltage);
1155 dev_err(dev, "max_chrg_voltage missing!\n");
1157 ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1159 dev_err(dev, "virtual_power missing!\n");
1161 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1163 dev_err(dev, "power_dc2otg missing!\n");
1165 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1167 pdata->sample_res = SAMPLE_RES_20MR;
1168 dev_err(dev, "sample_res missing!\n");
1171 if (!is_battery_exist(cg))
1172 pdata->virtual_power = 1;
1174 cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1175 SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1177 if (!of_find_property(np, "dc_det_gpio", &ret)) {
1178 pdata->support_dc_det = false;
1179 CG_INFO("not support dc\n");
1181 pdata->support_dc_det = true;
1182 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1184 if (gpio_is_valid(pdata->dc_det_pin)) {
1185 CG_INFO("support dc\n");
1186 pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1189 dev_err(dev, "invalid dc det gpio!\n");
1194 DBG("input_current:%d\n"
1199 "virtual_power:%d\n"
1200 "power_dc2otg:%d\n",
1201 pdata->max_input_current, pdata->max_chrg_current,
1202 pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1203 pdata->virtual_power, pdata->power_dc2otg);
1208 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1214 static int rk818_charger_probe(struct platform_device *pdev)
1216 struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1217 struct rk818_charger *cg;
1220 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1226 cg->dev = &pdev->dev;
1227 cg->regmap = rk818->regmap;
1228 platform_set_drvdata(pdev, cg);
1230 ret = rk818_cg_parse_dt(cg);
1232 dev_err(cg->dev, "parse dt failed!\n");
1236 ret = rk818_cg_init_irqs(cg);
1238 dev_err(cg->dev, "init irqs failed!\n");
1242 ret = rk818_cg_init_dc(cg);
1244 dev_err(cg->dev, "init dc failed!\n");
1248 ret = rk818_cg_init_usb(cg);
1250 dev_err(cg->dev, "init usb failed!\n");
1254 ret = rk818_cg_init_power_supply(cg);
1256 dev_err(cg->dev, "init power supply fail!\n");
1260 rk818_cg_init_charger_state(cg);
1262 CG_INFO("driver version: %s\n", DRIVER_VERSION);
1267 static int rk818_charger_suspend(struct platform_device *pdev,
1270 struct rk818_charger *cg = platform_get_drvdata(pdev);
1272 if (cg->otg_in && cg->dc_in) {
1273 cg->int_msk_reg2 = rk818_reg_read(cg, RK818_INT_STS_MSK_REG2);
1274 rk818_reg_set_bits(cg, RK818_INT_STS_MSK_REG2,
1275 CHRG_CVTLMT_INT_MSK, CHRG_CVTLMT_INT_MSK);
1281 static int rk818_charger_resume(struct platform_device *pdev)
1283 struct rk818_charger *cg = platform_get_drvdata(pdev);
1285 if (cg->otg_in && cg->dc_in)
1286 rk818_reg_write(cg, RK818_INT_STS_MSK_REG2, cg->int_msk_reg2);
1291 static void rk818_charger_shutdown(struct platform_device *pdev)
1293 struct rk818_charger *cg = platform_get_drvdata(pdev);
1295 cancel_delayed_work_sync(&cg->host_work);
1296 cancel_delayed_work_sync(&cg->usb_work);
1297 cancel_delayed_work_sync(&cg->discnt_work);
1298 cancel_delayed_work_sync(&cg->dc_work);
1299 cancel_delayed_work_sync(&cg->finish_sig_work);
1300 cancel_delayed_work_sync(&cg->irq_work);
1301 destroy_workqueue(cg->usb_charger_wq);
1302 destroy_workqueue(cg->dc_charger_wq);
1303 destroy_workqueue(cg->finish_sig_wq);
1305 if (cg->pdata->extcon) {
1306 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1308 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1310 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1312 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_HOST,
1313 &cg->cable_host_nb);
1314 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1315 &cg->cable_discnt_nb);
1317 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1320 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
1321 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1323 CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1324 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1327 static struct platform_driver rk818_charger_driver = {
1328 .probe = rk818_charger_probe,
1329 .suspend = rk818_charger_suspend,
1330 .resume = rk818_charger_resume,
1331 .shutdown = rk818_charger_shutdown,
1333 .name = "rk818-charger",
1337 static int __init charger_init(void)
1339 return platform_driver_register(&rk818_charger_driver);
1341 module_init(charger_init);
1343 static void __exit charger_exit(void)
1345 platform_driver_unregister(&rk818_charger_driver);
1347 module_exit(charger_exit);
1349 MODULE_LICENSE("GPL");
1350 MODULE_ALIAS("platform:rk818-charger");
1351 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");