1 /*
2 * rk818 charger driver
3 *
4 * Copyright (C) 2016 Rockchip Electronics Co., Ltd
5 * chenjh <chenjh@rock-chips.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 */
17
18 #include <linux/delay.h>
19 #include <linux/extcon.h>
20 #include <linux/gpio.h>
21 #include <linux/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>
37 #include "rk818_battery.h"
38
39 static int dbg_enable = 0;
40 module_param_named(dbg_level, dbg_enable, int, 0644);
41
42 #define DBG(args...) \
43 do { \
44 if (dbg_enable) { \
45 pr_info(args); \
46 } \
47 } while (0)
48
49 #define CG_INFO(fmt, args...) pr_info("rk818-charger: "fmt, ##args)
50
51 #define DEFAULT_CHRG_CURRENT 1400
52 #define DEFAULT_INPUT_CURRENT 2000
53 #define DEFAULT_CHRG_VOLTAGE 4200
54 #define SAMPLE_RES_10MR 10
55 #define SAMPLE_RES_20MR 20
56 #define SAMPLE_RES_DIV1 1
57 #define SAMPLE_RES_DIV2 2
58
59 /* RK818_USB_CTRL_REG */
60 #define INPUT_CUR450MA (0x00)
61 #define INPUT_CUR80MA (0x01)
62 #define INPUT_CUR850MA (0x02)
63 #define INPUT_CUR1500MA (0x05)
64 #define INPUT_CUR_MSK (0x0f)
65 /* RK818_CHRG_CTRL_REG3 */
66 #define CHRG_FINISH_MODE_MSK BIT(5)
67 #define CHRG_FINISH_ANA_SIGNAL (0)
68 #define CHRG_FINISH_DIG_SIGNAL BIT(5)
69 /* RK818_SUP_STS_REG */
70 #define BAT_EXS BIT(7)
71 #define USB_VLIMIT_EN BIT(3)
72 #define USB_CLIMIT_EN BIT(2)
73 /* RK818_CHRG_CTRL_REG1 */
74 #define CHRG_EN BIT(7)
75 #define CHRG_CUR_MSK (0x0f)
76 /* RK818_INT_STS_MSK_REG2 */
77 #define CHRG_CVTLMT_INT_MSK BIT(6)
78 #define PLUG_OUT_MSK BIT(1)
79 #define PLUG_IN_MSK BIT(0)
80 /* RK818_VB_MON_REG */
81 #define PLUG_IN_STS BIT(6)
82 /* RK818_TS_CTRL_REG */
83 #define GG_EN BIT(7)
84 #define TS2_FUN_ADC BIT(5)
85 /* RK818_ADC_CTRL_REG */
86 #define ADC_TS2_EN BIT(4)
87
88 #define CG_DRIVER_VERSION "2.0"
89
90 #define DEFAULT_TS2_THRESHOLD_VOL 4350
91 #define DEFAULT_TS2_VALID_VOL 1000
92 #define DEFAULT_TS2_VOL_MULTI 0
93 #define DEFAULT_TS2_CHECK_CNT 5
94
95 enum charger_t {
96 USB_TYPE_UNKNOWN_CHARGER,
97 USB_TYPE_NONE_CHARGER,
98 USB_TYPE_USB_CHARGER,
99 USB_TYPE_AC_CHARGER,
100 USB_TYPE_CDP_CHARGER,
101 DC_TYPE_DC_CHARGER,
102 DC_TYPE_NONE_CHARGER,
103 };
104
105 enum {
106 OFFLINE = 0,
107 ONLINE
108 };
109
110 struct temp_chrg_table {
111 int temp_down;
112 int temp_up;
113 u32 chrg_current;
114 u8 set_chrg_current;
115 };
116
117 struct charger_platform_data {
118 u32 max_input_current;
119 u32 max_chrg_current;
120 u32 max_chrg_voltage;
121 u32 pwroff_vol;
122 u32 power_dc2otg;
123 u32 dc_det_level;
124 int dc_det_pin;
125 bool support_dc_det;
126 int virtual_power;
127 int sample_res;
128 int otg5v_suspend_enable;
129 bool extcon;
130 int ts2_vol_multi;
131 struct temp_chrg_table *tc_table;
132 u32 tc_count;
133 };
134
135 struct rk818_charger {
136 struct platform_device *pdev;
137 struct device *dev;
138 struct rk808 *rk818;
139 struct regmap *regmap;
140 struct power_supply *ac_psy;
141 struct power_supply *usb_psy;
142 struct power_supply *bat_psy;
143 struct extcon_dev *cable_edev;
144 struct charger_platform_data *pdata;
145 struct workqueue_struct *usb_charger_wq;
146 struct workqueue_struct *dc_charger_wq;
147 struct workqueue_struct *finish_sig_wq;
148 struct workqueue_struct *ts2_wq;
149 struct delayed_work dc_work;
150 struct delayed_work usb_work;
151 struct delayed_work host_work;
152 struct delayed_work discnt_work;
153 struct delayed_work finish_sig_work;
154 struct delayed_work irq_work;
155 struct delayed_work ts2_vol_work;
156 struct notifier_block bc_nb;
157 struct notifier_block cable_cg_nb;
158 struct notifier_block cable_host_nb;
159 struct notifier_block cable_discnt_nb;
160 struct notifier_block temp_nb;
161 unsigned int bc_event;
162 enum charger_t usb_charger;
163 enum charger_t dc_charger;
164 struct regulator *otg5v_rdev;
165 u8 ac_in;
166 u8 usb_in;
167 u8 otg_in; /* OTG device attached status */
168 u8 otg_pmic5v; /* OTG device power supply from PMIC */
169 u8 dc_in;
170 u8 prop_status;
171 u8 chrg_voltage;
172 u8 chrg_input;
173 u8 chrg_current;
174 u8 res_div;
175 u8 sleep_set_off_reg1;
176 u8 plugin_trigger;
177 u8 plugout_trigger;
178 int plugin_irq;
179 int plugout_irq;
180 int charger_changed;
181 };
182
rk818_reg_read(struct rk818_charger * cg,u8 reg)183 static int rk818_reg_read(struct rk818_charger *cg, u8 reg)
184 {
185 int ret, val;
186
187 ret = regmap_read(cg->regmap, reg, &val);
188 if (ret)
189 dev_err(cg->dev, "i2c read reg: 0x%2x failed\n", reg);
190
191 return val;
192 }
193
rk818_reg_write(struct rk818_charger * cg,u8 reg,u8 buf)194 static int rk818_reg_write(struct rk818_charger *cg, u8 reg, u8 buf)
195 {
196 int ret;
197
198 ret = regmap_write(cg->regmap, reg, buf);
199 if (ret)
200 dev_err(cg->dev, "i2c write reg: 0x%2x failed\n", reg);
201
202 return ret;
203 }
204
rk818_reg_set_bits(struct rk818_charger * cg,u8 reg,u8 mask,u8 buf)205 static int rk818_reg_set_bits(struct rk818_charger *cg, u8 reg, u8 mask, u8 buf)
206 {
207 int ret;
208
209 ret = regmap_update_bits(cg->regmap, reg, mask, buf);
210 if (ret)
211 dev_err(cg->dev, "i2c set reg: 0x%2x failed\n", reg);
212
213 return ret;
214 }
215
rk818_reg_clear_bits(struct rk818_charger * cg,u8 reg,u8 mask)216 static int rk818_reg_clear_bits(struct rk818_charger *cg, u8 reg, u8 mask)
217 {
218 int ret;
219
220 ret = regmap_update_bits(cg->regmap, reg, mask, 0);
221 if (ret)
222 dev_err(cg->dev, "i2c clr reg: 0x%02x failed\n", reg);
223
224 return ret;
225 }
226
rk818_cg_online(struct rk818_charger * cg)227 static int rk818_cg_online(struct rk818_charger *cg)
228 {
229 return (cg->ac_in | cg->usb_in | cg->dc_in);
230 }
231
rk818_cg_get_dsoc(struct rk818_charger * cg)232 static int rk818_cg_get_dsoc(struct rk818_charger *cg)
233 {
234 return rk818_reg_read(cg, RK818_SOC_REG);
235 }
236
rk818_cg_get_avg_current(struct rk818_charger * cg)237 static int rk818_cg_get_avg_current(struct rk818_charger *cg)
238 {
239 int cur, val = 0;
240
241 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGL) << 0;
242 val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGH) << 8;
243
244 if (val & 0x800)
245 val -= 4096;
246 cur = val * cg->res_div * 1506 / 1000;
247
248 return cur;
249 }
250
rk818_cg_get_ts2_voltage(struct rk818_charger * cg)251 static int rk818_cg_get_ts2_voltage(struct rk818_charger *cg)
252 {
253 u32 val = 0;
254 int voltage;
255
256 val |= rk818_reg_read(cg, RK818_TS2_ADC_REGL) << 0;
257 val |= rk818_reg_read(cg, RK818_TS2_ADC_REGH) << 8;
258
259 /* refer voltage 2.2V, 12bit adc accuracy */
260 voltage = val * 2200 * cg->pdata->ts2_vol_multi / 4095;
261
262 DBG("********* ts2 adc=%d, vol=%d\n", val, voltage);
263
264 return voltage;
265 }
266
get_boot_sec(void)267 static u64 get_boot_sec(void)
268 {
269 struct timespec64 ts;
270
271 ktime_get_boottime_ts64(&ts);
272
273 return ts.tv_sec;
274 }
275
rk818_cg_lowpwr_check(struct rk818_charger * cg)276 static int rk818_cg_lowpwr_check(struct rk818_charger *cg)
277 {
278 u8 buf;
279 static u64 time;
280 int current_avg, dsoc, fake_offline = 0;
281
282 buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
283 if (!(buf & GG_EN))
284 return fake_offline;
285
286 dsoc = rk818_cg_get_dsoc(cg);
287 current_avg = rk818_cg_get_avg_current(cg);
288 if ((current_avg < 0) && (dsoc == 0)) {
289 if (!time)
290 time = get_boot_sec();
291 if ((get_boot_sec() - time) >= 30) {
292 fake_offline = 1;
293 CG_INFO("low power....soc=%d, current=%d\n",
294 dsoc, current_avg);
295 }
296 } else {
297 time = 0;
298 fake_offline = 0;
299 }
300
301 DBG("<%s>. t=%lld, dsoc=%d, current=%d, fake_offline=%d\n",
302 __func__, get_boot_sec() - time, dsoc, current_avg, fake_offline);
303
304 return fake_offline;
305 }
306
rk818_cg_get_bat_psy(struct device * dev,void * data)307 static int rk818_cg_get_bat_psy(struct device *dev, void *data)
308 {
309 struct rk818_charger *cg = data;
310 struct power_supply *psy = dev_get_drvdata(dev);
311
312 if (psy->desc->type == POWER_SUPPLY_TYPE_BATTERY) {
313 cg->bat_psy = psy;
314 return 1;
315 }
316
317 return 0;
318 }
319
rk818_cg_get_psy(struct rk818_charger * cg)320 static void rk818_cg_get_psy(struct rk818_charger *cg)
321 {
322 if (!cg->bat_psy)
323 class_for_each_device(power_supply_class, NULL, (void *)cg,
324 rk818_cg_get_bat_psy);
325 }
326
rk818_cg_get_bat_max_cur(struct rk818_charger * cg)327 static int rk818_cg_get_bat_max_cur(struct rk818_charger *cg)
328 {
329 union power_supply_propval val;
330 int ret;
331
332 rk818_cg_get_psy(cg);
333
334 if (!cg->bat_psy)
335 return cg->pdata->max_chrg_current;
336
337 ret = cg->bat_psy->desc->get_property(cg->bat_psy,
338 POWER_SUPPLY_PROP_CURRENT_MAX,
339 &val);
340 if (!ret && val.intval)
341 return val.intval;
342
343 return cg->pdata->max_chrg_current;
344 }
345
rk818_cg_get_bat_max_vol(struct rk818_charger * cg)346 static int rk818_cg_get_bat_max_vol(struct rk818_charger *cg)
347 {
348 union power_supply_propval val;
349 int ret;
350
351 rk818_cg_get_psy(cg);
352
353 if (!cg->bat_psy)
354 return cg->pdata->max_chrg_voltage;
355
356 ret = cg->bat_psy->desc->get_property(cg->bat_psy,
357 POWER_SUPPLY_PROP_VOLTAGE_MAX,
358 &val);
359 if (!ret && val.intval)
360 return val.intval;
361
362 return cg->pdata->max_chrg_voltage;
363 }
364
365 static enum power_supply_property rk818_ac_props[] = {
366 POWER_SUPPLY_PROP_ONLINE,
367 POWER_SUPPLY_PROP_STATUS,
368 POWER_SUPPLY_PROP_VOLTAGE_MAX,
369 POWER_SUPPLY_PROP_CURRENT_MAX,
370 };
371
372 static enum power_supply_property rk818_usb_props[] = {
373 POWER_SUPPLY_PROP_ONLINE,
374 POWER_SUPPLY_PROP_STATUS,
375 POWER_SUPPLY_PROP_VOLTAGE_MAX,
376 POWER_SUPPLY_PROP_CURRENT_MAX,
377 };
378
rk818_cg_ac_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)379 static int rk818_cg_ac_get_property(struct power_supply *psy,
380 enum power_supply_property psp,
381 union power_supply_propval *val)
382 {
383 struct rk818_charger *cg = power_supply_get_drvdata(psy);
384 int fake_offline = 0, ret = 0;
385
386 if (rk818_cg_online(cg))
387 fake_offline = rk818_cg_lowpwr_check(cg);
388
389 switch (psp) {
390 case POWER_SUPPLY_PROP_ONLINE:
391 if (cg->pdata->virtual_power)
392 val->intval = 1;
393 else if (fake_offline)
394 val->intval = 0;
395 else
396 val->intval = (cg->ac_in | cg->dc_in);
397
398 DBG("report online: %d\n", val->intval);
399 break;
400 case POWER_SUPPLY_PROP_STATUS:
401 if (cg->pdata->virtual_power)
402 val->intval = POWER_SUPPLY_STATUS_CHARGING;
403 else if (fake_offline)
404 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
405 else
406 val->intval = cg->prop_status;
407
408 DBG("report prop: %d\n", val->intval);
409 break;
410 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
411 val->intval = rk818_cg_get_bat_max_vol(cg);
412 break;
413 case POWER_SUPPLY_PROP_CURRENT_MAX:
414 val->intval = rk818_cg_get_bat_max_cur(cg);
415 break;
416 default:
417 ret = -EINVAL;
418 break;
419 }
420
421 return ret;
422 }
423
rk818_cg_usb_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)424 static int rk818_cg_usb_get_property(struct power_supply *psy,
425 enum power_supply_property psp,
426 union power_supply_propval *val)
427 {
428 struct rk818_charger *cg = power_supply_get_drvdata(psy);
429 int fake_offline = 0, ret = 0;
430
431 if (rk818_cg_online(cg))
432 fake_offline = rk818_cg_lowpwr_check(cg);
433
434 switch (psp) {
435 case POWER_SUPPLY_PROP_ONLINE:
436 if (cg->pdata->virtual_power)
437 val->intval = 1;
438 else if (fake_offline)
439 val->intval = 0;
440 else
441 val->intval = cg->usb_in;
442
443 DBG("report online: %d\n", val->intval);
444 break;
445 case POWER_SUPPLY_PROP_STATUS:
446 if (cg->pdata->virtual_power)
447 val->intval = POWER_SUPPLY_STATUS_CHARGING;
448 else if (fake_offline)
449 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
450 else
451 val->intval = cg->prop_status;
452
453 DBG("report prop: %d\n", val->intval);
454 break;
455 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
456 val->intval = rk818_cg_get_bat_max_vol(cg);
457 break;
458 case POWER_SUPPLY_PROP_CURRENT_MAX:
459 val->intval = rk818_cg_get_bat_max_cur(cg);
460 break;
461 default:
462 ret = -EINVAL;
463 break;
464 }
465
466 return ret;
467 }
468
469 static const struct power_supply_desc rk818_ac_desc = {
470 .name = "ac",
471 .type = POWER_SUPPLY_TYPE_MAINS,
472 .properties = rk818_ac_props,
473 .num_properties = ARRAY_SIZE(rk818_ac_props),
474 .get_property = rk818_cg_ac_get_property,
475 };
476
477 static const struct power_supply_desc rk818_usb_desc = {
478 .name = "usb",
479 .type = POWER_SUPPLY_TYPE_USB,
480 .properties = rk818_usb_props,
481 .num_properties = ARRAY_SIZE(rk818_usb_props),
482 .get_property = rk818_cg_usb_get_property,
483 };
484
rk818_cg_init_power_supply(struct rk818_charger * cg)485 static int rk818_cg_init_power_supply(struct rk818_charger *cg)
486 {
487 struct power_supply_config psy_cfg = { .drv_data = cg, };
488
489 cg->usb_psy = devm_power_supply_register(cg->dev, &rk818_usb_desc,
490 &psy_cfg);
491 if (IS_ERR(cg->usb_psy)) {
492 dev_err(cg->dev, "register usb power supply fail\n");
493 return PTR_ERR(cg->usb_psy);
494 }
495
496 cg->ac_psy = devm_power_supply_register(cg->dev, &rk818_ac_desc,
497 &psy_cfg);
498 if (IS_ERR(cg->ac_psy)) {
499 dev_err(cg->dev, "register ac power supply fail\n");
500 return PTR_ERR(cg->ac_psy);
501 }
502
503 return 0;
504 }
505
rk818_cg_pr_info(struct rk818_charger * cg)506 static void rk818_cg_pr_info(struct rk818_charger *cg)
507 {
508 u8 usb_ctrl, chrg_ctrl1;
509
510 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
511 chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
512 CG_INFO("ac=%d usb=%d dc=%d otg=%d 5v=%d, v=%d chrg=%d input=%d virt=%d\n",
513 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in, cg->otg_pmic5v,
514 chrg_vol_sel_array[(chrg_ctrl1 & 0x70) >> 4],
515 chrg_cur_sel_array[chrg_ctrl1 & 0x0f] * cg->res_div,
516 chrg_cur_input_array[usb_ctrl & 0x0f],
517 cg->pdata->virtual_power);
518 }
519
is_battery_exist(struct rk818_charger * cg)520 static bool is_battery_exist(struct rk818_charger *cg)
521 {
522 return (rk818_reg_read(cg, RK818_SUP_STS_REG) & BAT_EXS) ? true : false;
523 }
524
rk818_cg_set_chrg_current(struct rk818_charger * cg,u8 chrg_current)525 static void rk818_cg_set_chrg_current(struct rk818_charger *cg,
526 u8 chrg_current)
527 {
528 u8 chrg_ctrl_reg1;
529
530 chrg_ctrl_reg1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
531 chrg_ctrl_reg1 &= ~CHRG_CUR_MSK;
532 chrg_ctrl_reg1 |= (chrg_current);
533 rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl_reg1);
534 }
535
rk818_cg_set_input_current(struct rk818_charger * cg,int input_current)536 static void rk818_cg_set_input_current(struct rk818_charger *cg,
537 int input_current)
538 {
539 u8 usb_ctrl;
540
541 if (cg->pdata->virtual_power) {
542 CG_INFO("warning: virtual power mode...\n");
543 input_current = cg->chrg_input;
544 }
545
546 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
547 usb_ctrl &= ~INPUT_CUR_MSK;
548 usb_ctrl |= (input_current);
549 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
550 }
551
rk818_cg_set_finish_sig(struct rk818_charger * cg,int mode)552 static void rk818_cg_set_finish_sig(struct rk818_charger *cg, int mode)
553 {
554 u8 buf;
555
556 buf = rk818_reg_read(cg, RK818_CHRG_CTRL_REG3);
557 buf &= ~CHRG_FINISH_MODE_MSK;
558 buf |= mode;
559 rk818_reg_write(cg, RK818_CHRG_CTRL_REG3, buf);
560 }
561
rk818_cg_finish_sig_work(struct work_struct * work)562 static void rk818_cg_finish_sig_work(struct work_struct *work)
563 {
564 struct rk818_charger *cg;
565
566 cg = container_of(work, struct rk818_charger, finish_sig_work.work);
567 if (rk818_cg_online(cg))
568 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
569 else
570 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
571 }
572
rk818_cg_set_chrg_param(struct rk818_charger * cg,enum charger_t charger)573 static void rk818_cg_set_chrg_param(struct rk818_charger *cg,
574 enum charger_t charger)
575 {
576 u8 buf;
577
578 switch (charger) {
579 case USB_TYPE_NONE_CHARGER:
580 cg->usb_in = 0;
581 cg->ac_in = 0;
582 if (cg->dc_in == 0) {
583 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
584 rk818_cg_set_chrg_current(cg, cg->chrg_current);
585 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
586 }
587 power_supply_changed(cg->usb_psy);
588 power_supply_changed(cg->ac_psy);
589 break;
590 case USB_TYPE_USB_CHARGER:
591 cg->usb_in = 1;
592 cg->ac_in = 0;
593 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
594 if (cg->dc_in == 0) {
595 rk818_cg_set_chrg_current(cg, cg->chrg_current);
596 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
597 }
598 power_supply_changed(cg->usb_psy);
599 power_supply_changed(cg->ac_psy);
600 break;
601 case USB_TYPE_CDP_CHARGER:
602 cg->usb_in = 1;
603 cg->ac_in = 0;
604 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
605 if (cg->dc_in == 0) {
606 rk818_cg_set_chrg_current(cg, cg->chrg_current);
607 rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
608 }
609 power_supply_changed(cg->usb_psy);
610 power_supply_changed(cg->ac_psy);
611 break;
612 case USB_TYPE_AC_CHARGER:
613 cg->ac_in = 1;
614 cg->usb_in = 0;
615 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
616 if (charger == USB_TYPE_AC_CHARGER) {
617 if (cg->pdata->ts2_vol_multi) {
618 rk818_cg_set_chrg_current(cg, cg->chrg_current);
619 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
620 queue_delayed_work(cg->ts2_wq,
621 &cg->ts2_vol_work,
622 msecs_to_jiffies(0));
623 } else {
624 rk818_cg_set_chrg_current(cg, cg->chrg_current);
625 rk818_cg_set_input_current(cg, cg->chrg_input);
626 }
627 } else {
628 rk818_cg_set_chrg_current(cg, cg->chrg_current);
629 rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
630 }
631 power_supply_changed(cg->usb_psy);
632 power_supply_changed(cg->ac_psy);
633 break;
634 case DC_TYPE_DC_CHARGER:
635 cg->dc_in = 1;
636 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
637 if (cg->pdata->ts2_vol_multi) {
638 rk818_cg_set_chrg_current(cg, cg->chrg_current);
639 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
640 queue_delayed_work(cg->ts2_wq,
641 &cg->ts2_vol_work,
642 msecs_to_jiffies(0));
643 } else {
644 rk818_cg_set_chrg_current(cg, cg->chrg_current);
645 rk818_cg_set_input_current(cg, cg->chrg_input);
646 }
647 power_supply_changed(cg->usb_psy);
648 power_supply_changed(cg->ac_psy);
649 break;
650 case DC_TYPE_NONE_CHARGER:
651 cg->dc_in = 0;
652 buf = rk818_reg_read(cg, RK818_VB_MON_REG);
653 if ((buf & PLUG_IN_STS) == 0) {
654 cg->ac_in = 0;
655 cg->usb_in = 0;
656 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
657 rk818_cg_set_chrg_current(cg, cg->chrg_current);
658 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
659 } else if (cg->usb_in) {
660 rk818_cg_set_chrg_current(cg, cg->chrg_current);
661 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
662 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
663 }
664 power_supply_changed(cg->usb_psy);
665 power_supply_changed(cg->ac_psy);
666 break;
667 default:
668 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
669 break;
670 }
671
672 cg->charger_changed = 1;
673
674 if (rk818_cg_online(cg) && rk818_cg_get_dsoc(cg) == 100)
675 cg->prop_status = POWER_SUPPLY_STATUS_FULL;
676
677 if (cg->finish_sig_wq)
678 queue_delayed_work(cg->finish_sig_wq, &cg->finish_sig_work,
679 msecs_to_jiffies(1000));
680 }
681
rk818_cg_set_otg_in(struct rk818_charger * cg,int online)682 static void rk818_cg_set_otg_in(struct rk818_charger *cg, int online)
683 {
684 cg->otg_in = online;
685 }
686
rk818_cg_set_otg_power(struct rk818_charger * cg,int state)687 static void rk818_cg_set_otg_power(struct rk818_charger *cg, int state)
688 {
689 int ret;
690
691 switch (state) {
692 case USB_OTG_POWER_ON:
693 if (cg->otg_pmic5v) {
694 CG_INFO("otg5v is on yet, ignore..\n");
695 } else {
696 if (IS_ERR(cg->otg5v_rdev)) {
697 CG_INFO("not get otg_switch regulator!\n");
698 return;
699 }
700
701 if (!regulator_is_enabled(cg->otg5v_rdev)) {
702 ret = regulator_enable(cg->otg5v_rdev);
703 if (ret) {
704 CG_INFO("enable otg5v failed:%d\n",
705 ret);
706 return;
707 }
708 }
709 cg->otg_pmic5v = 1;
710 disable_irq(cg->plugin_irq);
711 disable_irq(cg->plugout_irq);
712 CG_INFO("enable otg5v\n");
713 }
714 break;
715
716 case USB_OTG_POWER_OFF:
717 if (!cg->otg_pmic5v) {
718 CG_INFO("otg5v is off yet, ignore..\n");
719 } else {
720 if (IS_ERR(cg->otg5v_rdev)) {
721 CG_INFO("not get otg_switch regulator!\n");
722 return;
723 }
724
725 if (regulator_is_enabled(cg->otg5v_rdev)) {
726 ret = regulator_disable(cg->otg5v_rdev);
727 if (ret) {
728 CG_INFO("disable otg5v failed: %d\n",
729 ret);
730 return;
731 }
732 }
733 cg->otg_pmic5v = 0;
734 enable_irq(cg->plugin_irq);
735 enable_irq(cg->plugout_irq);
736 CG_INFO("disable otg5v\n");
737 }
738 break;
739 default:
740 dev_err(cg->dev, "error otg type\n");
741 break;
742 }
743 }
744
rk818_cg_get_dc_state(struct rk818_charger * cg)745 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
746 {
747 int level;
748
749 if (!gpio_is_valid(cg->pdata->dc_det_pin))
750 return DC_TYPE_NONE_CHARGER;
751
752 level = gpio_get_value(cg->pdata->dc_det_pin);
753
754 return (level == cg->pdata->dc_det_level) ?
755 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
756 }
757
rk818_cg_dc_det_worker(struct work_struct * work)758 static void rk818_cg_dc_det_worker(struct work_struct *work)
759 {
760 enum charger_t charger;
761 struct rk818_charger *cg = container_of(work,
762 struct rk818_charger, dc_work.work);
763
764 charger = rk818_cg_get_dc_state(cg);
765 if (charger == DC_TYPE_DC_CHARGER) {
766 CG_INFO("detect dc charger in..\n");
767 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
768 /* check otg supply */
769 if (cg->otg_in && cg->pdata->power_dc2otg) {
770 CG_INFO("otg power from dc adapter\n");
771 rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
772 }
773 } else {
774 CG_INFO("detect dc charger out..\n");
775 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
776 /* check otg supply, power on anyway */
777 if (cg->otg_in)
778 rk818_cg_set_otg_power(cg, USB_OTG_POWER_ON);
779 }
780
781 rk_send_wakeup_key();
782 rk818_cg_pr_info(cg);
783 }
784
rk818_cg_decode_chrg_vol(struct rk818_charger * cg,u32 chrg_vol)785 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg, u32 chrg_vol)
786 {
787 u8 val = 0, index;
788
789 for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
790 if (chrg_vol < chrg_vol_sel_array[index])
791 break;
792 val = index << 4;
793 }
794
795 return val;
796 }
797
rk818_cg_decode_input_current(struct rk818_charger * cg,u32 input_current)798 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg,
799 u32 input_current)
800 {
801 u8 val = 0, index;
802
803 for (index = 2; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
804 if (input_current < 850 && input_current > 80) {
805 val = 0x0; /* 450mA */
806 break;
807 } else if (input_current <= 80) {
808 val = 0x1; /* 80mA */
809 break;
810 } else {
811 if (input_current < chrg_cur_input_array[index])
812 break;
813 val = index << 0;
814 }
815 }
816
817 return val;
818 }
819
rk818_cg_decode_chrg_current(struct rk818_charger * cg,u32 chrg_current)820 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg,
821 u32 chrg_current)
822 {
823 u8 val = 0, index;
824
825 if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
826 if (chrg_current > 2000)
827 chrg_current /= cg->res_div;
828 else
829 chrg_current = 1000;
830 }
831
832 for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
833 if (chrg_current < chrg_cur_sel_array[index])
834 break;
835 val = index << 0;
836 }
837
838 return val;
839 }
840
rk818_cg_init_config(struct rk818_charger * cg)841 static void rk818_cg_init_config(struct rk818_charger *cg)
842 {
843 u8 usb_ctrl, sup_sts, chrg_ctrl1;
844
845 cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg,
846 cg->pdata->max_chrg_voltage);
847 cg->chrg_current = rk818_cg_decode_chrg_current(cg,
848 cg->pdata->max_chrg_current);
849 cg->chrg_input = rk818_cg_decode_input_current(cg,
850 cg->pdata->max_input_current);
851
852 sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
853 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
854
855 /* set charge current and voltage */
856 usb_ctrl &= ~INPUT_CUR_MSK;
857 usb_ctrl |= cg->chrg_input;
858 chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
859
860 /* disable voltage limit and enable input current limit */
861 sup_sts &= ~USB_VLIMIT_EN;
862 sup_sts |= USB_CLIMIT_EN;
863
864 rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
865 rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
866 rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
867 }
868
rk818_ts2_vol_work(struct work_struct * work)869 static void rk818_ts2_vol_work(struct work_struct *work)
870 {
871 struct rk818_charger *cg;
872 int ts2_vol, input_current, invalid_cnt = 0, confirm_cnt = 0;
873
874 cg = container_of(work, struct rk818_charger, ts2_vol_work.work);
875
876 input_current = INPUT_CUR80MA;
877 while (input_current < cg->chrg_input) {
878 msleep(100);
879 ts2_vol = rk818_cg_get_ts2_voltage(cg);
880
881 /* filter invalid voltage */
882 if (ts2_vol <= DEFAULT_TS2_VALID_VOL) {
883 invalid_cnt++;
884 DBG("%s: invalid ts2 voltage: %d\n, cnt=%d",
885 __func__, ts2_vol, invalid_cnt);
886 if (invalid_cnt < DEFAULT_TS2_CHECK_CNT)
887 continue;
888
889 /* if fail, set max input current as default */
890 input_current = cg->chrg_input;
891 rk818_cg_set_input_current(cg, input_current);
892 break;
893 }
894
895 /* update input current */
896 if (ts2_vol >= DEFAULT_TS2_THRESHOLD_VOL) {
897 /* update input current */
898 input_current++;
899 rk818_cg_set_input_current(cg, input_current);
900 DBG("********* input=%d\n",
901 chrg_cur_input_array[input_current & 0x0f]);
902 } else {
903 /* confirm lower threshold voltage */
904 confirm_cnt++;
905 if (confirm_cnt < DEFAULT_TS2_CHECK_CNT) {
906 DBG("%s: confirm ts2 voltage: %d\n, cnt=%d",
907 __func__, ts2_vol, confirm_cnt);
908 continue;
909 }
910
911 /* trigger threshold, so roll back 1 step */
912 input_current--;
913 if (input_current == INPUT_CUR80MA ||
914 input_current < 0)
915 input_current = INPUT_CUR450MA;
916 rk818_cg_set_input_current(cg, input_current);
917 break;
918 }
919 }
920
921 if (input_current != cg->chrg_input)
922 CG_INFO("adjust input current: %dma\n",
923 chrg_cur_input_array[input_current & 0x0f]);
924 }
925
rk818_cg_charger_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)926 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
927 unsigned long event, void *ptr)
928 {
929 struct rk818_charger *cg =
930 container_of(nb, struct rk818_charger, cable_cg_nb);
931
932 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
933 msecs_to_jiffies(10));
934
935 return NOTIFY_DONE;
936 }
937
rk818_cg_discnt_evt_notfier(struct notifier_block * nb,unsigned long event,void * ptr)938 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
939 unsigned long event, void *ptr)
940 {
941 struct rk818_charger *cg =
942 container_of(nb, struct rk818_charger, cable_discnt_nb);
943
944 queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
945 msecs_to_jiffies(10));
946
947 return NOTIFY_DONE;
948 }
949
rk818_cg_host_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)950 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
951 unsigned long event, void *ptr)
952 {
953 struct rk818_charger *cg =
954 container_of(nb, struct rk818_charger, cable_host_nb);
955
956 queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
957 msecs_to_jiffies(10));
958
959 return NOTIFY_DONE;
960 }
961
rk818_cg_bc_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)962 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
963 unsigned long event, void *ptr)
964 {
965 struct rk818_charger *cg =
966 container_of(nb, struct rk818_charger, bc_nb);
967
968 cg->bc_event = event;
969 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
970 msecs_to_jiffies(10));
971
972 return NOTIFY_DONE;
973 }
974
rk818_cg_bc_evt_worker(struct work_struct * work)975 static void rk818_cg_bc_evt_worker(struct work_struct *work)
976 {
977 struct rk818_charger *cg = container_of(work,
978 struct rk818_charger, usb_work.work);
979 const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
980 "UNKNOWN", "OTG ON", "OTG OFF"};
981
982 switch (cg->bc_event) {
983 case USB_BC_TYPE_DISCNT:
984 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
985 break;
986 case USB_BC_TYPE_SDP:
987 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
988 break;
989 case USB_BC_TYPE_DCP:
990 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
991 break;
992 case USB_BC_TYPE_CDP:
993 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
994 break;
995 case USB_OTG_POWER_ON:
996 rk818_cg_set_otg_in(cg, ONLINE);
997 if (cg->pdata->power_dc2otg && cg->dc_in)
998 CG_INFO("otg power from dc adapter\n");
999 else
1000 rk818_cg_set_otg_power(cg, USB_OTG_POWER_ON);
1001 break;
1002 case USB_OTG_POWER_OFF:
1003 rk818_cg_set_otg_in(cg, OFFLINE);
1004 rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
1005 break;
1006 default:
1007 break;
1008 }
1009
1010 CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
1011
1012 rk818_cg_pr_info(cg);
1013 }
1014
rk818_cg_irq_delay_work(struct work_struct * work)1015 static void rk818_cg_irq_delay_work(struct work_struct *work)
1016 {
1017 struct rk818_charger *cg = container_of(work,
1018 struct rk818_charger, irq_work.work);
1019
1020 if (cg->plugin_trigger) {
1021 CG_INFO("pmic: plug in\n");
1022 cg->plugin_trigger = 0;
1023 rk_send_wakeup_key();
1024 if (cg->pdata->extcon)
1025 queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
1026 msecs_to_jiffies(10));
1027 } else if (cg->plugout_trigger) {
1028 CG_INFO("pmic: plug out\n");
1029 cg->plugout_trigger = 0;
1030 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
1031 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
1032 rk_send_wakeup_key();
1033 rk818_cg_pr_info(cg);
1034 } else {
1035 CG_INFO("pmic: unknown irq\n");
1036 }
1037 }
1038
rk818_plug_in_isr(int irq,void * cg)1039 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
1040 {
1041 struct rk818_charger *icg;
1042
1043 icg = (struct rk818_charger *)cg;
1044 icg->plugin_trigger = 1;
1045 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
1046 msecs_to_jiffies(10));
1047
1048 return IRQ_HANDLED;
1049 }
1050
rk818_plug_out_isr(int irq,void * cg)1051 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
1052 {
1053 struct rk818_charger *icg;
1054
1055 icg = (struct rk818_charger *)cg;
1056 icg->plugout_trigger = 1;
1057 queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
1058 msecs_to_jiffies(10));
1059
1060 return IRQ_HANDLED;
1061 }
1062
rk818_dc_det_isr(int irq,void * charger)1063 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
1064 {
1065 struct rk818_charger *cg = (struct rk818_charger *)charger;
1066
1067 if (gpio_get_value(cg->pdata->dc_det_pin))
1068 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
1069 else
1070 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
1071
1072 queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
1073 msecs_to_jiffies(10));
1074
1075 return IRQ_HANDLED;
1076 }
1077
rk818_cg_init_irqs(struct rk818_charger * cg)1078 static int rk818_cg_init_irqs(struct rk818_charger *cg)
1079 {
1080 struct rk808 *rk818 = cg->rk818;
1081 struct platform_device *pdev = cg->pdev;
1082 int ret, plug_in_irq, plug_out_irq;
1083
1084 plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
1085 if (plug_in_irq < 0) {
1086 dev_err(cg->dev, "plug_in_irq request failed!\n");
1087 return plug_in_irq;
1088 }
1089
1090 plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
1091 if (plug_out_irq < 0) {
1092 dev_err(cg->dev, "plug_out_irq request failed!\n");
1093 return plug_out_irq;
1094 }
1095
1096 ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
1097 rk818_plug_in_isr,
1098 IRQF_TRIGGER_RISING,
1099 "rk818_plug_in", cg);
1100 if (ret) {
1101 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
1102 return ret;
1103 }
1104
1105 ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
1106 rk818_plug_out_isr,
1107 IRQF_TRIGGER_FALLING,
1108 "rk818_plug_out", cg);
1109 if (ret) {
1110 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
1111 return ret;
1112 }
1113
1114 cg->plugin_irq = plug_in_irq;
1115 cg->plugout_irq = plug_out_irq;
1116
1117 INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
1118
1119 return 0;
1120 }
1121
rk818_cg_init_dc(struct rk818_charger * cg)1122 static int rk818_cg_init_dc(struct rk818_charger *cg)
1123 {
1124 int ret, level;
1125 unsigned long irq_flags;
1126 unsigned int dc_det_irq;
1127
1128 cg->dc_charger_wq = alloc_ordered_workqueue("%s",
1129 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1130 "rk818-dc-wq");
1131 INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
1132 cg->dc_charger = DC_TYPE_NONE_CHARGER;
1133
1134 if (!cg->pdata->support_dc_det)
1135 return 0;
1136
1137 ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
1138 if (ret < 0) {
1139 dev_err(cg->dev, "failed to request gpio %d\n",
1140 cg->pdata->dc_det_pin);
1141 return ret;
1142 }
1143
1144 ret = gpio_direction_input(cg->pdata->dc_det_pin);
1145 if (ret) {
1146 dev_err(cg->dev, "failed to set gpio input\n");
1147 return ret;
1148 }
1149
1150 level = gpio_get_value(cg->pdata->dc_det_pin);
1151 if (level == cg->pdata->dc_det_level)
1152 cg->dc_charger = DC_TYPE_DC_CHARGER;
1153 else
1154 cg->dc_charger = DC_TYPE_NONE_CHARGER;
1155
1156 if (level)
1157 irq_flags = IRQF_TRIGGER_LOW;
1158 else
1159 irq_flags = IRQF_TRIGGER_HIGH;
1160
1161 dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
1162 ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
1163 irq_flags, "rk818_dc_det", cg);
1164 if (ret != 0) {
1165 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
1166 return ret;
1167 }
1168
1169 enable_irq_wake(dc_det_irq);
1170
1171 return 0;
1172 }
1173
rk818_cg_discnt_evt_worker(struct work_struct * work)1174 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
1175 {
1176 struct rk818_charger *cg = container_of(work,
1177 struct rk818_charger, discnt_work.work);
1178
1179 if (extcon_get_state(cg->cable_edev, EXTCON_USB) == 0) {
1180 CG_INFO("receive type-c notifier event: DISCNT...\n");
1181 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
1182 rk818_cg_pr_info(cg);
1183 }
1184 }
1185
rk818_cg_host_evt_worker(struct work_struct * work)1186 static void rk818_cg_host_evt_worker(struct work_struct *work)
1187 {
1188 struct rk818_charger *cg = container_of(work,
1189 struct rk818_charger, host_work.work);
1190 struct extcon_dev *edev = cg->cable_edev;
1191
1192 /* Determine charger type */
1193 if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) > 0) {
1194 rk818_cg_set_otg_in(cg, ONLINE);
1195 CG_INFO("receive type-c notifier event: OTG ON...\n");
1196 if (cg->dc_in && cg->pdata->power_dc2otg)
1197 CG_INFO("otg power from dc adapter\n");
1198 else
1199 rk818_cg_set_otg_power(cg, USB_OTG_POWER_ON);
1200 } else if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) == 0) {
1201 CG_INFO("receive type-c notifier event: OTG OFF...\n");
1202 rk818_cg_set_otg_in(cg, OFFLINE);
1203 rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
1204 }
1205
1206 rk818_cg_pr_info(cg);
1207 }
1208
rk818_cg_charger_evt_worker(struct work_struct * work)1209 static void rk818_cg_charger_evt_worker(struct work_struct *work)
1210 {
1211 struct rk818_charger *cg = container_of(work,
1212 struct rk818_charger, usb_work.work);
1213 struct extcon_dev *edev = cg->cable_edev;
1214 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
1215 const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
1216
1217 /* Determine charger type */
1218 if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0)
1219 charger = USB_TYPE_USB_CHARGER;
1220 else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0)
1221 charger = USB_TYPE_AC_CHARGER;
1222 else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0)
1223 charger = USB_TYPE_CDP_CHARGER;
1224
1225 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
1226 CG_INFO("receive type-c notifier event: %s...\n",
1227 event[charger]);
1228 cg->usb_charger = charger;
1229 rk818_cg_set_chrg_param(cg, charger);
1230 rk818_cg_pr_info(cg);
1231 }
1232 }
1233
rk818_cg_init_usb(struct rk818_charger * cg)1234 static long rk818_cg_init_usb(struct rk818_charger *cg)
1235 {
1236 enum charger_t charger;
1237 enum bc_port_type bc_type;
1238 struct extcon_dev *edev;
1239 struct device *dev = cg->dev;
1240 int ret;
1241
1242 cg->usb_charger_wq = alloc_ordered_workqueue("%s",
1243 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1244 "rk818-usb-wq");
1245 cg->usb_charger = USB_TYPE_NONE_CHARGER;
1246
1247 /* type-C */
1248 if (cg->pdata->extcon) {
1249 edev = extcon_get_edev_by_phandle(dev->parent, 0);
1250 if (IS_ERR(edev)) {
1251 if (PTR_ERR(edev) != -EPROBE_DEFER)
1252 dev_err(dev, "Invalid or missing extcon\n");
1253 return PTR_ERR(edev);
1254 }
1255
1256 /* Register chargers */
1257 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
1258 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
1259 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
1260 &cg->cable_cg_nb);
1261 if (ret < 0) {
1262 dev_err(dev, "failed to register notifier for SDP\n");
1263 return ret;
1264 }
1265
1266 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1267 &cg->cable_cg_nb);
1268 if (ret < 0) {
1269 dev_err(dev, "failed to register notifier for DCP\n");
1270 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1271 &cg->cable_cg_nb);
1272 return ret;
1273 }
1274
1275 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1276 &cg->cable_cg_nb);
1277 if (ret < 0) {
1278 dev_err(dev, "failed to register notifier for CDP\n");
1279 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1280 &cg->cable_cg_nb);
1281 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1282 &cg->cable_cg_nb);
1283 return ret;
1284 }
1285
1286 /* Register host */
1287 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1288 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1289 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
1290 &cg->cable_host_nb);
1291 if (ret < 0) {
1292 dev_err(dev, "failed to register notifier for HOST\n");
1293 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1294 &cg->cable_cg_nb);
1295 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1296 &cg->cable_cg_nb);
1297 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1298 &cg->cable_cg_nb);
1299
1300 return ret;
1301 }
1302
1303 /* Register discnt usb */
1304 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1305 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1306 ret = extcon_register_notifier(edev, EXTCON_USB,
1307 &cg->cable_discnt_nb);
1308 if (ret < 0) {
1309 dev_err(dev, "failed to register notifier for HOST\n");
1310 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1311 &cg->cable_cg_nb);
1312 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1313 &cg->cable_cg_nb);
1314 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1315 &cg->cable_cg_nb);
1316 extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
1317 &cg->cable_host_nb);
1318 return ret;
1319 }
1320
1321 cg->cable_edev = edev;
1322
1323 schedule_delayed_work(&cg->host_work, 0);
1324 schedule_delayed_work(&cg->usb_work, 0);
1325
1326 CG_INFO("register typec extcon evt notifier\n");
1327 } else {
1328 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1329 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1330 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1331 if (ret) {
1332 dev_err(dev, "failed to register notifier for bc\n");
1333 return -EINVAL;
1334 }
1335
1336 switch (bc_type) {
1337 case USB_BC_TYPE_DISCNT:
1338 charger = USB_TYPE_NONE_CHARGER;
1339 break;
1340 case USB_BC_TYPE_SDP:
1341 case USB_BC_TYPE_CDP:
1342 charger = USB_TYPE_USB_CHARGER;
1343 break;
1344 case USB_BC_TYPE_DCP:
1345 charger = USB_TYPE_AC_CHARGER;
1346 break;
1347 default:
1348 charger = USB_TYPE_NONE_CHARGER;
1349 break;
1350 }
1351
1352 cg->usb_charger = charger;
1353 CG_INFO("register bc evt notifier\n");
1354 }
1355
1356 return 0;
1357 }
1358
rk818_cg_init_finish_sig(struct rk818_charger * cg)1359 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1360 {
1361 if (rk818_cg_online(cg))
1362 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1363 else
1364 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1365
1366 cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1367 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1368 "rk818-finish-sig-wq");
1369 INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1370 }
1371
rk818_cg_init_ts2_detect(struct rk818_charger * cg)1372 static void rk818_cg_init_ts2_detect(struct rk818_charger *cg)
1373 {
1374 u8 buf;
1375
1376 cg->ts2_wq = alloc_ordered_workqueue("%s",
1377 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1378 "rk818-ts2-wq");
1379 INIT_DELAYED_WORK(&cg->ts2_vol_work, rk818_ts2_vol_work);
1380
1381 if (!cg->pdata->ts2_vol_multi)
1382 return;
1383
1384 /* TS2 adc mode */
1385 buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
1386 buf |= TS2_FUN_ADC;
1387 rk818_reg_write(cg, RK818_TS_CTRL_REG, buf);
1388
1389 /* TS2 adc enable */
1390 buf = rk818_reg_read(cg, RK818_ADC_CTRL_REG);
1391 buf |= ADC_TS2_EN;
1392 rk818_reg_write(cg, RK818_ADC_CTRL_REG, buf);
1393
1394 CG_INFO("enable ts2 voltage detect, multi=%d\n",
1395 cg->pdata->ts2_vol_multi);
1396 }
1397
rk818_cg_init_charger_state(struct rk818_charger * cg)1398 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1399 {
1400 rk818_cg_init_config(cg);
1401 rk818_cg_init_finish_sig(cg);
1402 rk818_cg_set_chrg_param(cg, cg->dc_charger);
1403 rk818_cg_set_chrg_param(cg, cg->usb_charger);
1404
1405 if (cg->otg_in && cg->dc_in && cg->pdata->power_dc2otg) {
1406 CG_INFO("otg power from dc adapter\n");
1407 rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
1408 }
1409
1410 CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d, 5v=%d\n",
1411 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in, cg->otg_pmic5v);
1412 }
1413
rk818_cg_temperature_notifier_call(struct notifier_block * nb,unsigned long temp,void * data)1414 static int rk818_cg_temperature_notifier_call(struct notifier_block *nb,
1415 unsigned long temp, void *data)
1416 {
1417 struct rk818_charger *cg =
1418 container_of(nb, struct rk818_charger, temp_nb);
1419 static int temp_triggered, config_index = -1;
1420 int i, up_temp, down_temp, cfg_current;
1421 int now_temp = temp;
1422 u8 usb_ctrl, chrg_ctrl1;
1423
1424 DBG("%s: receive notify temperature = %d\n", __func__, now_temp);
1425 for (i = 0; i < cg->pdata->tc_count; i++) {
1426 up_temp = cg->pdata->tc_table[i].temp_up;
1427 down_temp = cg->pdata->tc_table[i].temp_down;
1428 cfg_current = cg->pdata->tc_table[i].chrg_current;
1429
1430 if (now_temp >= down_temp && now_temp <= up_temp) {
1431 /* Temp range or charger are not update, return */
1432 if (config_index == i && !cg->charger_changed)
1433 return NOTIFY_DONE;
1434
1435 config_index = i;
1436 cg->charger_changed = 0;
1437 temp_triggered = 1;
1438
1439 if (cg->pdata->tc_table[i].set_chrg_current) {
1440 rk818_cg_set_chrg_current(cg, cfg_current);
1441 CG_INFO("temperature = %d'C[%d~%d'C], "
1442 "chrg current = %d\n",
1443 now_temp, down_temp, up_temp,
1444 chrg_cur_sel_array[cfg_current] *
1445 cg->res_div);
1446 } else {
1447 rk818_cg_set_input_current(cg, cfg_current);
1448 CG_INFO("temperature = %d'C[%d~%d'C], "
1449 "input current = %d\n",
1450 now_temp, down_temp, up_temp,
1451 chrg_cur_input_array[cfg_current]);
1452 }
1453 return NOTIFY_DONE;
1454 }
1455 }
1456
1457 /*
1458 * means: current temperature not covers above case, temperature rolls
1459 * back to normal range, so restore default value
1460 */
1461 if (temp_triggered) {
1462 temp_triggered = 0;
1463 config_index = -1;
1464 rk818_cg_set_chrg_current(cg, cg->chrg_current);
1465 if (cg->ac_in || cg->dc_in)
1466 rk818_cg_set_input_current(cg, cg->chrg_input);
1467 else
1468 rk818_cg_set_input_current(cg, INPUT_CUR450MA);
1469 usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
1470 chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
1471 CG_INFO("roll back temp %d'C, current chrg = %d, input = %d\n",
1472 now_temp,
1473 chrg_cur_sel_array[(chrg_ctrl1 & 0x0f)] * cg->res_div,
1474 chrg_cur_input_array[(usb_ctrl & 0x0f)]);
1475 }
1476
1477 return NOTIFY_DONE;
1478 }
1479
parse_temperature_chrg_table(struct rk818_charger * cg,struct device_node * np)1480 static int parse_temperature_chrg_table(struct rk818_charger *cg,
1481 struct device_node *np)
1482 {
1483 int size, count;
1484 int i, chrg_current;
1485 const __be32 *list;
1486
1487 if (!of_find_property(np, "temperature_chrg_table_v2", &size))
1488 return 0;
1489
1490 list = of_get_property(np, "temperature_chrg_table_v2", &size);
1491 size /= sizeof(u32);
1492 if (!size || (size % 3)) {
1493 dev_err(cg->dev,
1494 "invalid temperature_chrg_table: size=%d\n", size);
1495 return -EINVAL;
1496 }
1497
1498 count = size / 3;
1499 cg->pdata->tc_count = count;
1500 cg->pdata->tc_table = devm_kzalloc(cg->dev,
1501 count * sizeof(*cg->pdata->tc_table),
1502 GFP_KERNEL);
1503 if (!cg->pdata->tc_table)
1504 return -ENOMEM;
1505
1506 for (i = 0; i < count; i++) {
1507 /* temperature */
1508 cg->pdata->tc_table[i].temp_down = be32_to_cpu(*list++);
1509 cg->pdata->tc_table[i].temp_up = be32_to_cpu(*list++);
1510
1511 /*
1512 * because charge current lowest level is 1000mA:
1513 * higher than or equal 1000ma, select charge current;
1514 * lower than 1000ma, must select input current.
1515 */
1516 chrg_current = be32_to_cpu(*list++);
1517 if (chrg_current >= 1000) {
1518 cg->pdata->tc_table[i].set_chrg_current = 1;
1519 cg->pdata->tc_table[i].chrg_current =
1520 rk818_cg_decode_chrg_current(cg, chrg_current);
1521 } else {
1522 cg->pdata->tc_table[i].chrg_current =
1523 rk818_cg_decode_input_current(cg, chrg_current);
1524 }
1525
1526 DBG("temp%d: [%d, %d], chrg_current=%d\n",
1527 i, cg->pdata->tc_table[i].temp_down,
1528 cg->pdata->tc_table[i].temp_up,
1529 cg->pdata->tc_table[i].chrg_current);
1530 }
1531
1532 return 0;
1533
1534 }
1535
rk818_cg_register_temp_notifier(struct rk818_charger * cg)1536 static int rk818_cg_register_temp_notifier(struct rk818_charger *cg)
1537 {
1538 int ret;
1539
1540 if (!cg->pdata->tc_count)
1541 return 0;
1542 cg->temp_nb.notifier_call = rk818_cg_temperature_notifier_call,
1543 ret = rk818_bat_temp_notifier_register(&cg->temp_nb);
1544 if (ret) {
1545 dev_err(cg->dev,
1546 "battery temperature notify register failed:%d\n", ret);
1547 return ret;
1548 }
1549
1550 CG_INFO("enable set charge current by temperature\n");
1551
1552 return 0;
1553 }
1554
rk818_cg_get_otg5v_regulator(struct rk818_charger * cg)1555 static int rk818_cg_get_otg5v_regulator(struct rk818_charger *cg)
1556 {
1557 int ret;
1558
1559 /* not necessary */
1560 cg->otg5v_rdev = devm_regulator_get(cg->dev, "otg_switch");
1561 if (IS_ERR(cg->otg5v_rdev)) {
1562 ret = PTR_ERR(cg->otg5v_rdev);
1563 dev_warn(cg->dev, "failed to get otg regulator: %d\n", ret);
1564 }
1565
1566 return 0;
1567 }
1568
1569 #ifdef CONFIG_OF
rk818_cg_parse_dt(struct rk818_charger * cg)1570 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1571 {
1572 struct device_node *np;
1573 struct charger_platform_data *pdata;
1574 enum of_gpio_flags flags;
1575 struct device *dev = cg->dev;
1576 int ret;
1577
1578 np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1579 if (!np) {
1580 dev_err(dev, "battery node not found!\n");
1581 return -ENODEV;
1582 }
1583
1584 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1585 if (!pdata)
1586 return -ENOMEM;
1587
1588 cg->pdata = pdata;
1589 pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1590 pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1591 pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1592
1593 pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1594
1595 ret = of_property_read_u32(np, "max_chrg_current",
1596 &pdata->max_chrg_current);
1597 if (ret < 0)
1598 dev_err(dev, "max_chrg_current missing!\n");
1599
1600 ret = of_property_read_u32(np, "max_input_current",
1601 &pdata->max_input_current);
1602 if (ret < 0)
1603 dev_err(dev, "max_input_current missing!\n");
1604
1605 ret = of_property_read_u32(np, "max_chrg_voltage",
1606 &pdata->max_chrg_voltage);
1607 if (ret < 0)
1608 dev_err(dev, "max_chrg_voltage missing!\n");
1609
1610 ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1611 if (ret < 0)
1612 dev_err(dev, "virtual_power missing!\n");
1613
1614 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1615 if (ret < 0)
1616 dev_err(dev, "power_dc2otg missing!\n");
1617
1618 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1619 if (ret < 0) {
1620 pdata->sample_res = SAMPLE_RES_20MR;
1621 dev_err(dev, "sample_res missing!\n");
1622 }
1623
1624 ret = of_property_read_u32(np, "otg5v_suspend_enable",
1625 &pdata->otg5v_suspend_enable);
1626 if (ret < 0) {
1627 pdata->otg5v_suspend_enable = 1;
1628 dev_err(dev, "otg5v_suspend_enable missing!\n");
1629 }
1630
1631 ret = of_property_read_u32(np, "ts2_vol_multi",
1632 &pdata->ts2_vol_multi);
1633
1634 if (!is_battery_exist(cg))
1635 pdata->virtual_power = 1;
1636
1637 cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1638 SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1639
1640 if (!of_find_property(np, "dc_det_gpio", &ret)) {
1641 pdata->support_dc_det = false;
1642 CG_INFO("not support dc\n");
1643 } else {
1644 pdata->support_dc_det = true;
1645 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1646 0, &flags);
1647 if (gpio_is_valid(pdata->dc_det_pin)) {
1648 CG_INFO("support dc\n");
1649 pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1650 0 : 1;
1651 } else {
1652 dev_err(dev, "invalid dc det gpio!\n");
1653 return -EINVAL;
1654 }
1655 }
1656
1657 ret = parse_temperature_chrg_table(cg, np);
1658 if (ret)
1659 return ret;
1660
1661 DBG("input_current:%d\n"
1662 "chrg_current:%d\n"
1663 "chrg_voltage:%d\n"
1664 "sample_res:%d\n"
1665 "extcon:%d\n"
1666 "ts2_vol_multi:%d\n"
1667 "virtual_power:%d\n"
1668 "power_dc2otg:%d\n",
1669 pdata->max_input_current, pdata->max_chrg_current,
1670 pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1671 pdata->ts2_vol_multi, pdata->virtual_power, pdata->power_dc2otg);
1672
1673 return 0;
1674 }
1675 #else
rk818_cg_parse_dt(struct rk818_charger * cg)1676 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1677 {
1678 return -ENODEV;
1679 }
1680 #endif
1681
rk818_charger_probe(struct platform_device * pdev)1682 static int rk818_charger_probe(struct platform_device *pdev)
1683 {
1684 struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1685 struct rk818_charger *cg;
1686 int ret;
1687
1688 cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1689 if (!cg)
1690 return -ENOMEM;
1691
1692 cg->rk818 = rk818;
1693 cg->pdev = pdev;
1694 cg->dev = &pdev->dev;
1695 cg->regmap = rk818->regmap;
1696 platform_set_drvdata(pdev, cg);
1697
1698 ret = rk818_cg_parse_dt(cg);
1699 if (ret < 0) {
1700 dev_err(cg->dev, "parse dt failed!\n");
1701 return ret;
1702 }
1703
1704 rk818_cg_init_ts2_detect(cg);
1705 rk818_cg_get_otg5v_regulator(cg);
1706
1707 ret = rk818_cg_init_dc(cg);
1708 if (ret) {
1709 dev_err(cg->dev, "init dc failed!\n");
1710 return ret;
1711 }
1712
1713 ret = rk818_cg_init_usb(cg);
1714 if (ret) {
1715 dev_err(cg->dev, "init usb failed!\n");
1716 return ret;
1717 }
1718
1719 ret = rk818_cg_init_power_supply(cg);
1720 if (ret) {
1721 dev_err(cg->dev, "init power supply fail!\n");
1722 return ret;
1723 }
1724
1725 rk818_cg_init_charger_state(cg);
1726
1727 ret = rk818_cg_register_temp_notifier(cg);
1728 if (ret) {
1729 dev_err(cg->dev, "register temp notify failed!\n");
1730 goto notify_fail;
1731 }
1732
1733 ret = rk818_cg_init_irqs(cg);
1734 if (ret) {
1735 dev_err(cg->dev, "init irqs failed!\n");
1736 goto irq_fail;
1737 }
1738
1739 CG_INFO("driver version: %s\n", CG_DRIVER_VERSION);
1740
1741 return 0;
1742
1743 irq_fail:
1744 rk818_bat_temp_notifier_unregister(&cg->temp_nb);
1745
1746 notify_fail:
1747 /* type-c only */
1748 if (cg->pdata->extcon) {
1749 cancel_delayed_work_sync(&cg->host_work);
1750 cancel_delayed_work_sync(&cg->discnt_work);
1751 }
1752
1753 cancel_delayed_work_sync(&cg->usb_work);
1754 cancel_delayed_work_sync(&cg->dc_work);
1755 cancel_delayed_work_sync(&cg->finish_sig_work);
1756 cancel_delayed_work_sync(&cg->irq_work);
1757 cancel_delayed_work_sync(&cg->ts2_vol_work);
1758 destroy_workqueue(cg->ts2_wq);
1759 destroy_workqueue(cg->usb_charger_wq);
1760 destroy_workqueue(cg->dc_charger_wq);
1761 destroy_workqueue(cg->finish_sig_wq);
1762
1763 if (cg->pdata->extcon) {
1764 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1765 &cg->cable_cg_nb);
1766 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1767 &cg->cable_cg_nb);
1768 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1769 &cg->cable_cg_nb);
1770 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
1771 &cg->cable_host_nb);
1772 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1773 &cg->cable_discnt_nb);
1774 } else {
1775 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1776 }
1777
1778 return ret;
1779 }
1780
rk818_charger_shutdown(struct platform_device * pdev)1781 static void rk818_charger_shutdown(struct platform_device *pdev)
1782 {
1783 struct rk818_charger *cg = platform_get_drvdata(pdev);
1784
1785 /* type-c only */
1786 if (cg->pdata->extcon) {
1787 cancel_delayed_work_sync(&cg->host_work);
1788 cancel_delayed_work_sync(&cg->discnt_work);
1789 }
1790
1791 rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
1792 disable_irq(cg->plugin_irq);
1793 disable_irq(cg->plugout_irq);
1794
1795 cancel_delayed_work_sync(&cg->usb_work);
1796 cancel_delayed_work_sync(&cg->dc_work);
1797 cancel_delayed_work_sync(&cg->finish_sig_work);
1798 cancel_delayed_work_sync(&cg->irq_work);
1799 cancel_delayed_work_sync(&cg->ts2_vol_work);
1800 flush_workqueue(cg->ts2_wq);
1801 flush_workqueue(cg->usb_charger_wq);
1802 flush_workqueue(cg->dc_charger_wq);
1803 flush_workqueue(cg->finish_sig_wq);
1804
1805 if (cg->pdata->extcon) {
1806 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1807 &cg->cable_cg_nb);
1808 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1809 &cg->cable_cg_nb);
1810 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1811 &cg->cable_cg_nb);
1812 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
1813 &cg->cable_host_nb);
1814 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1815 &cg->cable_discnt_nb);
1816 } else {
1817 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1818 }
1819
1820 rk818_bat_temp_notifier_unregister(&cg->temp_nb);
1821
1822 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1823
1824 CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d 5v=%d\n",
1825 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in, cg->otg_pmic5v);
1826 }
1827
rk818_charger_suspend(struct platform_device * pdev,pm_message_t state)1828 static int rk818_charger_suspend(struct platform_device *pdev,
1829 pm_message_t state)
1830 {
1831 struct rk818_charger *cg = platform_get_drvdata(pdev);
1832
1833 cg->sleep_set_off_reg1 = rk818_reg_read(cg, RK818_SLEEP_SET_OFF_REG1);
1834
1835 /* enable sleep boost5v and otg5v */
1836 if (cg->pdata->otg5v_suspend_enable) {
1837 if ((cg->otg_in && !cg->dc_in) ||
1838 (cg->otg_in && cg->dc_in && !cg->pdata->power_dc2otg)) {
1839 rk818_reg_clear_bits(cg, RK818_SLEEP_SET_OFF_REG1,
1840 OTG_BOOST_SLP_OFF);
1841 CG_INFO("suspend: otg 5v on\n");
1842 return 0;
1843 }
1844 }
1845
1846 /* disable sleep otg5v */
1847 rk818_reg_set_bits(cg, RK818_SLEEP_SET_OFF_REG1,
1848 OTG_SLP_SET_OFF, OTG_SLP_SET_OFF);
1849 CG_INFO("suspend: otg 5v off\n");
1850
1851 return 0;
1852 }
1853
rk818_charger_resume(struct platform_device * pdev)1854 static int rk818_charger_resume(struct platform_device *pdev)
1855 {
1856 struct rk818_charger *cg = platform_get_drvdata(pdev);
1857
1858 /* resume sleep boost5v and otg5v */
1859 rk818_reg_set_bits(cg, RK818_SLEEP_SET_OFF_REG1,
1860 OTG_BOOST_SLP_OFF, cg->sleep_set_off_reg1);
1861
1862 return 0;
1863 }
1864
1865 static struct platform_driver rk818_charger_driver = {
1866 .probe = rk818_charger_probe,
1867 .suspend = rk818_charger_suspend,
1868 .resume = rk818_charger_resume,
1869 .shutdown = rk818_charger_shutdown,
1870 .driver = {
1871 .name = "rk818-charger",
1872 },
1873 };
1874
charger_init(void)1875 static int __init charger_init(void)
1876 {
1877 return platform_driver_register(&rk818_charger_driver);
1878 }
1879 module_init(charger_init);
1880
charger_exit(void)1881 static void __exit charger_exit(void)
1882 {
1883 platform_driver_unregister(&rk818_charger_driver);
1884 }
1885 module_exit(charger_exit);
1886
1887 MODULE_LICENSE("GPL");
1888 MODULE_ALIAS("platform:rk818-charger");
1889 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");
1890