1 /*
2 * rk816 battery driver
3 *
4 * Copyright (C) 2017 Rockchip Electronics Co., Ltd
5 * Author: 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/fb.h>
21 #include <linux/gpio.h>
22 #include <linux/iio/consumer.h>
23 #include <linux/iio/iio.h>
24 #include <linux/irq.h>
25 #include <linux/jiffies.h>
26 #include <linux/mfd/rk808.h>
27 #include <linux/module.h>
28 #include <linux/of_device.h>
29 #include <linux/of_gpio.h>
30 #include <linux/platform_device.h>
31 #include <linux/power_supply.h>
32 #include <linux/power/rk_usbbc.h>
33 #include <linux/regmap.h>
34 #include <linux/rk_keys.h>
35 #include <linux/rtc.h>
36 #include <linux/timer.h>
37 #include <linux/wakelock.h>
38 #include <linux/workqueue.h>
39 #include "rk816_battery.h"
40
41 static int dbg_enable = 0;
42 module_param_named(dbg_level, dbg_enable, int, 0644);
43
44 #define DBG(args...) \
45 do { \
46 if (dbg_enable) { \
47 pr_info(args); \
48 } \
49 } while (0)
50
51 #define BAT_INFO(fmt, args...) pr_info("rk816-bat: "fmt, ##args)
52
53 /* default param */
54 #define DEFAULT_BAT_RES 135
55 #define DEFAULT_SLP_ENTER_CUR 300
56 #define DEFAULT_SLP_EXIT_CUR 300
57 #define DEFAULT_SLP_FILTER_CUR 100
58 #define DEFAULT_PWROFF_VOL_THRESD 3400
59 #define DEFAULT_MONITOR_SEC 5
60 #define DEFAULT_ALGR_VOL_THRESD1 3850
61 #define DEFAULT_ALGR_VOL_THRESD2 3950
62 #define DEFAULT_CHRG_VOL_SEL CHRG_VOL4200MV
63 #define DEFAULT_CHRG_CUR_SEL CHRG_CUR1400MA
64 #define DEFAULT_CHRG_CUR_INPUT INPUT_CUR2000MA
65 #define DEFAULT_POFFSET 42
66 #define DEFAULT_MAX_SOC_OFFSET 60
67 #define DEFAULT_FB_TEMP TEMP_115C
68 #define DEFAULT_ENERGY_MODE 0
69 #define DEFAULT_ZERO_RESERVE_DSOC 10
70 #define DEFAULT_SAMPLE_RES 20
71
72 /*MODE_VIRTUAL params*/
73 #define VIRTUAL_CURRENT 1000
74 #define VIRTUAL_VOLTAGE 3888
75 #define VIRTUAL_SOC 66
76 #define VIRTUAL_STATUS POWER_SUPPLY_STATUS_CHARGING
77 #define VIRTUAL_PRESET 1
78 #define VIRTUAL_AC_ONLINE 1
79 #define VIRTUAL_USB_ONLINE 0
80 #define VIRTUAL_TEMPERATURE 188
81
82 /* dsoc calib param */
83 #define FINISH_CHRG_CUR1 1000
84 #define FINISH_CHRG_CUR2 1500
85 #define FINISH_MAX_SOC_DELAY 20
86 #define TERM_CHRG_DSOC 88
87 #define TERM_CHRG_CURR 600
88 #define TERM_CHRG_K 650
89
90 #define SIMULATE_CHRG_INTV 8
91 #define SIMULATE_CHRG_CURR 400
92 #define SIMULATE_CHRG_K 1500
93
94 #define FULL_CHRG_K 400
95
96 /* zero algorithm */
97 #define PWROFF_THRESD 3400
98 #define MIN_ZERO_DSOC_ACCURACY 10 /*0.01%*/
99 #define MIN_ZERO_OVERCNT 100
100 #define MIN_ACCURACY 1
101 #define DEF_PWRPATH_RES 50
102 #define WAIT_DSOC_DROP_SEC 15
103 #define WAIT_SHTD_DROP_SEC 30
104 #define MIN_ZERO_GAP_XSOC1 10
105 #define MIN_ZERO_GAP_XSOC2 5
106 #define MIN_ZERO_GAP_XSOC3 3
107 #define MIN_ZERO_GAP_CALIB 5
108
109 #define ADC_CALIB_THRESHOLD 4
110 #define ADC_CALIB_LMT_MIN 3
111 #define ADC_CALIB_CNT 5
112
113 /* TS detect battery temperature */
114 #define ADC_CUR_MSK 0x03
115 #define ADC_CUR_20UA 0x00
116 #define ADC_CUR_40UA 0x01
117 #define ADC_CUR_60UA 0x02
118 #define ADC_CUR_80UA 0x03
119
120 #define NTC_CALC_FACTOR_80UA 80
121 #define NTC_CALC_FACTOR_60UA 60
122 #define NTC_CALC_FACTOR_40UA 40
123 #define NTC_CALC_FACTOR_20UA 20
124 #define NTC_80UA_MAX_MEASURE 27500
125 #define NTC_60UA_MAX_MEASURE 36666
126 #define NTC_40UA_MAX_MEASURE 55000
127 #define NTC_20UA_MAX_MEASURE 110000
128
129 /* time */
130 #define POWER_ON_SEC_BASE 1
131 #define MINUTE(x) ((x) * 60)
132
133 /* sleep */
134 #define SLP_CURR_MAX 40
135 #define SLP_CURR_MIN 6
136 #define DISCHRG_TIME_STEP1 MINUTE(10)
137 #define DISCHRG_TIME_STEP2 MINUTE(60)
138 #define SLP_DSOC_VOL_THRESD 3600
139 #define REBOOT_PERIOD_SEC 180
140 #define REBOOT_MAX_CNT 80
141
142 #define ZERO_LOAD_LVL1 1400
143 #define ZERO_LOAD_LVL2 600
144
145 /* fcc */
146 #define MIN_FCC 500
147
148 /* DC ADC */
149 #define DC_ADC_TRIGGER 150
150
151 #define TEMP_RECORD_NUM 30
152
153 static const char *bat_status[] = {
154 "charge off", "dead charge", "trickle charge", "cc cv",
155 "finish", "usb over vol", "bat temp error", "timer error",
156 };
157
158 struct rk816_battery {
159 struct platform_device *pdev;
160 struct rk808 *rk816;
161 struct regmap *regmap;
162 struct device *dev;
163 struct power_supply *bat;
164 struct power_supply *usb;
165 struct power_supply *ac;
166 struct battery_platform_data *pdata;
167 struct workqueue_struct *bat_monitor_wq;
168 struct workqueue_struct *usb_charger_wq;
169 struct delayed_work bat_delay_work;
170 struct delayed_work dc_delay_work;
171 struct delayed_work calib_delay_work;
172 struct wake_lock wake_lock;
173 struct notifier_block fb_nb;
174 struct timer_list caltimer;
175 time64_t rtc_base;
176 struct iio_channel *iio_chan;
177 struct notifier_block cable_cg_nb;
178 struct notifier_block cable_host_nb;
179 struct notifier_block cable_discnt_nb;
180 struct delayed_work usb_work;
181 struct delayed_work host_work;
182 struct delayed_work discnt_work;
183 struct extcon_dev *cable_edev;
184 int charger_changed;
185 int bat_res;
186 int chrg_status;
187 int res_fac;
188 int over_20mR;
189 bool is_initialized;
190 bool bat_first_power_on;
191 u8 ac_in;
192 u8 usb_in;
193 u8 otg_in; /* OTG device attached status */
194 u8 otg_pmic5v; /* OTG device power supply from PMIC */
195 u8 dc_in;
196 u8 prop_status;
197 int cvtlmt_irq;
198 int current_avg;
199 int current_relax;
200 int voltage_avg;
201 int voltage_ocv;
202 int voltage_relax;
203 int voltage_k;/* VCALIB0 VCALIB1 */
204 int voltage_b;
205 int remain_cap;
206 int design_cap;
207 int nac;
208 int fcc;
209 int lock_fcc;
210 int qmax;
211 int dsoc;
212 int rsoc;
213 int poffset;
214 int fake_offline;
215 int age_ocv_soc;
216 bool age_allow_update;
217 int age_level;
218 int age_ocv_cap;
219 int age_voltage;
220 int age_adjust_cap;
221 unsigned long age_keep_sec;
222 int zero_timeout_cnt;
223 int zero_remain_cap;
224 int zero_dsoc;
225 int zero_linek;
226 u64 zero_drop_sec;
227 u64 shtd_drop_sec;
228 int sm_remain_cap;
229 int sm_linek;
230 int sm_chrg_dsoc;
231 int sm_dischrg_dsoc;
232 int algo_rest_val;
233 int algo_rest_mode;
234 int sleep_sum_cap;
235 int sleep_remain_cap;
236 unsigned long sleep_dischrg_sec;
237 unsigned long sleep_sum_sec;
238 bool sleep_chrg_online;
239 u8 sleep_chrg_status;
240 bool adc_allow_update;
241 int fb_blank;
242 bool s2r; /*suspend to resume*/
243 u32 work_mode;
244 int temperature;
245 int chrg_cur_lp_input;
246 int chrg_vol_sel;
247 int chrg_cur_input;
248 int chrg_cur_sel;
249 u32 monitor_ms;
250 u32 pwroff_min;
251 u32 adc_calib_cnt;
252 unsigned long chrg_finish_base;
253 unsigned long boot_base;
254 unsigned long flat_match_sec;
255 unsigned long plug_in_base;
256 unsigned long plug_out_base;
257 u8 halt_cnt;
258 bool is_halt;
259 bool is_max_soc_offset;
260 bool is_sw_reset;
261 bool is_ocv_calib;
262 bool is_first_on;
263 bool is_force_calib;
264 int last_dsoc;
265 u8 cvtlmt_int_event;
266 u8 slp_dcdc_en_reg;
267 int ocv_pre_dsoc;
268 int ocv_new_dsoc;
269 int max_pre_dsoc;
270 int max_new_dsoc;
271 int force_pre_dsoc;
272 int force_new_dsoc;
273 int dbg_cap_low0;
274 int dbg_pwr_dsoc;
275 int dbg_pwr_rsoc;
276 int dbg_pwr_vol;
277 int dbg_chrg_min[10];
278 int dbg_meet_soc;
279 int dbg_calc_dsoc;
280 int dbg_calc_rsoc;
281 bool is_charging;
282 unsigned long charge_count;
283 int current_max;
284 int voltage_max;
285 };
286
287 struct led_ops {
288 void (*led_init)(struct rk816_battery *di);
289 void (*led_charging)(struct rk816_battery *di);
290 void (*led_discharging)(struct rk816_battery *di);
291 void (*led_charging_full)(struct rk816_battery *di);
292 };
293
294 static struct led_ops *rk816_led_ops;
295
296 #define DIV(x) ((x) ? (x) : 1)
297
298 /* 'res_fac' has been *10, so we need divide 10 */
299 #define RES_FAC_MUX(value, res_fac) ((value) * res_fac / 10)
300
301 /* 'res_fac' has been *10, so we need 'value * 10' before divide 'res_fac' */
302 #define RES_FAC_DIV(value, res_fac) ((value) * 10 / res_fac)
303
get_boot_sec(void)304 static u64 get_boot_sec(void)
305 {
306 struct timespec64 ts;
307
308 ktime_get_boottime_ts64(&ts);
309
310 return ts.tv_sec;
311 }
312
base2sec(unsigned long x)313 static unsigned long base2sec(unsigned long x)
314 {
315 if (x)
316 return (get_boot_sec() > x) ? (get_boot_sec() - x) : 0;
317 else
318 return 0;
319 }
320
base2min(unsigned long x)321 static unsigned long base2min(unsigned long x)
322 {
323 return base2sec(x) / 60;
324 }
325
interpolate(int value,u32 * table,int size)326 static u32 interpolate(int value, u32 *table, int size)
327 {
328 u8 i;
329 u16 d;
330
331 for (i = 0; i < size; i++) {
332 if (value < table[i])
333 break;
334 }
335
336 if ((i > 0) && (i < size)) {
337 d = (value - table[i - 1]) * (MAX_INTERPOLATE / (size - 1));
338 d /= table[i] - table[i - 1];
339 d = d + (i - 1) * (MAX_INTERPOLATE / (size - 1));
340 } else {
341 d = i * ((MAX_INTERPOLATE + size / 2) / size);
342 }
343
344 if (d > 1000)
345 d = 1000;
346
347 return d;
348 }
349
350 /* (a*b)/c */
ab_div_c(u32 a,u32 b,u32 c)351 static int32_t ab_div_c(u32 a, u32 b, u32 c)
352 {
353 bool sign;
354 u32 ans = MAX_INT;
355 int32_t tmp;
356
357 sign = ((((a ^ b) ^ c) & 0x80000000) != 0);
358 if (c != 0) {
359 if (sign)
360 c = -c;
361 tmp = (a * b + (c >> 1)) / c;
362 if (tmp < MAX_INT)
363 ans = tmp;
364 }
365
366 if (sign)
367 ans = -ans;
368
369 return ans;
370 }
371
rk816_bat_read(struct rk816_battery * di,u8 reg)372 static int rk816_bat_read(struct rk816_battery *di, u8 reg)
373 {
374 int ret, val;
375
376 ret = regmap_read(di->regmap, reg, &val);
377 if (ret)
378 dev_err(di->dev, "read reg:0x%x failed\n", reg);
379
380 return val;
381 }
382
rk816_bat_write(struct rk816_battery * di,u8 reg,u8 buf)383 static int rk816_bat_write(struct rk816_battery *di, u8 reg, u8 buf)
384 {
385 int ret;
386
387 ret = regmap_write(di->regmap, reg, buf);
388 if (ret)
389 dev_err(di->dev, "i2c write reg: 0x%2x error\n", reg);
390
391 return ret;
392 }
393
rk816_bat_set_bits(struct rk816_battery * di,u8 reg,u8 mask,u8 buf)394 static int rk816_bat_set_bits(struct rk816_battery *di, u8 reg, u8 mask, u8 buf)
395 {
396 int ret;
397
398 ret = regmap_update_bits(di->regmap, reg, mask, buf);
399 if (ret)
400 dev_err(di->dev, "write reg:0x%x failed\n", reg);
401
402 return ret;
403 }
404
rk816_bat_clear_bits(struct rk816_battery * di,u8 reg,u8 mask)405 static int rk816_bat_clear_bits(struct rk816_battery *di, u8 reg, u8 mask)
406 {
407 int ret;
408
409 ret = regmap_update_bits(di->regmap, reg, mask, 0);
410 if (ret)
411 dev_err(di->dev, "clr reg:0x%02x failed\n", reg);
412
413 return ret;
414 }
415
rk816_bat_dump_regs(struct rk816_battery * di,u8 start,u8 end)416 static void rk816_bat_dump_regs(struct rk816_battery *di, u8 start, u8 end)
417 {
418 int i;
419
420 if (!dbg_enable)
421 return;
422
423 DBG("dump regs from: 0x%x-->0x%x\n", start, end);
424 for (i = start; i < end; i++)
425 DBG("0x%x: 0x%0x\n", i, rk816_bat_read(di, i));
426 }
427
rk816_bat_chrg_online(struct rk816_battery * di)428 static bool rk816_bat_chrg_online(struct rk816_battery *di)
429 {
430 return (di->usb_in || di->ac_in || di->dc_in) ? true : false;
431 }
432
rk816_bat_get_coulomb_cap(struct rk816_battery * di)433 static int rk816_bat_get_coulomb_cap(struct rk816_battery *di)
434 {
435 int cap, val = 0;
436
437 val |= rk816_bat_read(di, RK816_GASCNT_REG3) << 24;
438 val |= rk816_bat_read(di, RK816_GASCNT_REG2) << 16;
439 val |= rk816_bat_read(di, RK816_GASCNT_REG1) << 8;
440 val |= rk816_bat_read(di, RK816_GASCNT_REG0) << 0;
441
442 if (!di->over_20mR)
443 cap = RES_FAC_MUX(val / 2390, di->res_fac);
444 else
445 cap = RES_FAC_DIV(val / 2390, di->res_fac);
446
447 return cap;
448 }
449
rk816_bat_get_rsoc(struct rk816_battery * di)450 static int rk816_bat_get_rsoc(struct rk816_battery *di)
451 {
452 int remain_cap;
453
454 remain_cap = rk816_bat_get_coulomb_cap(di);
455 return (remain_cap + di->fcc / 200) * 100 / DIV(di->fcc);
456 }
457
bat_info_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)458 static ssize_t bat_info_store(struct device *dev, struct device_attribute *attr,
459 const char *buf, size_t count)
460 {
461 int ret;
462 char cmd = 0;
463 struct rk816_battery *di = dev_get_drvdata(dev);
464
465 ret = sscanf(buf, "%c", &cmd);
466 if (ret != 1) {
467 dev_err(di->dev, "error! cmd require only one args\n");
468 return count;
469 }
470
471 if (cmd == 'n')
472 rk816_bat_set_bits(di, RK816_MISC_MARK_REG,
473 FG_RESET_NOW, FG_RESET_NOW);
474 else if (cmd == 'm')
475 rk816_bat_set_bits(di, RK816_MISC_MARK_REG,
476 FG_RESET_LATE, FG_RESET_LATE);
477 else if (cmd == 'c')
478 rk816_bat_clear_bits(di, RK816_MISC_MARK_REG,
479 FG_RESET_LATE | FG_RESET_NOW);
480 else if (cmd == 'r')
481 BAT_INFO("0x%2x\n", rk816_bat_read(di, RK816_MISC_MARK_REG));
482 else
483 BAT_INFO("command error\n");
484
485 return count;
486 }
487
488 static struct device_attribute rk816_bat_attr[] = {
489 __ATTR(bat, 0664, NULL, bat_info_store),
490 };
491
rk816_bat_enable_input_current(struct rk816_battery * di)492 static void rk816_bat_enable_input_current(struct rk816_battery *di)
493 {
494 u8 buf;
495
496 buf = rk816_bat_read(di, RK816_BAT_CTRL_REG);
497 buf |= USB_SYS_EN;
498 rk816_bat_write(di, RK816_BAT_CTRL_REG, buf);
499 }
500
rk816_bat_disable_input_current(struct rk816_battery * di)501 static void rk816_bat_disable_input_current(struct rk816_battery *di)
502 {
503 u8 buf;
504
505 buf = rk816_bat_read(di, RK816_BAT_CTRL_REG);
506 buf &= ~USB_SYS_EN;
507 rk816_bat_write(di, RK816_BAT_CTRL_REG, buf);
508 }
509
rk816_bat_is_input_enabled(struct rk816_battery * di)510 static int rk816_bat_is_input_enabled(struct rk816_battery *di)
511 {
512 u8 buf;
513
514 buf = rk816_bat_read(di, RK816_BAT_CTRL_REG);
515 return !!(buf & USB_SYS_EN);
516 }
517
rk816_bat_enable_gauge(struct rk816_battery * di)518 static void rk816_bat_enable_gauge(struct rk816_battery *di)
519 {
520 u8 buf;
521
522 buf = rk816_bat_read(di, RK816_TS_CTRL_REG);
523 buf |= GG_EN;
524 rk816_bat_write(di, RK816_TS_CTRL_REG, buf);
525 }
526
rk816_bat_save_age_level(struct rk816_battery * di,u8 level)527 static void rk816_bat_save_age_level(struct rk816_battery *di, u8 level)
528 {
529 rk816_bat_write(di, RK816_UPDATE_LEVE_REG, level);
530 }
531
rk816_bat_get_age_level(struct rk816_battery * di)532 static u8 rk816_bat_get_age_level(struct rk816_battery *di)
533 {
534 return rk816_bat_read(di, RK816_UPDATE_LEVE_REG);
535 }
536
rk816_bat_get_vcalib0(struct rk816_battery * di)537 static int rk816_bat_get_vcalib0(struct rk816_battery *di)
538 {
539 int val = 0;
540
541 val |= rk816_bat_read(di, RK816_VCALIB0_REGL) << 0;
542 val |= rk816_bat_read(di, RK816_VCALIB0_REGH) << 8;
543
544 DBG("<%s>. voffset0: 0x%x\n", __func__, val);
545 return val;
546 }
547
rk816_bat_get_vcalib1(struct rk816_battery * di)548 static int rk816_bat_get_vcalib1(struct rk816_battery *di)
549 {
550 int val = 0;
551
552 val |= rk816_bat_read(di, RK816_VCALIB1_REGL) << 0;
553 val |= rk816_bat_read(di, RK816_VCALIB1_REGH) << 8;
554
555 DBG("<%s>. voffset1: 0x%x\n", __func__, val);
556 return val;
557 }
558
rk816_bat_get_ioffset(struct rk816_battery * di)559 static int rk816_bat_get_ioffset(struct rk816_battery *di)
560 {
561 int val = 0;
562
563 val |= rk816_bat_read(di, RK816_IOFFSET_REGL) << 0;
564 val |= rk816_bat_read(di, RK816_IOFFSET_REGH) << 8;
565
566 DBG("<%s>. ioffset: 0x%x\n", __func__, val);
567 return val;
568 }
569
rk816_bat_get_coffset(struct rk816_battery * di)570 static int rk816_bat_get_coffset(struct rk816_battery *di)
571 {
572 int val = 0;
573
574 val |= rk816_bat_read(di, RK816_CAL_OFFSET_REGL) << 0;
575 val |= rk816_bat_read(di, RK816_CAL_OFFSET_REGH) << 8;
576
577 DBG("<%s>. coffset: 0x%x\n", __func__, val);
578 return val;
579 }
580
rk816_bat_set_coffset(struct rk816_battery * di,int val)581 static void rk816_bat_set_coffset(struct rk816_battery *di, int val)
582 {
583 u8 buf;
584
585 buf = (val >> 8) & 0xff;
586 rk816_bat_write(di, RK816_CAL_OFFSET_REGH, buf);
587 buf = (val >> 0) & 0xff;
588 rk816_bat_write(di, RK816_CAL_OFFSET_REGL, buf);
589 DBG("<%s>. coffset: 0x%x\n", __func__, val);
590 }
591
rk816_bat_init_voltage_kb(struct rk816_battery * di)592 static void rk816_bat_init_voltage_kb(struct rk816_battery *di)
593 {
594 int vcalib0, vcalib1;
595
596 vcalib0 = rk816_bat_get_vcalib0(di);
597 vcalib1 = rk816_bat_get_vcalib1(di);
598 di->voltage_k = (4200 - 3000) * 1000 / DIV(vcalib1 - vcalib0);
599 di->voltage_b = 4200 - (di->voltage_k * vcalib1) / 1000;
600
601 DBG("voltage_k=%d(*1000),voltage_b=%d\n", di->voltage_k, di->voltage_b);
602 }
603
rk816_bat_get_ocv_voltage(struct rk816_battery * di)604 static int rk816_bat_get_ocv_voltage(struct rk816_battery *di)
605 {
606 int vol, val = 0;
607
608 val |= rk816_bat_read(di, RK816_BAT_OCV_REGL) << 0;
609 val |= rk816_bat_read(di, RK816_BAT_OCV_REGH) << 8;
610 vol = di->voltage_k * val / 1000 + di->voltage_b;
611
612 return (vol * 1100 / 1000);
613 }
614
rk816_bat_get_avg_voltage(struct rk816_battery * di)615 static int rk816_bat_get_avg_voltage(struct rk816_battery *di)
616 {
617 int vol, val = 0;
618
619 val |= rk816_bat_read(di, RK816_BAT_VOL_REGL) << 0;
620 val |= rk816_bat_read(di, RK816_BAT_VOL_REGH) << 8;
621 vol = di->voltage_k * val / 1000 + di->voltage_b;
622
623 return (vol * 1100 / 1000);
624 }
625
rk816_bat_get_usb_voltage(struct rk816_battery * di)626 static int rk816_bat_get_usb_voltage(struct rk816_battery *di)
627 {
628 int vol, val = 0;
629
630 val |= rk816_bat_read(di, RK816_USB_ADC_REGL) << 0;
631 val |= rk816_bat_read(di, RK816_USB_ADC_REGH) << 8;
632 vol = di->voltage_k * val / 1000 + di->voltage_b;
633
634 return (vol * 1400 / 1100);
635 }
636
is_rk816_bat_relax_mode(struct rk816_battery * di)637 static bool is_rk816_bat_relax_mode(struct rk816_battery *di)
638 {
639 u8 status;
640
641 status = rk816_bat_read(di, RK816_GGSTS_REG);
642 if (!(status & RELAX_VOL1_UPD) || !(status & RELAX_VOL2_UPD))
643 return false;
644 else
645 return true;
646 }
647
rk816_bat_get_relax_vol1(struct rk816_battery * di)648 static u16 rk816_bat_get_relax_vol1(struct rk816_battery *di)
649 {
650 u16 vol, val = 0;
651
652 val |= rk816_bat_read(di, RK816_RELAX_VOL1_REGL) << 0;
653 val |= rk816_bat_read(di, RK816_RELAX_VOL1_REGH) << 8;
654 vol = di->voltage_k * val / 1000 + di->voltage_b;
655
656 return (vol * 1100 / 1000);
657 }
658
rk816_bat_get_relax_vol2(struct rk816_battery * di)659 static u16 rk816_bat_get_relax_vol2(struct rk816_battery *di)
660 {
661 u16 vol, val = 0;
662
663 val |= rk816_bat_read(di, RK816_RELAX_VOL2_REGL) << 0;
664 val |= rk816_bat_read(di, RK816_RELAX_VOL2_REGH) << 8;
665 vol = di->voltage_k * val / 1000 + di->voltage_b;
666
667 return (vol * 1100 / 1000);
668 }
669
rk816_bat_get_relax_voltage(struct rk816_battery * di)670 static u16 rk816_bat_get_relax_voltage(struct rk816_battery *di)
671 {
672 u16 relax_vol1, relax_vol2;
673
674 if (!is_rk816_bat_relax_mode(di))
675 return 0;
676
677 relax_vol1 = rk816_bat_get_relax_vol1(di);
678 relax_vol2 = rk816_bat_get_relax_vol2(di);
679
680 return relax_vol1 > relax_vol2 ? relax_vol1 : relax_vol2;
681 }
682
rk816_bat_get_avg_current(struct rk816_battery * di)683 static int rk816_bat_get_avg_current(struct rk816_battery *di)
684 {
685 int cur, val = 0;
686
687 val |= rk816_bat_read(di, RK816_BAT_CUR_AVG_REGL) << 0;
688 val |= rk816_bat_read(di, RK816_BAT_CUR_AVG_REGH) << 8;
689 if (val & 0x800)
690 val -= 4096;
691
692 if (!di->over_20mR)
693 cur = RES_FAC_MUX(val * 1506, di->res_fac) / 1000;
694 else
695 cur = RES_FAC_DIV(val * 1506, di->res_fac) / 1000;
696
697 return cur;
698 }
699
rk816_bat_get_relax_cur1(struct rk816_battery * di)700 static int rk816_bat_get_relax_cur1(struct rk816_battery *di)
701 {
702 int val = 0;
703
704 val |= rk816_bat_read(di, RK816_RELAX_CUR1_REGL) << 0;
705 val |= rk816_bat_read(di, RK816_RELAX_CUR1_REGH) << 8;
706 if (val & 0x800)
707 val -= 4096;
708
709 return (val * 1506 / 1000);
710 }
711
rk816_bat_get_relax_cur2(struct rk816_battery * di)712 static int rk816_bat_get_relax_cur2(struct rk816_battery *di)
713 {
714 int val = 0;
715
716 val |= rk816_bat_read(di, RK816_RELAX_CUR2_REGL) << 0;
717 val |= rk816_bat_read(di, RK816_RELAX_CUR2_REGH) << 8;
718 if (val & 0x800)
719 val -= 4096;
720
721 return (val * 1506 / 1000);
722 }
723
rk816_bat_get_relax_current(struct rk816_battery * di)724 static int rk816_bat_get_relax_current(struct rk816_battery *di)
725 {
726 int relax_cur1, relax_cur2;
727
728 if (!is_rk816_bat_relax_mode(di))
729 return 0;
730
731 relax_cur1 = rk816_bat_get_relax_cur1(di);
732 relax_cur2 = rk816_bat_get_relax_cur2(di);
733
734 return (relax_cur1 < relax_cur2) ? relax_cur1 : relax_cur2;
735 }
736
rk816_bat_vol_to_ocvsoc(struct rk816_battery * di,int voltage)737 static int rk816_bat_vol_to_ocvsoc(struct rk816_battery *di, int voltage)
738 {
739 u32 *ocv_table, temp;
740 int ocv_size, ocv_soc;
741
742 ocv_table = di->pdata->ocv_table;
743 ocv_size = di->pdata->ocv_size;
744 temp = interpolate(voltage, ocv_table, ocv_size);
745 ocv_soc = ab_div_c(temp, MAX_PERCENTAGE, MAX_INTERPOLATE);
746
747 return ocv_soc;
748 }
749
rk816_bat_vol_to_ocvcap(struct rk816_battery * di,int voltage)750 static int rk816_bat_vol_to_ocvcap(struct rk816_battery *di, int voltage)
751 {
752 u32 *ocv_table, temp;
753 int ocv_size, cap;
754
755 ocv_table = di->pdata->ocv_table;
756 ocv_size = di->pdata->ocv_size;
757 temp = interpolate(voltage, ocv_table, ocv_size);
758 cap = ab_div_c(temp, di->fcc, MAX_INTERPOLATE);
759
760 return cap;
761 }
762
rk816_bat_vol_to_zerosoc(struct rk816_battery * di,int voltage)763 static int rk816_bat_vol_to_zerosoc(struct rk816_battery *di, int voltage)
764 {
765 u32 *ocv_table, temp;
766 int ocv_size, ocv_soc;
767
768 ocv_table = di->pdata->zero_table;
769 ocv_size = di->pdata->ocv_size;
770 temp = interpolate(voltage, ocv_table, ocv_size);
771 ocv_soc = ab_div_c(temp, MAX_PERCENTAGE, MAX_INTERPOLATE);
772
773 return ocv_soc;
774 }
775
rk816_bat_vol_to_zerocap(struct rk816_battery * di,int voltage)776 static int rk816_bat_vol_to_zerocap(struct rk816_battery *di, int voltage)
777 {
778 u32 *ocv_table, temp;
779 int ocv_size, cap;
780
781 ocv_table = di->pdata->zero_table;
782 ocv_size = di->pdata->ocv_size;
783 temp = interpolate(voltage, ocv_table, ocv_size);
784 cap = ab_div_c(temp, di->fcc, MAX_INTERPOLATE);
785
786 return cap;
787 }
788
rk816_bat_get_iadc(struct rk816_battery * di)789 static int rk816_bat_get_iadc(struct rk816_battery *di)
790 {
791 int val = 0;
792
793 val |= rk816_bat_read(di, RK816_BAT_CUR_AVG_REGL) << 0;
794 val |= rk816_bat_read(di, RK816_BAT_CUR_AVG_REGH) << 8;
795 if (val > 2047)
796 val -= 4096;
797
798 return val;
799 }
800
is_rk816_bat_st_cvtlim(struct rk816_battery * di)801 static bool is_rk816_bat_st_cvtlim(struct rk816_battery *di)
802 {
803 return (rk816_bat_read(di, RK816_INT_STS_REG1) & 0x80) ? true : false;
804 }
805
rk816_bat_adc_calib(struct rk816_battery * di)806 static bool rk816_bat_adc_calib(struct rk816_battery *di)
807 {
808 int i, ioffset, coffset, adc, save_coffset;
809
810 if ((di->chrg_status != CHARGE_FINISH) ||
811 (di->adc_calib_cnt > ADC_CALIB_CNT) ||
812 (base2min(di->boot_base) < ADC_CALIB_LMT_MIN) ||
813 (abs(di->current_avg) < ADC_CALIB_THRESHOLD) ||
814 (is_rk816_bat_st_cvtlim(di)))
815 return false;
816
817 di->adc_calib_cnt++;
818 save_coffset = rk816_bat_get_coffset(di);
819 for (i = 0; i < 5; i++) {
820 if (!rk816_bat_chrg_online(di)) {
821 rk816_bat_set_coffset(di, save_coffset);
822 BAT_INFO("quit, charger plugout when calib adc\n");
823 return false;
824 }
825
826 /* check status and int cvtlmt */
827 if (is_rk816_bat_st_cvtlim(di)) {
828 rk816_bat_set_coffset(di, save_coffset);
829 BAT_INFO("1 cvtlmt(st) when calib adc\n");
830 return false;
831 }
832 enable_irq(di->cvtlmt_irq);
833 msleep(2000);
834 disable_irq(di->cvtlmt_irq);
835 if (di->cvtlmt_int_event) {
836 di->cvtlmt_int_event = 0;
837 rk816_bat_set_coffset(di, save_coffset);
838 BAT_INFO("1 cvtlmt(int) when calib adc\n");
839 return false;
840 }
841
842 /* it's ok to update coffset */
843 adc = rk816_bat_get_iadc(di);
844 coffset = rk816_bat_get_coffset(di);
845 rk816_bat_set_coffset(di, coffset + adc);
846
847 /* check status and int cvtlmt again */
848 if (is_rk816_bat_st_cvtlim(di)) {
849 rk816_bat_set_coffset(di, save_coffset);
850 BAT_INFO("2 cvtlmt(st) when calib adc\n");
851 return false;
852 }
853 enable_irq(di->cvtlmt_irq);
854 msleep(2000);
855 disable_irq(di->cvtlmt_irq);
856 if (di->cvtlmt_int_event) {
857 di->cvtlmt_int_event = 0;
858 rk816_bat_set_coffset(di, save_coffset);
859 BAT_INFO("2 cvtlmt(int) when calib adc\n");
860 return false;
861 }
862
863 /* it's ok to check calib adc result */
864 adc = rk816_bat_get_iadc(di);
865 if (abs(adc) < ADC_CALIB_THRESHOLD) {
866 coffset = rk816_bat_get_coffset(di);
867 ioffset = rk816_bat_get_ioffset(di);
868 di->poffset = coffset - ioffset;
869 rk816_bat_write(di, RK816_PCB_IOFFSET_REG, di->poffset);
870 BAT_INFO("new offset:c=0x%x, i=0x%x, p=0x%x\n",
871 coffset, ioffset, di->poffset);
872 return true;
873 } else {
874 BAT_INFO("coffset calib again %d.., max_cnt=%d\n",
875 i, di->adc_calib_cnt);
876 rk816_bat_set_coffset(di, coffset);
877 }
878 }
879
880 rk816_bat_set_coffset(di, save_coffset);
881
882 return false;
883 }
884
rk816_bat_set_ioffset_sample(struct rk816_battery * di)885 static void rk816_bat_set_ioffset_sample(struct rk816_battery *di)
886 {
887 u8 ggcon;
888
889 ggcon = rk816_bat_read(di, RK816_GGCON_REG);
890 ggcon &= ~ADC_CAL_MIN_MSK;
891 ggcon |= ADC_CAL_8MIN;
892 rk816_bat_write(di, RK816_GGCON_REG, ggcon);
893 }
894
rk816_bat_set_ocv_sample(struct rk816_battery * di)895 static void rk816_bat_set_ocv_sample(struct rk816_battery *di)
896 {
897 u8 ggcon;
898
899 ggcon = rk816_bat_read(di, RK816_GGCON_REG);
900 ggcon &= ~OCV_SAMP_MIN_MSK;
901 ggcon |= OCV_SAMP_8MIN;
902 rk816_bat_write(di, RK816_GGCON_REG, ggcon);
903 }
904
rk816_bat_restart_relax(struct rk816_battery * di)905 static void rk816_bat_restart_relax(struct rk816_battery *di)
906 {
907 u8 ggsts;
908
909 ggsts = rk816_bat_read(di, RK816_GGSTS_REG);
910 ggsts &= ~RELAX_VOL12_UPD_MSK;
911 rk816_bat_write(di, RK816_GGSTS_REG, ggsts);
912 }
913
rk816_bat_set_relax_sample(struct rk816_battery * di)914 static void rk816_bat_set_relax_sample(struct rk816_battery *di)
915 {
916 u8 buf;
917 int enter_thres, exit_thres, filter_thres;
918 struct battery_platform_data *pdata = di->pdata;
919
920 filter_thres = pdata->sleep_filter_current * 1000 / 1506;
921
922 if (!di->over_20mR) {
923 enter_thres = RES_FAC_DIV(pdata->sleep_enter_current * 1000,
924 di->res_fac) / 1506;
925 exit_thres = RES_FAC_DIV(pdata->sleep_exit_current * 1000,
926 di->res_fac) / 1506;
927 } else {
928 enter_thres = RES_FAC_MUX(pdata->sleep_enter_current * 1000,
929 di->res_fac) / 1506;
930 exit_thres = RES_FAC_MUX(pdata->sleep_exit_current * 1000,
931 di->res_fac) / 1506;
932 }
933
934 /* set relax enter and exit threshold */
935 buf = enter_thres & 0xff;
936 rk816_bat_write(di, RK816_RELAX_ENTRY_THRES_REGL, buf);
937 buf = (enter_thres >> 8) & 0xff;
938 rk816_bat_write(di, RK816_RELAX_ENTRY_THRES_REGH, buf);
939
940 buf = exit_thres & 0xff;
941 rk816_bat_write(di, RK816_RELAX_EXIT_THRES_REGL, buf);
942 buf = (exit_thres >> 8) & 0xff;
943 rk816_bat_write(di, RK816_RELAX_EXIT_THRES_REGH, buf);
944
945 /* set sample current threshold */
946 buf = filter_thres & 0xff;
947 rk816_bat_write(di, RK816_SLEEP_CON_SAMP_CUR_REG, buf);
948
949 /* reset relax update state */
950 rk816_bat_restart_relax(di);
951 DBG("<%s>. sleep_enter_current = %d, sleep_exit_current = %d\n",
952 __func__, pdata->sleep_enter_current, pdata->sleep_exit_current);
953 }
954
955 /* high load: current < 0 with charger in.
956 * System will not shutdown while dsoc=0% with charging state(ac_in),
957 * which will cause over discharge, so oppose status before report states.
958 */
rk816_bat_lowpwr_check(struct rk816_battery * di)959 static void rk816_bat_lowpwr_check(struct rk816_battery *di)
960 {
961 static u64 time;
962 int pwr_off_thresd = di->pdata->pwroff_vol;
963
964 if (di->current_avg < 0 && di->voltage_avg < pwr_off_thresd) {
965 if (!time)
966 time = get_boot_sec();
967
968 if ((base2sec(time) > MINUTE(1)) ||
969 (di->voltage_avg <= pwr_off_thresd - 50)) {
970 di->fake_offline = 1;
971 if (di->voltage_avg <= pwr_off_thresd - 50)
972 di->dsoc--;
973 BAT_INFO("low power, soc=%d, current=%d\n",
974 di->dsoc, di->current_avg);
975 }
976 } else {
977 time = 0;
978 di->fake_offline = 0;
979 }
980
981 DBG("<%s>. t=%lu, dsoc=%d, current=%d, fake_offline=%d\n",
982 __func__, base2sec(time), di->dsoc,
983 di->current_avg, di->fake_offline);
984 }
985
is_rk816_bat_exist(struct rk816_battery * di)986 static bool is_rk816_bat_exist(struct rk816_battery *di)
987 {
988 return (rk816_bat_read(di, RK816_SUP_STS_REG) & BAT_EXS) ? true : false;
989 }
990
is_rk816_bat_first_pwron(struct rk816_battery * di)991 static bool is_rk816_bat_first_pwron(struct rk816_battery *di)
992 {
993 u8 buf;
994
995 buf = rk816_bat_read(di, RK816_GGSTS_REG);
996 if (buf & BAT_CON) {
997 buf &= ~BAT_CON;
998 rk816_bat_write(di, RK816_GGSTS_REG, buf);
999 return true;
1000 }
1001
1002 return false;
1003 }
1004
rk816_bat_get_pwroff_min(struct rk816_battery * di)1005 static u8 rk816_bat_get_pwroff_min(struct rk816_battery *di)
1006 {
1007 u8 now_min, last_min;
1008
1009 now_min = rk816_bat_read(di, RK816_NON_ACT_TIMER_CNT_REG);
1010 last_min = rk816_bat_read(di, RK816_NON_ACT_TIMER_CNT_REG_SAVE);
1011 rk816_bat_write(di, RK816_NON_ACT_TIMER_CNT_REG_SAVE, now_min);
1012
1013 return (now_min != last_min) ? now_min : 0;
1014 }
1015
is_rk816_bat_initialized(struct rk816_battery * di)1016 static u8 is_rk816_bat_initialized(struct rk816_battery *di)
1017 {
1018 u8 val = rk816_bat_read(di, RK816_MISC_MARK_REG);
1019
1020 if (val & FG_INIT) {
1021 val &= ~FG_INIT;
1022 rk816_bat_write(di, RK816_MISC_MARK_REG, val);
1023 return true;
1024 } else {
1025 return false;
1026 }
1027 }
1028
is_rk816_bat_ocv_valid(struct rk816_battery * di)1029 static bool is_rk816_bat_ocv_valid(struct rk816_battery *di)
1030 {
1031 return (!di->is_initialized && di->pwroff_min >= 30) ? true : false;
1032 }
1033
rk816_bat_init_age_algorithm(struct rk816_battery * di)1034 static void rk816_bat_init_age_algorithm(struct rk816_battery *di)
1035 {
1036 int age_level, ocv_soc, ocv_cap, ocv_vol;
1037
1038 if (di->bat_first_power_on || is_rk816_bat_ocv_valid(di)) {
1039 DBG("<%s> enter.\n", __func__);
1040 ocv_vol = rk816_bat_get_ocv_voltage(di);
1041 ocv_soc = rk816_bat_vol_to_ocvsoc(di, ocv_vol);
1042 ocv_cap = rk816_bat_vol_to_ocvcap(di, ocv_vol);
1043 if (ocv_soc < 20) {
1044 di->age_voltage = ocv_vol;
1045 di->age_ocv_cap = ocv_cap;
1046 di->age_ocv_soc = ocv_soc;
1047 di->age_adjust_cap = 0;
1048
1049 if (ocv_soc <= 0)
1050 di->age_level = 100;
1051 else if (ocv_soc < 5)
1052 di->age_level = 95;
1053 else if (ocv_soc < 10)
1054 di->age_level = 90;
1055 else
1056 di->age_level = 80;
1057
1058 age_level = rk816_bat_get_age_level(di);
1059 if (age_level > di->age_level) {
1060 di->age_allow_update = false;
1061 age_level -= 5;
1062 if (age_level <= 80)
1063 age_level = 80;
1064 rk816_bat_save_age_level(di, age_level);
1065 } else {
1066 di->age_allow_update = true;
1067 di->age_keep_sec = get_boot_sec();
1068 }
1069
1070 BAT_INFO("init_age_algorithm: age_vol:%d, age_ocv_cap:%d, age_ocv_soc:%d, old_age_level:%d, age_allow_update:%d, new_age_level:%d\n",
1071 di->age_voltage, di->age_ocv_cap,
1072 ocv_soc, age_level, di->age_allow_update,
1073 di->age_level);
1074 }
1075 }
1076 }
1077
1078 static enum power_supply_property rk816_bat_props[] = {
1079 POWER_SUPPLY_PROP_STATUS,
1080 POWER_SUPPLY_PROP_CURRENT_NOW,
1081 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1082 POWER_SUPPLY_PROP_PRESENT,
1083 POWER_SUPPLY_PROP_HEALTH,
1084 POWER_SUPPLY_PROP_CAPACITY,
1085 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
1086 POWER_SUPPLY_PROP_TEMP,
1087 POWER_SUPPLY_PROP_CHARGE_COUNTER,
1088 POWER_SUPPLY_PROP_CHARGE_FULL,
1089 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1090 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
1091 };
1092
rk816_bat_ac_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)1093 static int rk816_bat_ac_set_property(struct power_supply *psy,
1094 enum power_supply_property psp,
1095 const union power_supply_propval *val)
1096 {
1097 struct rk816_battery *di = power_supply_get_drvdata(psy);
1098
1099 switch (psp) {
1100 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1101 if (val->intval)
1102 rk816_bat_enable_input_current(di);
1103 else
1104 rk816_bat_disable_input_current(di);
1105 break;
1106 default:
1107 return -EINVAL;
1108 }
1109
1110 return 0;
1111 }
1112
rk816_bat_usb_set_property(struct power_supply * psy,enum power_supply_property psp,const union power_supply_propval * val)1113 static int rk816_bat_usb_set_property(struct power_supply *psy,
1114 enum power_supply_property psp,
1115 const union power_supply_propval *val)
1116 {
1117 struct rk816_battery *di = power_supply_get_drvdata(psy);
1118
1119 switch (psp) {
1120 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1121 if (val->intval)
1122 rk816_bat_enable_input_current(di);
1123 else
1124 rk816_bat_disable_input_current(di);
1125 break;
1126 default:
1127 return -EINVAL;
1128 }
1129
1130 return 0;
1131 }
1132
rk816_get_capacity_leve(struct rk816_battery * di)1133 static int rk816_get_capacity_leve(struct rk816_battery *di)
1134 {
1135 if (di->pdata->bat_mode == MODE_VIRTUAL)
1136 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1137
1138 if (di->dsoc < 1)
1139 return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1140 else if (di->dsoc <= 20)
1141 return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1142 else if (di->dsoc <= 70)
1143 return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1144 else if (di->dsoc <= 90)
1145 return POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
1146 else
1147 return POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1148 }
1149
rk816_battery_time_to_full(struct rk816_battery * di)1150 static int rk816_battery_time_to_full(struct rk816_battery *di)
1151 {
1152 int time_sec;
1153 int cap_temp;
1154
1155 if (di->pdata->bat_mode == MODE_VIRTUAL) {
1156 time_sec = 3600;
1157 } else if (di->voltage_avg > 0) {
1158 cap_temp = di->pdata->design_capacity - di->remain_cap;
1159 if (cap_temp < 0)
1160 cap_temp = 0;
1161 time_sec = (3600 * cap_temp) / di->voltage_avg;
1162 } else {
1163 time_sec = 3600 * 24; /* One day */
1164 }
1165
1166 return time_sec;
1167 }
1168
rk816_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)1169 static int rk816_battery_get_property(struct power_supply *psy,
1170 enum power_supply_property psp,
1171 union power_supply_propval *val)
1172 {
1173 struct rk816_battery *di = power_supply_get_drvdata(psy);
1174
1175 switch (psp) {
1176 case POWER_SUPPLY_PROP_CURRENT_NOW:
1177 val->intval = di->current_avg * 1000;/*uA*/
1178 if (di->pdata->bat_mode == MODE_VIRTUAL)
1179 val->intval = VIRTUAL_CURRENT * 1000;
1180 break;
1181 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1182 val->intval = di->voltage_avg * 1000;/*uV*/
1183 if (di->pdata->bat_mode == MODE_VIRTUAL)
1184 val->intval = VIRTUAL_VOLTAGE * 1000;
1185 break;
1186 case POWER_SUPPLY_PROP_PRESENT:
1187 val->intval = is_rk816_bat_exist(di);
1188 if (di->pdata->bat_mode == MODE_VIRTUAL)
1189 val->intval = VIRTUAL_PRESET;
1190 break;
1191 case POWER_SUPPLY_PROP_CAPACITY:
1192 val->intval = di->dsoc;
1193 if (di->pdata->bat_mode == MODE_VIRTUAL)
1194 val->intval = VIRTUAL_SOC;
1195 DBG("<%s>. report dsoc: %d\n", __func__, val->intval);
1196 break;
1197 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1198 val->intval = rk816_get_capacity_leve(di);
1199 break;
1200 case POWER_SUPPLY_PROP_HEALTH:
1201 val->intval = POWER_SUPPLY_HEALTH_GOOD;
1202 break;
1203 case POWER_SUPPLY_PROP_STATUS:
1204 val->intval = di->prop_status;
1205 if (di->pdata->bat_mode == MODE_VIRTUAL)
1206 val->intval = VIRTUAL_STATUS;
1207 if (!rk816_bat_is_input_enabled(di))
1208 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1209 break;
1210 case POWER_SUPPLY_PROP_TEMP:
1211 val->intval = di->temperature;
1212 if (di->pdata->bat_mode == MODE_VIRTUAL)
1213 val->intval = VIRTUAL_TEMPERATURE;
1214 break;
1215 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
1216 val->intval = di->charge_count;
1217 break;
1218 case POWER_SUPPLY_PROP_CHARGE_FULL:
1219 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1220 val->intval = di->pdata->design_capacity * 1000;/* uAh */
1221 break;
1222 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
1223 val->intval = rk816_battery_time_to_full(di);
1224 break;
1225 default:
1226 return -EINVAL;
1227 }
1228
1229 return 0;
1230 }
1231
1232 static enum power_supply_property rk816_ac_props[] = {
1233 POWER_SUPPLY_PROP_ONLINE,
1234 POWER_SUPPLY_PROP_VOLTAGE_MAX,
1235 POWER_SUPPLY_PROP_CURRENT_MAX,
1236 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1237 };
1238
1239 static enum power_supply_property rk816_usb_props[] = {
1240 POWER_SUPPLY_PROP_ONLINE,
1241 POWER_SUPPLY_PROP_VOLTAGE_MAX,
1242 POWER_SUPPLY_PROP_CURRENT_MAX,
1243 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1244 };
1245
rk816_bat_ac_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)1246 static int rk816_bat_ac_get_property(struct power_supply *psy,
1247 enum power_supply_property psp,
1248 union power_supply_propval *val)
1249 {
1250 int ret = 0;
1251 struct rk816_battery *di = power_supply_get_drvdata(psy);
1252
1253 switch (psp) {
1254 case POWER_SUPPLY_PROP_ONLINE:
1255 if (di->pdata->bat_mode == MODE_VIRTUAL)
1256 val->intval = VIRTUAL_AC_ONLINE;
1257 else if (di->fake_offline)
1258 val->intval = 0;
1259 else
1260 val->intval = di->ac_in | di->dc_in;
1261 break;
1262 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
1263 val->intval = di->voltage_max;
1264 break;
1265 case POWER_SUPPLY_PROP_CURRENT_MAX:
1266 val->intval = di->current_max;
1267 break;
1268 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1269 val->intval = rk816_bat_is_input_enabled(di);
1270 break;
1271 default:
1272 ret = -EINVAL;
1273 break;
1274 }
1275
1276 return ret;
1277 }
1278
rk816_bat_usb_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)1279 static int rk816_bat_usb_get_property(struct power_supply *psy,
1280 enum power_supply_property psp,
1281 union power_supply_propval *val)
1282 {
1283 int ret = 0;
1284 struct rk816_battery *di = power_supply_get_drvdata(psy);
1285
1286 switch (psp) {
1287 case POWER_SUPPLY_PROP_ONLINE:
1288 if (di->pdata->bat_mode == MODE_VIRTUAL)
1289 val->intval = VIRTUAL_USB_ONLINE;
1290 else if (di->fake_offline)
1291 val->intval = 0;
1292 else
1293 val->intval = di->usb_in;
1294 break;
1295 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
1296 val->intval = di->voltage_max;
1297 break;
1298 case POWER_SUPPLY_PROP_CURRENT_MAX:
1299 val->intval = di->current_max;
1300 break;
1301 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1302 val->intval = rk816_bat_is_input_enabled(di);
1303 break;
1304 default:
1305 ret = -EINVAL;
1306 break;
1307 }
1308
1309 return ret;
1310 }
1311
rk816_bat_writable_property(struct power_supply * psy,enum power_supply_property psp)1312 static int rk816_bat_writable_property(struct power_supply *psy,
1313 enum power_supply_property psp)
1314 {
1315 switch (psp) {
1316 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1317 return 1;
1318 default:
1319 return 0;
1320 }
1321
1322 return 0;
1323 }
1324
1325 static const struct power_supply_desc rk816_bat_desc = {
1326 .name = "battery",
1327 .type = POWER_SUPPLY_TYPE_BATTERY,
1328 .properties = rk816_bat_props,
1329 .num_properties = ARRAY_SIZE(rk816_bat_props),
1330 .get_property = rk816_battery_get_property,
1331 };
1332
1333 static const struct power_supply_desc rk816_ac_desc = {
1334 .name = "ac",
1335 .type = POWER_SUPPLY_TYPE_MAINS,
1336 .properties = rk816_ac_props,
1337 .num_properties = ARRAY_SIZE(rk816_ac_props),
1338 .get_property = rk816_bat_ac_get_property,
1339 .set_property = rk816_bat_ac_set_property,
1340 .property_is_writeable = rk816_bat_writable_property,
1341 };
1342
1343 static const struct power_supply_desc rk816_usb_desc = {
1344 .name = "usb",
1345 .type = POWER_SUPPLY_TYPE_USB,
1346 .properties = rk816_usb_props,
1347 .num_properties = ARRAY_SIZE(rk816_usb_props),
1348 .get_property = rk816_bat_usb_get_property,
1349 .set_property = rk816_bat_usb_set_property,
1350 .property_is_writeable = rk816_bat_writable_property,
1351 };
1352
rk816_bat_init_power_supply(struct rk816_battery * di)1353 static int rk816_bat_init_power_supply(struct rk816_battery *di)
1354 {
1355 struct power_supply_config psy_cfg = { .drv_data = di, };
1356
1357 di->bat = devm_power_supply_register(di->dev,
1358 &rk816_bat_desc, &psy_cfg);
1359 if (IS_ERR(di->bat)) {
1360 dev_err(di->dev, "register bat power supply fail\n");
1361 return PTR_ERR(di->bat);
1362 }
1363
1364 di->ac = devm_power_supply_register(di->dev,
1365 &rk816_ac_desc, &psy_cfg);
1366 if (IS_ERR(di->ac)) {
1367 dev_err(di->dev, "register ac power supply fail\n");
1368 return PTR_ERR(di->ac);
1369 }
1370
1371 di->usb = devm_power_supply_register(di->dev,
1372 &rk816_usb_desc, &psy_cfg);
1373 if (IS_ERR(di->usb)) {
1374 dev_err(di->dev, "register usb power supply fail\n");
1375 return PTR_ERR(di->usb);
1376 }
1377
1378 return 0;
1379 }
1380
rk816_bat_save_cap(struct rk816_battery * di,int capacity)1381 static void rk816_bat_save_cap(struct rk816_battery *di, int capacity)
1382 {
1383 u8 buf;
1384 static u32 old_cap;
1385
1386 if (capacity >= di->qmax)
1387 capacity = di->qmax;
1388 if (capacity <= 0)
1389 capacity = 0;
1390 if (old_cap == capacity)
1391 return;
1392
1393 old_cap = capacity;
1394 buf = (capacity >> 24) & 0xff;
1395 rk816_bat_write(di, RK816_REMAIN_CAP_REG3, buf);
1396 buf = (capacity >> 16) & 0xff;
1397 rk816_bat_write(di, RK816_REMAIN_CAP_REG2, buf);
1398 buf = (capacity >> 8) & 0xff;
1399 rk816_bat_write(di, RK816_REMAIN_CAP_REG1, buf);
1400 buf = (capacity >> 0) & 0xff;
1401 rk816_bat_write(di, RK816_REMAIN_CAP_REG0, buf);
1402 }
1403
rk816_bat_get_prev_cap(struct rk816_battery * di)1404 static int rk816_bat_get_prev_cap(struct rk816_battery *di)
1405 {
1406 int val = 0;
1407
1408 val |= rk816_bat_read(di, RK816_REMAIN_CAP_REG3) << 24;
1409 val |= rk816_bat_read(di, RK816_REMAIN_CAP_REG2) << 16;
1410 val |= rk816_bat_read(di, RK816_REMAIN_CAP_REG1) << 8;
1411 val |= rk816_bat_read(di, RK816_REMAIN_CAP_REG0) << 0;
1412
1413 return val;
1414 }
1415
rk816_bat_save_fcc(struct rk816_battery * di,u32 fcc)1416 static void rk816_bat_save_fcc(struct rk816_battery *di, u32 fcc)
1417 {
1418 u8 buf;
1419
1420 buf = (fcc >> 24) & 0xff;
1421 rk816_bat_write(di, RK816_NEW_FCC_REG3, buf);
1422 buf = (fcc >> 16) & 0xff;
1423 rk816_bat_write(di, RK816_NEW_FCC_REG2, buf);
1424 buf = (fcc >> 8) & 0xff;
1425 rk816_bat_write(di, RK816_NEW_FCC_REG1, buf);
1426 buf = (fcc >> 0) & 0xff;
1427 rk816_bat_write(di, RK816_NEW_FCC_REG0, buf);
1428
1429 BAT_INFO("save fcc: %d\n", fcc);
1430 }
1431
rk816_bat_get_fcc(struct rk816_battery * di)1432 static int rk816_bat_get_fcc(struct rk816_battery *di)
1433 {
1434 u32 fcc = 0;
1435
1436 fcc |= rk816_bat_read(di, RK816_NEW_FCC_REG3) << 24;
1437 fcc |= rk816_bat_read(di, RK816_NEW_FCC_REG2) << 16;
1438 fcc |= rk816_bat_read(di, RK816_NEW_FCC_REG1) << 8;
1439 fcc |= rk816_bat_read(di, RK816_NEW_FCC_REG0) << 0;
1440
1441 if (fcc < MIN_FCC) {
1442 BAT_INFO("invalid fcc(%d), use design cap", fcc);
1443 fcc = di->pdata->design_capacity;
1444 rk816_bat_save_fcc(di, fcc);
1445 } else if (fcc > di->pdata->design_qmax) {
1446 BAT_INFO("invalid fcc(%d), use qmax", fcc);
1447 fcc = di->pdata->design_qmax;
1448 rk816_bat_save_fcc(di, fcc);
1449 }
1450
1451 return fcc;
1452 }
1453
rk816_bat_get_lock_fcc(struct rk816_battery * di)1454 static int rk816_bat_get_lock_fcc(struct rk816_battery *di)
1455 {
1456 u8 reg;
1457 int fcc, val = 0;
1458
1459 /* check lock flag, 1: yes, 0: no */
1460 reg = rk816_bat_read(di, RK816_GGSTS_REG);
1461 if ((reg & FCC_LOCK) == 0)
1462 return 0;
1463
1464 val |= rk816_bat_read(di, RK816_FCC_GASCNT_REG3) << 24;
1465 val |= rk816_bat_read(di, RK816_FCC_GASCNT_REG2) << 16;
1466 val |= rk816_bat_read(di, RK816_FCC_GASCNT_REG1) << 8;
1467 val |= rk816_bat_read(di, RK816_FCC_GASCNT_REG0) << 0;
1468 fcc = val / 2390;
1469
1470 /* clear lock flag */
1471 reg &= ~FCC_LOCK;
1472 rk816_bat_write(di, RK816_GGSTS_REG, reg);
1473 BAT_INFO("lock fcc = %d\n", fcc);
1474
1475 return fcc;
1476 }
1477
rk816_bat_save_dsoc(struct rk816_battery * di,u8 save_soc)1478 static void rk816_bat_save_dsoc(struct rk816_battery *di, u8 save_soc)
1479 {
1480 static int last_soc = -1;
1481
1482 if (last_soc != save_soc) {
1483 rk816_bat_write(di, RK816_SOC_REG, save_soc);
1484 last_soc = save_soc;
1485 }
1486 }
1487
rk816_bat_get_prev_dsoc(struct rk816_battery * di)1488 static int rk816_bat_get_prev_dsoc(struct rk816_battery *di)
1489 {
1490 return rk816_bat_read(di, RK816_SOC_REG);
1491 }
1492
rk816_bat_save_reboot_cnt(struct rk816_battery * di,u8 save_cnt)1493 static void rk816_bat_save_reboot_cnt(struct rk816_battery *di, u8 save_cnt)
1494 {
1495 rk816_bat_write(di, RK816_REBOOT_CNT_REG, save_cnt);
1496 }
1497
rk816_bat_init_leds(struct rk816_battery * di)1498 static void rk816_bat_init_leds(struct rk816_battery *di)
1499 {
1500 if (rk816_led_ops && rk816_led_ops->led_init) {
1501 rk816_led_ops->led_init(di);
1502 BAT_INFO("leds initialized\n");
1503 }
1504 }
1505
rk816_bat_update_leds(struct rk816_battery * di,int prop)1506 static void rk816_bat_update_leds(struct rk816_battery *di, int prop)
1507 {
1508 static int old_prop = -1;
1509
1510 if (prop == old_prop)
1511 return;
1512
1513 old_prop = prop;
1514 switch (prop) {
1515 case POWER_SUPPLY_STATUS_FULL:
1516 if (rk816_led_ops && rk816_led_ops->led_charging_full) {
1517 rk816_led_ops->led_charging_full(di);
1518 BAT_INFO("charging full led on\n");
1519 }
1520 break;
1521 case POWER_SUPPLY_STATUS_CHARGING:
1522 if (rk816_led_ops && rk816_led_ops->led_charging) {
1523 rk816_led_ops->led_charging(di);
1524 BAT_INFO("charging led on\n");
1525 }
1526 break;
1527 case POWER_SUPPLY_STATUS_DISCHARGING:
1528 if (rk816_led_ops && rk816_led_ops->led_discharging) {
1529 rk816_led_ops->led_discharging(di);
1530 BAT_INFO("discharging led on\n");
1531 }
1532 break;
1533 default:
1534 BAT_INFO("Unknown led update\n");
1535 break;
1536 }
1537 }
1538
rk816_bat_set_chrg_current(struct rk816_battery * di,u8 chrg_current)1539 static void rk816_bat_set_chrg_current(struct rk816_battery *di,
1540 u8 chrg_current)
1541 {
1542 u8 chrg_ctrl_reg1;
1543
1544 chrg_ctrl_reg1 = rk816_bat_read(di, RK816_CHRG_CTRL_REG1);
1545 chrg_ctrl_reg1 &= ~CHRG_CUR_MSK;
1546 chrg_ctrl_reg1 |= (chrg_current);
1547 rk816_bat_write(di, RK816_CHRG_CTRL_REG1, chrg_ctrl_reg1);
1548 }
1549
rk816_bat_set_input_current(struct rk816_battery * di,int input_current)1550 static void rk816_bat_set_input_current(struct rk816_battery *di,
1551 int input_current)
1552 {
1553 u8 usb_ctrl;
1554
1555 if (di->pdata->bat_mode == MODE_VIRTUAL) {
1556 BAT_INFO("virtual power test mode, set max input current\n");
1557 input_current = di->chrg_cur_input;
1558 }
1559
1560 usb_ctrl = rk816_bat_read(di, RK816_USB_CTRL_REG);
1561 usb_ctrl &= ~INPUT_CUR_MSK;
1562 usb_ctrl |= (input_current);
1563 rk816_bat_write(di, RK816_USB_CTRL_REG, usb_ctrl);
1564 }
1565
rk816_bat_set_chrg_param(struct rk816_battery * di,enum charger_t charger_type)1566 static void rk816_bat_set_chrg_param(struct rk816_battery *di,
1567 enum charger_t charger_type)
1568 {
1569 u8 buf, usb_ctrl, chrg_ctrl1;
1570 const char *charger_name[] = {"NONE", "NONE USB", "USB", "AC",
1571 "CDP1.5A", "DC", "NONE DC"};
1572
1573 switch (charger_type) {
1574 case USB_TYPE_UNKNOWN_CHARGER:
1575 di->usb_in = 0;
1576 di->ac_in = 0;
1577 di->dc_in = 0;
1578 di->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
1579 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1580 rk816_bat_set_input_current(di, INPUT_CUR450MA);
1581 power_supply_changed(di->bat);
1582 power_supply_changed(di->usb);
1583 power_supply_changed(di->ac);
1584 break;
1585 case USB_TYPE_NONE_CHARGER:
1586 di->usb_in = 0;
1587 di->ac_in = 0;
1588 if (di->dc_in == 0) {
1589 di->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
1590 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1591 rk816_bat_set_input_current(di, INPUT_CUR450MA);
1592 }
1593 power_supply_changed(di->usb);
1594 power_supply_changed(di->ac);
1595 break;
1596 case USB_TYPE_USB_CHARGER:
1597 di->usb_in = 1;
1598 di->ac_in = 0;
1599 di->prop_status = POWER_SUPPLY_STATUS_CHARGING;
1600 if (di->dc_in == 0) {
1601 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1602 rk816_bat_set_input_current(di, INPUT_CUR450MA);
1603 }
1604 power_supply_changed(di->usb);
1605 break;
1606 case USB_TYPE_CDP_CHARGER:
1607 di->usb_in = 1;
1608 di->ac_in = 0;
1609 di->prop_status = POWER_SUPPLY_STATUS_CHARGING;
1610 if (di->dc_in == 0) {
1611 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1612 rk816_bat_set_input_current(di, INPUT_CUR1500MA);
1613 }
1614 power_supply_changed(di->usb);
1615 break;
1616 case USB_TYPE_AC_CHARGER:
1617 di->ac_in = 1;
1618 di->usb_in = 0;
1619 di->prop_status = POWER_SUPPLY_STATUS_CHARGING;
1620 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1621 rk816_bat_set_input_current(di, di->chrg_cur_input);
1622 power_supply_changed(di->ac);
1623 break;
1624 case DC_TYPE_DC_CHARGER:
1625 di->dc_in = 1;
1626 di->prop_status = POWER_SUPPLY_STATUS_CHARGING;
1627 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1628 rk816_bat_set_input_current(di, di->chrg_cur_input);
1629 power_supply_changed(di->ac);
1630 break;
1631 case DC_TYPE_NONE_CHARGER:
1632 di->dc_in = 0;
1633 /*
1634 * check by pmic int avoid usb error notify:
1635 * when plug in dc, usb may error notify usb/ac plug in,
1636 * while dc plug out, the "ac/usb_in" still hold
1637 */
1638 buf = rk816_bat_read(di, RK816_VB_MON_REG);
1639 if ((buf & PLUG_IN_STS) == 0) {
1640 di->ac_in = 0;
1641 di->usb_in = 0;
1642 di->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
1643 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1644 rk816_bat_set_input_current(di, INPUT_CUR450MA);
1645 } else if (di->usb_in) {
1646 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
1647 rk816_bat_set_input_current(di, INPUT_CUR450MA);
1648 di->prop_status = POWER_SUPPLY_STATUS_CHARGING;
1649 }
1650 power_supply_changed(di->usb);
1651 power_supply_changed(di->ac);
1652 break;
1653 default:
1654 di->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
1655 break;
1656 }
1657
1658 di->charger_changed = 1;
1659
1660 usb_ctrl = rk816_bat_read(di, RK816_USB_CTRL_REG);
1661 chrg_ctrl1 = rk816_bat_read(di, RK816_CHRG_CTRL_REG1);
1662 BAT_INFO("set charger type: %s, current: input=%d, chrg=%d\n",
1663 charger_name[charger_type],
1664 CHRG_CUR_INPUT[usb_ctrl & 0x0f],
1665 CHRG_CUR_SEL[chrg_ctrl1 & 0x0f]);
1666
1667 if (di->dsoc == 100 && rk816_bat_chrg_online(di))
1668 di->prop_status = POWER_SUPPLY_STATUS_FULL;
1669
1670 rk816_bat_update_leds(di, di->prop_status);
1671 }
1672
rk816_bat_set_otg_in(struct rk816_battery * di,int online)1673 static void rk816_bat_set_otg_in(struct rk816_battery *di, int online)
1674 {
1675 di->otg_in = online;
1676 }
1677
1678 /*
1679 * -----: VBUS-5V
1680 * #####: PMIC_INT
1681 *
1682 *
1683 * A 140ms D
1684 * |------------------>>>>>>>>>>>>>>>
1685 * | B C
1686 * ##########################
1687 * | #
1688 * | 100ms # F E
1689 * -------------- ##############
1690 *
1691 * [PMIC]
1692 * A: charger plugin event(vbus-5v on);
1693 * C: pmic reaction time finish, [A~C] = 100ms;
1694 * D: pmic switch to charging mode, start charging, [A~D] = 140ms;
1695 *
1696 * [Software]
1697 * B: PLUG_IN_STS=0, we think it's not charging mode, so enable otg+boost,
1698 * but actually, PLUG_IN_STS is not effective now.
1699 * F: pmic reaction finish, PLUG_IN_STS is effective and we do check again.
1700 * E: output-5v mode really works(enable boost+otg)
1701 *
1702 * [Mistake detail]
1703 * 1. Charger plugin at spot-A and switch to charing mode at spot-D.
1704 * 2. Software check PLUG_IN_STS=0 at spot-B, so we think it's not
1705 * charging mode and we enable boost+otg, and this really works at
1706 * spot-E(because delay of i2c transfer or other).
1707 * 3. It's a pity that pmic has been changed to charing mode at spot-D
1708 * earlier than spot-E.
1709 *
1710 * After above mistake, we enable otg+boost in charing mode. Then, boost will
1711 * burn off if we plugout charger.
1712 *
1713 * [Solution]
1714 * we should abey the rule: Don't enable boost while in charging mode.
1715 * We should enable otg first at spot-B, trying to switch to output-5v mode,
1716 * then delay 140ms(pmic reaction and other) to check effective PLUG_IN_STS
1717 * again at spot-F, if PLUG_IN_STS=1, means it's charging mode now, we abandont
1718 * enable boost and disable otg. Otherwise, we can turn on boost safely.
1719 */
rk816_bat_set_otg_power(struct rk816_battery * di,int power)1720 static void rk816_bat_set_otg_power(struct rk816_battery *di, int power)
1721 {
1722 u8 buf;
1723
1724 switch (power) {
1725 case USB_OTG_POWER_ON:
1726 if (di->otg_pmic5v) {
1727 BAT_INFO("otg5v is on yet, ignore..\n");
1728 break;
1729 }
1730
1731 /* (spot-B). for safe, detect vbus-5v by pmic self */
1732 buf = rk816_bat_read(di, RK816_VB_MON_REG);
1733 if (buf & PLUG_IN_STS) {
1734 BAT_INFO("detect vbus-5v suppling, deny otg on..\n");
1735 break;
1736 }
1737
1738 /* (spot-B). enable otg, try to switch to output-5v mode */
1739 rk816_bat_set_bits(di, RK816_DCDC_EN_REG2,
1740 BOOST_OTG_MASK, BOOST_OFF_OTG_ON);
1741
1742 /*
1743 * pmic need about 140ms to switch to charging mode, so wait
1744 * 140ms and check charger again. if still check vbus-5v online,
1745 * that means it's charger mode now, we should turn off boost
1746 * and otg, then return.
1747 */
1748 msleep(140);
1749 /* spot-F */
1750 buf = rk816_bat_read(di, RK816_VB_MON_REG);
1751 if (buf & PLUG_IN_STS) {
1752 rk816_bat_set_bits(di, RK816_DCDC_EN_REG2,
1753 BOOST_OTG_MASK, BOOST_OTG_OFF);
1754 BAT_INFO("detect vbus-5v suppling too, deny otg on\n");
1755 break;
1756 }
1757
1758 /*
1759 * reach here, means pmic switch to output-5v mode ok, it's
1760 * safe to enable boost-5v on output mode.
1761 */
1762 rk816_bat_set_bits(di, RK816_DCDC_EN_REG2,
1763 BOOST_OTG_MASK, BOOST_OTG_ON);
1764 di->otg_pmic5v = 1;
1765 break;
1766
1767 case USB_OTG_POWER_OFF:
1768 if (!di->otg_pmic5v) {
1769 BAT_INFO("otg5v is off yet, ignore..\n");
1770 } else {
1771 rk816_bat_set_bits(di, RK816_DCDC_EN_REG2,
1772 BOOST_OTG_MASK, BOOST_OTG_OFF);
1773 di->otg_pmic5v = 0;
1774 }
1775 break;
1776
1777 default:
1778 break;
1779 }
1780 }
1781
rk816_bat_get_adc_dc_state(struct rk816_battery * di)1782 static enum charger_t rk816_bat_get_adc_dc_state(struct rk816_battery *di)
1783 {
1784 int val = 0;
1785
1786 if (!di->iio_chan) {
1787 di->iio_chan = iio_channel_get(&di->rk816->i2c->dev, NULL);
1788 if (IS_ERR(di->iio_chan)) {
1789 di->iio_chan = NULL;
1790 return DC_TYPE_NONE_CHARGER;
1791 }
1792 }
1793
1794 if (iio_read_channel_raw(di->iio_chan, &val) < 0) {
1795 pr_err("read channel error\n");
1796 return DC_TYPE_NONE_CHARGER;
1797 }
1798
1799 return (val >= DC_ADC_TRIGGER) ?
1800 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
1801 }
1802
rk816_bat_get_gpio_dc_state(struct rk816_battery * di)1803 static enum charger_t rk816_bat_get_gpio_dc_state(struct rk816_battery *di)
1804 {
1805 int level;
1806
1807 if (!gpio_is_valid(di->pdata->dc_det_pin))
1808 return DC_TYPE_NONE_CHARGER;
1809
1810 level = gpio_get_value(di->pdata->dc_det_pin);
1811
1812 return (level == di->pdata->dc_det_level) ?
1813 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
1814 }
1815
rk816_bat_get_dc_state(struct rk816_battery * di)1816 static enum charger_t rk816_bat_get_dc_state(struct rk816_battery *di)
1817 {
1818 enum charger_t type;
1819
1820 if (di->pdata->dc_det_adc)
1821 type = rk816_bat_get_adc_dc_state(di);
1822 else
1823 type = rk816_bat_get_gpio_dc_state(di);
1824
1825 return type;
1826 }
1827
rk816_bat_dc_delay_work(struct work_struct * work)1828 static void rk816_bat_dc_delay_work(struct work_struct *work)
1829 {
1830 enum charger_t type;
1831 static enum charger_t old_type = USB_TYPE_UNKNOWN_CHARGER;
1832 struct rk816_battery *di = container_of(work,
1833 struct rk816_battery, dc_delay_work.work);
1834
1835 type = rk816_bat_get_dc_state(di);
1836 if (old_type == type)
1837 goto out;
1838
1839 old_type = type;
1840 if (type == DC_TYPE_DC_CHARGER) {
1841 BAT_INFO("detect dc charger in..\n");
1842 rk816_bat_set_chrg_param(di, DC_TYPE_DC_CHARGER);
1843 /* check otg supply */
1844 if (di->otg_in && di->pdata->power_dc2otg) {
1845 BAT_INFO("otg power from dc adapter\n");
1846 rk816_bat_set_otg_power(di, USB_OTG_POWER_OFF);
1847 }
1848 } else {
1849 BAT_INFO("detect dc charger out..\n");
1850 rk816_bat_set_chrg_param(di, DC_TYPE_NONE_CHARGER);
1851 /* check otg supply, power on anyway */
1852 if (di->otg_in) {
1853 BAT_INFO("charge disable, enable otg\n");
1854 /*
1855 * must wait 200ms to wait 5v-input fade away before
1856 * enable boost
1857 */
1858 msleep(200);
1859 rk816_bat_set_otg_power(di, USB_OTG_POWER_ON);
1860 }
1861 }
1862 out:
1863 /* adc need check all the time */
1864 if (di->pdata->dc_det_adc)
1865 queue_delayed_work(di->usb_charger_wq,
1866 &di->dc_delay_work,
1867 msecs_to_jiffies(1000));
1868 }
1869
rk816_bat_fb_notifier(struct notifier_block * nb,unsigned long event,void * data)1870 static int rk816_bat_fb_notifier(struct notifier_block *nb,
1871 unsigned long event, void *data)
1872 {
1873 struct rk816_battery *di;
1874 struct fb_event *evdata = data;
1875
1876 if (event != FB_EVENT_BLANK)
1877 return NOTIFY_DONE;
1878
1879 di = container_of(nb, struct rk816_battery, fb_nb);
1880 di->fb_blank = *(int *)evdata->data;
1881
1882 return NOTIFY_OK;
1883 }
1884
rk816_bat_register_fb_notify(struct rk816_battery * di)1885 static int rk816_bat_register_fb_notify(struct rk816_battery *di)
1886 {
1887 memset(&di->fb_nb, 0, sizeof(di->fb_nb));
1888 di->fb_nb.notifier_call = rk816_bat_fb_notifier;
1889
1890 return fb_register_client(&di->fb_nb);
1891 }
1892
rk816_bat_unregister_fb_notify(struct rk816_battery * di)1893 static int rk816_bat_unregister_fb_notify(struct rk816_battery *di)
1894 {
1895 return fb_unregister_client(&di->fb_nb);
1896 }
1897
rk816_bat_init_coulomb_cap(struct rk816_battery * di,u32 capacity)1898 static void rk816_bat_init_coulomb_cap(struct rk816_battery *di, u32 capacity)
1899 {
1900 u8 buf;
1901 u32 cap;
1902
1903 if (!di->over_20mR)
1904 cap = RES_FAC_DIV(capacity * 2390, di->res_fac);
1905 else
1906 cap = RES_FAC_MUX(capacity * 2390, di->res_fac);
1907
1908 buf = (cap >> 24) & 0xff;
1909 rk816_bat_write(di, RK816_GASCNT_CAL_REG3, buf);
1910 buf = (cap >> 16) & 0xff;
1911 rk816_bat_write(di, RK816_GASCNT_CAL_REG2, buf);
1912 buf = (cap >> 8) & 0xff;
1913 rk816_bat_write(di, RK816_GASCNT_CAL_REG1, buf);
1914 buf = (cap >> 0) & 0xff;
1915 rk816_bat_write(di, RK816_GASCNT_CAL_REG0, buf);
1916
1917 di->remain_cap = capacity;
1918 di->rsoc = rk816_bat_get_rsoc(di);
1919 }
1920
rk816_bat_get_halt_cnt(struct rk816_battery * di)1921 static u8 rk816_bat_get_halt_cnt(struct rk816_battery *di)
1922 {
1923 return rk816_bat_read(di, RK816_HALT_CNT_REG);
1924 }
1925
rk816_bat_inc_halt_cnt(struct rk816_battery * di)1926 static void rk816_bat_inc_halt_cnt(struct rk816_battery *di)
1927 {
1928 u8 cnt;
1929
1930 cnt = rk816_bat_read(di, RK816_HALT_CNT_REG);
1931 rk816_bat_write(di, RK816_HALT_CNT_REG, ++cnt);
1932 }
1933
is_rk816_bat_last_halt(struct rk816_battery * di)1934 static bool is_rk816_bat_last_halt(struct rk816_battery *di)
1935 {
1936 int pre_cap = rk816_bat_get_prev_cap(di);
1937 int now_cap = rk816_bat_get_coulomb_cap(di);
1938
1939 /* over 10%: system halt last time */
1940 if (abs(now_cap - pre_cap) > (di->fcc / 10)) {
1941 rk816_bat_inc_halt_cnt(di);
1942 return true;
1943 } else {
1944 return false;
1945 }
1946 }
1947
rk816_bat_first_pwron(struct rk816_battery * di)1948 static void rk816_bat_first_pwron(struct rk816_battery *di)
1949 {
1950 int ocv_vol;
1951
1952 rk816_bat_save_fcc(di, di->design_cap);
1953 ocv_vol = rk816_bat_get_ocv_voltage(di);
1954 di->fcc = rk816_bat_get_fcc(di);
1955 di->nac = rk816_bat_vol_to_ocvcap(di, ocv_vol);
1956 di->rsoc = rk816_bat_vol_to_ocvsoc(di, ocv_vol);
1957 di->dsoc = di->rsoc;
1958 di->is_first_on = true;
1959
1960 BAT_INFO("first on: dsoc=%d, rsoc=%d cap=%d, fcc=%d, ov=%d\n",
1961 di->dsoc, di->rsoc, di->nac, di->fcc, ocv_vol);
1962 }
1963
rk816_bat_not_first_pwron(struct rk816_battery * di)1964 static void rk816_bat_not_first_pwron(struct rk816_battery *di)
1965 {
1966 int now_cap, pre_soc, pre_cap, ocv_cap, ocv_soc, ocv_vol;
1967
1968 di->fcc = rk816_bat_get_fcc(di);
1969 pre_soc = rk816_bat_get_prev_dsoc(di);
1970 pre_cap = rk816_bat_get_prev_cap(di);
1971 now_cap = rk816_bat_get_coulomb_cap(di);
1972 di->is_halt = is_rk816_bat_last_halt(di);
1973 di->halt_cnt = rk816_bat_get_halt_cnt(di);
1974 di->is_initialized = is_rk816_bat_initialized(di);
1975 di->is_ocv_calib = is_rk816_bat_ocv_valid(di);
1976
1977 if (di->is_initialized) {
1978 BAT_INFO("initialized yet..\n");
1979 goto finish;
1980 } else if (di->is_halt) {
1981 BAT_INFO("system halt last time... cap: pre=%d, now=%d\n",
1982 pre_cap, now_cap);
1983 if (now_cap < 0)
1984 now_cap = 0;
1985 rk816_bat_init_coulomb_cap(di, now_cap);
1986 pre_cap = now_cap;
1987 pre_soc = di->rsoc;
1988 goto finish;
1989 } else if (di->is_ocv_calib) {
1990 ocv_vol = rk816_bat_get_ocv_voltage(di);
1991 ocv_soc = rk816_bat_vol_to_ocvsoc(di, ocv_vol);
1992 ocv_cap = rk816_bat_vol_to_ocvcap(di, ocv_vol);
1993 pre_cap = ocv_cap;
1994 di->ocv_pre_dsoc = pre_soc;
1995 di->ocv_new_dsoc = ocv_soc;
1996 if (abs(ocv_soc - pre_soc) >= di->pdata->max_soc_offset) {
1997 di->ocv_pre_dsoc = pre_soc;
1998 di->ocv_new_dsoc = ocv_soc;
1999 di->is_max_soc_offset = true;
2000 BAT_INFO("trigger max soc offset, dsoc: %d -> %d\n",
2001 pre_soc, ocv_soc);
2002 pre_soc = ocv_soc;
2003 }
2004 BAT_INFO("OCV calib: cap=%d, rsoc=%d\n", ocv_cap, ocv_soc);
2005 } else if (di->pwroff_min > 0) {
2006 ocv_vol = rk816_bat_get_ocv_voltage(di);
2007 ocv_soc = rk816_bat_vol_to_ocvsoc(di, ocv_vol);
2008 ocv_cap = rk816_bat_vol_to_ocvcap(di, ocv_vol);
2009 di->force_pre_dsoc = pre_soc;
2010 di->force_new_dsoc = ocv_soc;
2011 if (abs(ocv_soc - pre_soc) >= 80) {
2012 di->is_force_calib = true;
2013 BAT_INFO("dsoc force calib: %d -> %d\n",
2014 pre_soc, ocv_soc);
2015 pre_soc = ocv_soc;
2016 pre_cap = ocv_cap;
2017 }
2018 }
2019
2020 finish:
2021 di->dsoc = pre_soc;
2022 di->nac = pre_cap;
2023 if (di->nac < 0)
2024 di->nac = 0;
2025
2026 BAT_INFO("dsoc=%d cap=%d v=%d ov=%d rv=%d min=%d psoc=%d pcap=%d\n",
2027 di->dsoc, di->nac, rk816_bat_get_avg_voltage(di),
2028 rk816_bat_get_ocv_voltage(di), rk816_bat_get_relax_voltage(di),
2029 di->pwroff_min, rk816_bat_get_prev_dsoc(di),
2030 rk816_bat_get_prev_cap(di));
2031 }
2032
rk816_bat_ocv_sw_reset(struct rk816_battery * di)2033 static bool rk816_bat_ocv_sw_reset(struct rk816_battery *di)
2034 {
2035 u8 buf;
2036
2037 buf = rk816_bat_read(di, RK816_MISC_MARK_REG);
2038 if (((buf & FG_RESET_LATE) && di->pwroff_min >= 30) ||
2039 (buf & FG_RESET_NOW)) {
2040 buf &= ~FG_RESET_LATE;
2041 buf &= ~FG_RESET_NOW;
2042 rk816_bat_write(di, RK816_MISC_MARK_REG, buf);
2043 BAT_INFO("manual reset fuel gauge\n");
2044 return true;
2045 } else {
2046 return false;
2047 }
2048 }
2049
rk816_bat_setup_ocv_table(struct rk816_battery * di,int temp)2050 static void rk816_bat_setup_ocv_table(struct rk816_battery *di, int temp)
2051 {
2052 int i, idx = 0;
2053 int temp_h, temp_l, percent, volt_htemp, volt_ltemp;
2054 int *temp_t = di->pdata->temp_t;
2055 int temp_t_num = di->pdata->temp_t_num;
2056
2057 if (temp_t_num < 2)
2058 return;
2059
2060 DBG("<%s>. temperature=%d\n", __func__, temp);
2061
2062 /* Out of MIN, select MIN */
2063 if (temp < temp_t[0]) {
2064 DBG("<%s>. Out MIN\n", __func__);
2065 di->pdata->ocv_table = di->pdata->table_t[0];
2066 return;
2067 }
2068
2069 /* Out of MAX, select MAX */
2070 if (temp > temp_t[temp_t_num - 1]) {
2071 DBG("<%s>. Out MAX\n", __func__);
2072 di->pdata->ocv_table = di->pdata->table_t[temp_t_num - 1];
2073 return;
2074 }
2075
2076 /* Exactly match some one */
2077 for (i = 0; i < temp_t_num; i++) {
2078 if (temp == temp_t[i]) {
2079 DBG("<%s>. Match: %d'C\n", __func__, temp_t[i]);
2080 di->pdata->ocv_table = di->pdata->table_t[i];
2081 return;
2082 }
2083 }
2084
2085 /* Find position of current temperature, must be fond */
2086 for (i = 0; i < temp_t_num - 1; i++) {
2087 if ((temp > temp_t[i]) && (temp < temp_t[i + 1])) {
2088 idx = i;
2089 break;
2090 }
2091 }
2092
2093 DBG("<%s>. found! idx = %d\n", __func__, idx);
2094
2095 /* calculate percent */
2096 temp_l = temp_t[idx];
2097 temp_h = temp_t[idx + 1];
2098 percent = (temp - temp_l) * 100 / DIV(temp_h - temp_l);
2099
2100 /* Fill in new ocv table members */
2101 for (i = 0; i < di->pdata->ocv_size; i++) {
2102 volt_ltemp = di->pdata->table_t[idx][i];
2103 volt_htemp = di->pdata->table_t[idx + 1][i];
2104
2105 di->pdata->ocv_table[i] = volt_ltemp +
2106 (volt_htemp - volt_ltemp) * percent / 100;
2107
2108 DBG("#low=%d'C[%dmv], me=%d'C[%dmv], high=%d'C[%dmv]. percent=%d, delta=%dmv\n",
2109 temp_l, volt_ltemp, temp, di->pdata->ocv_table[i],
2110 temp_h, volt_htemp, percent,
2111 (volt_htemp - volt_ltemp) * percent / 100);
2112 }
2113 }
2114
rk816_bat_init_rsoc(struct rk816_battery * di)2115 static void rk816_bat_init_rsoc(struct rk816_battery *di)
2116 {
2117 di->bat_first_power_on = is_rk816_bat_first_pwron(di);
2118 di->is_sw_reset = rk816_bat_ocv_sw_reset(di);
2119 di->pwroff_min = rk816_bat_get_pwroff_min(di);
2120
2121 if (di->bat_first_power_on || di->is_sw_reset)
2122 rk816_bat_first_pwron(di);
2123 else
2124 rk816_bat_not_first_pwron(di);
2125 }
2126
rk816_bat_get_chrg_status(struct rk816_battery * di)2127 static u8 rk816_bat_get_chrg_status(struct rk816_battery *di)
2128 {
2129 u8 status;
2130
2131 status = rk816_bat_read(di, RK816_SUP_STS_REG) & CHRG_STATUS_MSK;
2132 switch (status) {
2133 case CHARGE_OFF:
2134 DBG("CHARGE-OFF ...\n");
2135 break;
2136 case DEAD_CHARGE:
2137 BAT_INFO("DEAD CHARGE...\n");
2138 break;
2139 case TRICKLE_CHARGE:
2140 BAT_INFO("TRICKLE CHARGE...\n ");
2141 break;
2142 case CC_OR_CV:
2143 DBG("CC or CV...\n");
2144 break;
2145 case CHARGE_FINISH:
2146 DBG("CHARGE FINISH...\n");
2147 break;
2148 case USB_OVER_VOL:
2149 BAT_INFO("USB OVER VOL...\n");
2150 break;
2151 case BAT_TMP_ERR:
2152 BAT_INFO("BAT TMP ERROR...\n");
2153 break;
2154 case TIMER_ERR:
2155 BAT_INFO("TIMER ERROR...\n");
2156 break;
2157 case USB_EXIST:
2158 BAT_INFO("USB EXIST...\n");
2159 break;
2160 case USB_EFF:
2161 BAT_INFO("USB EFF...\n");
2162 break;
2163 default:
2164 BAT_INFO("UNKNOWN STATUS...\n");
2165 break;
2166 }
2167
2168 return status;
2169 }
2170
rk816_bat_fb_temp(struct rk816_battery * di)2171 static u8 rk816_bat_fb_temp(struct rk816_battery *di)
2172 {
2173 u8 reg;
2174 int index, fb_temp;
2175
2176 reg = DEFAULT_FB_TEMP;
2177 fb_temp = di->pdata->fb_temp;
2178 for (index = 0; index < ARRAY_SIZE(FEED_BACK_TEMP); index++) {
2179 if (fb_temp < FEED_BACK_TEMP[index])
2180 break;
2181 reg = (index << FB_TEMP_SHIFT);
2182 }
2183
2184 return reg;
2185 }
2186
rk816_bat_select_sample_res(struct rk816_battery * di)2187 static void rk816_bat_select_sample_res(struct rk816_battery *di)
2188 {
2189 if (di->pdata->sample_res == 20) {
2190 di->over_20mR = 0;
2191 di->res_fac = 10;
2192 } else if (di->pdata->sample_res > 20) {
2193 di->over_20mR = 1;
2194 di->res_fac = di->pdata->sample_res * 10 / 20;
2195 } else {
2196 di->over_20mR = 0;
2197 di->res_fac = 20 * 10 / di->pdata->sample_res;
2198 }
2199 }
2200
rk816_bat_decode_input_current(struct rk816_battery * di,u32 input_current)2201 static u8 rk816_bat_decode_input_current(struct rk816_battery *di,
2202 u32 input_current)
2203 {
2204 u8 val = DEFAULT_CHRG_CUR_INPUT;
2205 u8 index;
2206
2207 for (index = 2; index < ARRAY_SIZE(CHRG_CUR_INPUT); index++) {
2208 if (input_current < 850 && input_current > 80) {
2209 val = 0x0;/* 450mA */
2210 break;
2211 } else if (input_current <= 80) {
2212 val = 0x1;/* 80mA */
2213 break;
2214 } else {
2215 if (input_current < CHRG_CUR_INPUT[index])
2216 break;
2217 val = (index << CHRG_CRU_INPUT_SHIFT);
2218 }
2219 }
2220
2221 return val;
2222 }
2223
rk816_bat_decode_chrg_current(struct rk816_battery * di,u32 chrg_current)2224 static u8 rk816_bat_decode_chrg_current(struct rk816_battery *di,
2225 u32 chrg_current)
2226 {
2227 u8 val = DEFAULT_CHRG_CUR_SEL;
2228 u8 index;
2229
2230 if (di->pdata->sample_res < 20) {
2231 if (chrg_current > 2000)
2232 chrg_current = RES_FAC_DIV(chrg_current, di->res_fac);
2233 else
2234 chrg_current = 1000;
2235 } else if (di->pdata->sample_res > 20) {
2236 chrg_current = RES_FAC_MUX(chrg_current, di->res_fac);
2237 if (chrg_current > 2400)
2238 chrg_current = 2400;
2239 if (chrg_current < 1000)
2240 chrg_current = 1000;
2241 }
2242
2243 for (index = 0; index < ARRAY_SIZE(CHRG_CUR_SEL); index++) {
2244 if (chrg_current < CHRG_CUR_SEL[index])
2245 break;
2246 val = (index << CHRG_CRU_SEL_SHIFT);
2247 }
2248
2249 return val;
2250 }
2251
rk816_bat_decode_chrg_vol(struct rk816_battery * di,u32 chrg_vol)2252 static u8 rk816_bat_decode_chrg_vol(struct rk816_battery *di,
2253 u32 chrg_vol)
2254 {
2255 u8 val = DEFAULT_CHRG_VOL_SEL;
2256 u8 index;
2257
2258 for (index = 0; index < ARRAY_SIZE(CHRG_VOL_SEL); index++) {
2259 if (chrg_vol < CHRG_VOL_SEL[index])
2260 break;
2261 val = (index << CHRG_VOL_SEL_SHIFT);
2262 }
2263
2264 return val;
2265 }
2266
rk816_bat_select_chrg_cv(struct rk816_battery * di)2267 static void rk816_bat_select_chrg_cv(struct rk816_battery *di)
2268 {
2269 di->chrg_vol_sel = rk816_bat_decode_chrg_vol(di,
2270 di->pdata->max_chrg_voltage);
2271 di->chrg_cur_input = rk816_bat_decode_input_current(di,
2272 di->pdata->max_input_current);
2273 di->chrg_cur_sel = rk816_bat_decode_chrg_current(di,
2274 di->pdata->max_chrg_current);
2275
2276 DBG("<%s>. vol = 0x%x, input = 0x%x, sel = 0x%x\n",
2277 __func__, di->chrg_vol_sel, di->chrg_cur_input, di->chrg_cur_sel);
2278 }
2279
rk816_bat_finish_ma(struct rk816_battery * di,int fcc)2280 static u8 rk816_bat_finish_ma(struct rk816_battery *di, int fcc)
2281 {
2282 u8 ma;
2283
2284 if (fcc > 5000)
2285 ma = FINISH_250MA;
2286 else if (fcc >= 4000)
2287 ma = FINISH_200MA;
2288 else if (fcc >= 3000)
2289 ma = FINISH_150MA;
2290 else
2291 ma = FINISH_100MA;
2292
2293 /* adjust ma according to sample resistor */
2294 if (di->pdata->sample_res < 20) {
2295 /* ma should div 2 */
2296 if (ma == FINISH_200MA)
2297 ma = FINISH_100MA;
2298 else if (ma == FINISH_250MA)
2299 ma = FINISH_150MA;
2300 } else if (di->pdata->sample_res > 20) {
2301 /* ma should mux 2 */
2302 if (ma == FINISH_100MA)
2303 ma = FINISH_200MA;
2304 else if (ma == FINISH_150MA)
2305 ma = FINISH_250MA;
2306 }
2307
2308 return ma;
2309 }
2310
rk816_bat_init_chrg_config(struct rk816_battery * di)2311 static void rk816_bat_init_chrg_config(struct rk816_battery *di)
2312 {
2313 u8 chrg_ctrl1, usb_ctrl, chrg_ctrl2, chrg_ctrl3;
2314 u8 sup_sts, thermal, ggcon, finish_ma, fb_temp;
2315
2316 rk816_bat_select_chrg_cv(di);
2317 finish_ma = rk816_bat_finish_ma(di, di->fcc);
2318 fb_temp = rk816_bat_fb_temp(di);
2319
2320 ggcon = rk816_bat_read(di, RK816_GGCON_REG);
2321 sup_sts = rk816_bat_read(di, RK816_SUP_STS_REG);
2322 thermal = rk816_bat_read(di, RK816_THERMAL_REG);
2323 usb_ctrl = rk816_bat_read(di, RK816_USB_CTRL_REG);
2324 chrg_ctrl1 = rk816_bat_read(di, RK816_CHRG_CTRL_REG1);
2325 chrg_ctrl2 = rk816_bat_read(di, RK816_CHRG_CTRL_REG2);
2326 chrg_ctrl3 = rk816_bat_read(di, RK816_CHRG_CTRL_REG3);
2327
2328 /* set charge current and voltage */
2329 usb_ctrl &= ~INPUT_CUR_MSK;
2330 usb_ctrl |= di->chrg_cur_input;
2331 chrg_ctrl1 = (CHRG_EN) | (di->chrg_vol_sel | di->chrg_cur_sel);
2332
2333 /* set charge finish current */
2334 chrg_ctrl3 |= CHRG_TERM_DIG_SIGNAL;
2335 chrg_ctrl2 &= ~FINISH_CUR_MSK;
2336 chrg_ctrl2 |= finish_ma;
2337
2338 /* disable cccv mode */
2339 chrg_ctrl3 &= ~CHRG_TIMER_CCCV_EN;
2340
2341 /* enable voltage limit and enable input current limit */
2342 sup_sts |= USB_VLIMIT_EN;
2343 sup_sts |= USB_CLIMIT_EN;
2344
2345 /* set feed back temperature */
2346 if (di->pdata->fb_temp)
2347 usb_ctrl |= CHRG_CT_EN;
2348 else
2349 usb_ctrl &= ~CHRG_CT_EN;
2350 thermal &= ~FB_TEMP_MSK;
2351 thermal |= fb_temp;
2352
2353 /* adc current mode */
2354 ggcon |= ADC_CUR_MODE;
2355 ggcon |= AVG_CUR_MODE;
2356
2357 rk816_bat_write(di, RK816_GGCON_REG, ggcon);
2358 rk816_bat_write(di, RK816_SUP_STS_REG, sup_sts);
2359 rk816_bat_write(di, RK816_THERMAL_REG, thermal);
2360 rk816_bat_write(di, RK816_USB_CTRL_REG, usb_ctrl);
2361 rk816_bat_write(di, RK816_CHRG_CTRL_REG1, chrg_ctrl1);
2362 rk816_bat_write(di, RK816_CHRG_CTRL_REG2, chrg_ctrl2);
2363 rk816_bat_write(di, RK816_CHRG_CTRL_REG3, chrg_ctrl3);
2364 }
2365
rk816_bat_init_poffset(struct rk816_battery * di)2366 static void rk816_bat_init_poffset(struct rk816_battery *di)
2367 {
2368 int coffset, ioffset;
2369
2370 coffset = rk816_bat_get_coffset(di);
2371 ioffset = rk816_bat_get_ioffset(di);
2372 di->poffset = coffset - ioffset;
2373 }
2374
rk816_bat_caltimer_isr(struct timer_list * t)2375 static void rk816_bat_caltimer_isr(struct timer_list *t)
2376 {
2377 struct rk816_battery *di = from_timer(di, t, caltimer);
2378
2379 mod_timer(&di->caltimer, jiffies + MINUTE(8) * HZ);
2380 queue_delayed_work(di->bat_monitor_wq, &di->calib_delay_work,
2381 msecs_to_jiffies(10));
2382 }
2383
rk816_bat_internal_calib(struct work_struct * work)2384 static void rk816_bat_internal_calib(struct work_struct *work)
2385 {
2386 int ioffset;
2387 struct rk816_battery *di = container_of(work,
2388 struct rk816_battery, calib_delay_work.work);
2389
2390 ioffset = rk816_bat_get_ioffset(di);
2391 rk816_bat_set_coffset(di, di->poffset + ioffset);
2392 rk816_bat_init_voltage_kb(di);
2393 BAT_INFO("caltimer: ioffset=0x%x, coffset=0x%x\n",
2394 ioffset, rk816_bat_get_coffset(di));
2395 }
2396
rk816_bat_init_caltimer(struct rk816_battery * di)2397 static void rk816_bat_init_caltimer(struct rk816_battery *di)
2398 {
2399 timer_setup(&di->caltimer, rk816_bat_caltimer_isr, 0);
2400 di->caltimer.expires = jiffies + MINUTE(8) * HZ;
2401 add_timer(&di->caltimer);
2402 INIT_DELAYED_WORK(&di->calib_delay_work, rk816_bat_internal_calib);
2403 }
2404
rk816_bat_init_zero_table(struct rk816_battery * di)2405 static void rk816_bat_init_zero_table(struct rk816_battery *di)
2406 {
2407 int i, diff, min, max;
2408 size_t ocv_size, length;
2409
2410 ocv_size = di->pdata->ocv_size;
2411 length = sizeof(di->pdata->zero_table) * ocv_size;
2412 di->pdata->zero_table =
2413 devm_kzalloc(di->dev, length, GFP_KERNEL);
2414 if (!di->pdata->zero_table) {
2415 di->pdata->zero_table = di->pdata->ocv_table;
2416 dev_err(di->dev, "malloc zero table fail\n");
2417 return;
2418 }
2419
2420 min = di->pdata->pwroff_vol,
2421 max = di->pdata->ocv_table[ocv_size - 4];
2422 diff = (max - min) / DIV(ocv_size - 1);
2423 for (i = 0; i < ocv_size; i++)
2424 di->pdata->zero_table[i] = min + (i * diff);
2425
2426 if (!dbg_enable)
2427 return;
2428
2429 for (i = 0; i < ocv_size; i++)
2430 DBG("zero[%d] = %d\n", i, di->pdata->zero_table[i]);
2431
2432 for (i = 0; i < ocv_size; i++)
2433 DBG("ocv[%d] = %d\n", i, di->pdata->ocv_table[i]);
2434 }
2435
rk816_bat_calc_sm_linek(struct rk816_battery * di)2436 static void rk816_bat_calc_sm_linek(struct rk816_battery *di)
2437 {
2438 int linek, current_avg;
2439 u8 diff, delta;
2440
2441 delta = abs(di->dsoc - di->rsoc);
2442 diff = delta * 3;/* speed:3/4 */
2443 current_avg = rk816_bat_get_avg_current(di);
2444 if (current_avg >= 0) {
2445 if (di->dsoc < di->rsoc)
2446 linek = 1000 * (delta + diff) / DIV(diff);
2447 else if (di->dsoc > di->rsoc)
2448 linek = 1000 * diff / DIV(delta + diff);
2449 else
2450 linek = 1000;
2451 di->dbg_meet_soc = (di->dsoc >= di->rsoc) ?
2452 (di->dsoc + diff) : (di->rsoc + diff);
2453 } else {
2454 if (di->dsoc < di->rsoc)
2455 linek = -1000 * diff / DIV(delta + diff);
2456 else if (di->dsoc > di->rsoc)
2457 linek = -1000 * (delta + diff) / DIV(diff);
2458 else
2459 linek = -1000;
2460 di->dbg_meet_soc = (di->dsoc >= di->rsoc) ?
2461 (di->dsoc - diff) : (di->rsoc - diff);
2462 }
2463
2464 di->sm_linek = linek;
2465 di->sm_remain_cap = di->remain_cap;
2466 di->dbg_calc_dsoc = di->dsoc;
2467 di->dbg_calc_rsoc = di->rsoc;
2468
2469 DBG("<%s>.diff=%d, k=%d, cur=%d\n", __func__, diff, linek, current_avg);
2470 }
2471
rk816_bat_calc_zero_linek(struct rk816_battery * di)2472 static void rk816_bat_calc_zero_linek(struct rk816_battery *di)
2473 {
2474 int dead_voltage, ocv_voltage;
2475 int voltage_avg, current_avg, vsys;
2476 int ocv_cap, dead_cap, xsoc;
2477 int ocv_soc, dead_soc;
2478 int pwroff_vol, org_linek = 0;
2479 int min_gap_xsoc;
2480
2481 if ((abs(di->current_avg) < 400) && (di->dsoc > 5))
2482 pwroff_vol = di->pdata->pwroff_vol + 50;
2483 else
2484 pwroff_vol = di->pdata->pwroff_vol;
2485
2486 /* calc estimate ocv voltage */
2487 voltage_avg = rk816_bat_get_avg_voltage(di);
2488 current_avg = rk816_bat_get_avg_current(di);
2489 vsys = voltage_avg + (current_avg * DEF_PWRPATH_RES) / 1000;
2490
2491 DBG("ZERO0: shtd_vol: org = %d, now = %d, zero_reserve_dsoc = %d\n",
2492 di->pdata->pwroff_vol, pwroff_vol, di->pdata->zero_reserve_dsoc);
2493
2494 dead_voltage = pwroff_vol - current_avg *
2495 (di->bat_res + DEF_PWRPATH_RES) / 1000;
2496 ocv_voltage = voltage_avg - (current_avg * di->bat_res) / 1000;
2497 DBG("ZERO0: dead_voltage(shtd) = %d, ocv_voltage(now) = %d\n",
2498 dead_voltage, ocv_voltage);
2499
2500 /* calc estimate soc and cap */
2501 dead_soc = rk816_bat_vol_to_zerosoc(di, dead_voltage);
2502 dead_cap = rk816_bat_vol_to_zerocap(di, dead_voltage);
2503 DBG("ZERO0: dead_soc = %d, dead_cap = %d\n",
2504 dead_soc, dead_cap);
2505
2506 ocv_soc = rk816_bat_vol_to_zerosoc(di, ocv_voltage);
2507 ocv_cap = rk816_bat_vol_to_zerocap(di, ocv_voltage);
2508 DBG("ZERO0: ocv_soc = %d, ocv_cap = %d\n",
2509 ocv_soc, ocv_cap);
2510
2511 /* xsoc: available rsoc */
2512 xsoc = ocv_soc - dead_soc;
2513
2514 /* min_gap_xsoc: reserve xsoc */
2515 if (abs(current_avg) > ZERO_LOAD_LVL1)
2516 min_gap_xsoc = MIN_ZERO_GAP_XSOC3;
2517 else if (abs(current_avg) > ZERO_LOAD_LVL2)
2518 min_gap_xsoc = MIN_ZERO_GAP_XSOC2;
2519 else
2520 min_gap_xsoc = MIN_ZERO_GAP_XSOC1;
2521
2522 if ((xsoc <= 30) && (di->dsoc >= di->pdata->zero_reserve_dsoc))
2523 min_gap_xsoc = min_gap_xsoc + MIN_ZERO_GAP_CALIB;
2524
2525 di->zero_remain_cap = di->remain_cap;
2526 di->zero_timeout_cnt = 0;
2527 if ((di->dsoc <= 1) && (xsoc > 0)) {
2528 di->zero_linek = 400;
2529 di->zero_drop_sec = 0;
2530 } else if (xsoc >= 0) {
2531 di->zero_drop_sec = 0;
2532 di->zero_linek = (di->zero_dsoc + xsoc / 2) / DIV(xsoc);
2533 org_linek = di->zero_linek;
2534 /* battery energy mode to use up voltage */
2535 if ((di->pdata->energy_mode) &&
2536 (xsoc - di->dsoc >= MIN_ZERO_GAP_XSOC3) &&
2537 (di->dsoc <= 10) && (di->zero_linek < 300)) {
2538 di->zero_linek = 300;
2539 DBG("ZERO-new: zero_linek adjust step0...\n");
2540 /* reserve enough power yet, slow down any way */
2541 } else if ((xsoc - di->dsoc >= min_gap_xsoc) ||
2542 ((xsoc - di->dsoc >= MIN_ZERO_GAP_XSOC2) &&
2543 (di->dsoc <= 10) && (xsoc > 15))) {
2544 if (xsoc <= 20 &&
2545 di->dsoc >= di->pdata->zero_reserve_dsoc)
2546 di->zero_linek = 1200;
2547 else if (xsoc - di->dsoc >= 2 * min_gap_xsoc)
2548 di->zero_linek = 400;
2549 else if (xsoc - di->dsoc >= 3 + min_gap_xsoc)
2550 di->zero_linek = 600;
2551 else
2552 di->zero_linek = 800;
2553 DBG("ZERO-new: zero_linek adjust step1...\n");
2554 /* control zero mode beginning enter */
2555 } else if ((di->zero_linek > 1800) && (di->dsoc > 70)) {
2556 di->zero_linek = 1800;
2557 DBG("ZERO-new: zero_linek adjust step2...\n");
2558 /* dsoc close to xsoc: it must reserve power */
2559 } else if ((di->zero_linek > 1000) && (di->zero_linek < 1200)) {
2560 di->zero_linek = 1200;
2561 DBG("ZERO-new: zero_linek adjust step3...\n");
2562 /* dsoc[5~15], dsoc < xsoc */
2563 } else if ((di->dsoc <= 15 && di->dsoc > 5) &&
2564 (di->zero_linek <= 1200)) {
2565 /* slow down */
2566 if ((xsoc - di->dsoc) >= min_gap_xsoc)
2567 di->zero_linek = 800;
2568 /* reserve power */
2569 else
2570 di->zero_linek = 1200;
2571 DBG("ZERO-new: zero_linek adjust step4...\n");
2572 /* dsoc[5, 100], dsoc < xsoc */
2573 } else if ((di->zero_linek < 1000) && (di->dsoc >= 5)) {
2574 if ((xsoc - di->dsoc) < min_gap_xsoc) {
2575 /* reserve power */
2576 di->zero_linek = 1200;
2577 } else {
2578 if (abs(di->current_avg) > 500)/* heavy */
2579 di->zero_linek = 900;
2580 else
2581 di->zero_linek = 1000;
2582 }
2583 DBG("ZERO-new: zero_linek adjust step5...\n");
2584 /* dsoc[0~5], dsoc < xsoc */
2585 } else if ((di->zero_linek < 1000) && (di->dsoc <= 5)) {
2586 if ((xsoc - di->dsoc) <= 3)
2587 di->zero_linek = 1200;
2588 else
2589 di->zero_linek = 800;
2590 DBG("ZERO-new: zero_linek adjust step6...\n");
2591 }
2592 } else {
2593 /* xsoc < 0 */
2594 di->zero_linek = 1000;
2595 if (!di->zero_drop_sec)
2596 di->zero_drop_sec = get_boot_sec();
2597 if (base2sec(di->zero_drop_sec) >= WAIT_DSOC_DROP_SEC) {
2598 DBG("ZERO0: t=%lu\n", base2sec(di->zero_drop_sec));
2599 di->zero_drop_sec = 0;
2600 di->dsoc--;
2601 di->zero_dsoc = (di->dsoc + 1) * 1000 -
2602 MIN_ACCURACY;
2603 }
2604 }
2605
2606 if (voltage_avg < pwroff_vol - 70) {
2607 if (!di->shtd_drop_sec)
2608 di->shtd_drop_sec = get_boot_sec();
2609 if (base2sec(di->shtd_drop_sec) > WAIT_SHTD_DROP_SEC) {
2610 BAT_INFO("voltage extreme low...soc:%d->0\n", di->dsoc);
2611 di->shtd_drop_sec = 0;
2612 di->dsoc = 0;
2613 }
2614 } else {
2615 di->shtd_drop_sec = 0;
2616 }
2617
2618 DBG("ZERO-new: org_linek=%d, zero_linek=%d, dsoc=%d, Xsoc=%d, rsoc=%d, gap=%d, v=%d, vsys=%d\n"
2619 "ZERO-new: di->zero_dsoc=%d, zero_remain_cap=%d, zero_drop=%ld, sht_drop=%ld\n\n",
2620 org_linek, di->zero_linek, di->dsoc, xsoc, di->rsoc,
2621 min_gap_xsoc, voltage_avg, vsys, di->zero_dsoc, di->zero_remain_cap,
2622 base2sec(di->zero_drop_sec), base2sec(di->shtd_drop_sec));
2623 }
2624
rk816_bat_finish_algo_prepare(struct rk816_battery * di)2625 static void rk816_bat_finish_algo_prepare(struct rk816_battery *di)
2626 {
2627 di->chrg_finish_base = get_boot_sec();
2628 if (!di->chrg_finish_base)
2629 di->chrg_finish_base = 1;
2630 }
2631
rk816_bat_smooth_algo_prepare(struct rk816_battery * di)2632 static void rk816_bat_smooth_algo_prepare(struct rk816_battery *di)
2633 {
2634 int tmp_soc;
2635
2636 tmp_soc = di->sm_chrg_dsoc / 1000;
2637 if (tmp_soc != di->dsoc)
2638 di->sm_chrg_dsoc = di->dsoc * 1000;
2639
2640 tmp_soc = di->sm_dischrg_dsoc / 1000;
2641 if (tmp_soc != di->dsoc)
2642 di->sm_dischrg_dsoc =
2643 (di->dsoc + 1) * 1000 - MIN_ACCURACY;
2644
2645 DBG("<%s>. tmp_soc=%d, dsoc=%d, dsoc:sm_dischrg=%d, sm_chrg=%d\n",
2646 __func__, tmp_soc, di->dsoc, di->sm_dischrg_dsoc, di->sm_chrg_dsoc);
2647
2648 rk816_bat_calc_sm_linek(di);
2649 }
2650
rk816_bat_zero_algo_prepare(struct rk816_battery * di)2651 static void rk816_bat_zero_algo_prepare(struct rk816_battery *di)
2652 {
2653 int tmp_dsoc;
2654
2655 di->zero_timeout_cnt = 0;
2656 tmp_dsoc = di->zero_dsoc / 1000;
2657 if (tmp_dsoc != di->dsoc)
2658 di->zero_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
2659
2660 DBG("<%s>. first calc, reinit linek\n", __func__);
2661
2662 rk816_bat_calc_zero_linek(di);
2663 }
2664
rk816_bat_calc_zero_algorithm(struct rk816_battery * di)2665 static void rk816_bat_calc_zero_algorithm(struct rk816_battery *di)
2666 {
2667 int tmp_soc = 0, sm_delta_dsoc = 0;
2668
2669 tmp_soc = di->zero_dsoc / 1000;
2670 if (tmp_soc == di->dsoc)
2671 goto out;
2672
2673 DBG("<%s>. enter: dsoc=%d, rsoc=%d\n", __func__, di->dsoc, di->rsoc);
2674 /* when discharge slow down, take sm chrg into calc */
2675 if (di->dsoc < di->rsoc) {
2676 /* take sm charge rest into calc */
2677 tmp_soc = di->sm_chrg_dsoc / 1000;
2678 if (tmp_soc == di->dsoc) {
2679 sm_delta_dsoc = di->sm_chrg_dsoc - di->dsoc * 1000;
2680 di->sm_chrg_dsoc = di->dsoc * 1000;
2681 di->zero_dsoc += sm_delta_dsoc;
2682 DBG("ZERO1: take sm chrg,delta=%d\n", sm_delta_dsoc);
2683 }
2684 }
2685
2686 /* when discharge speed up, take sm dischrg into calc */
2687 if (di->dsoc > di->rsoc) {
2688 /* take sm discharge rest into calc */
2689 tmp_soc = di->sm_dischrg_dsoc / 1000;
2690 if (tmp_soc == di->dsoc) {
2691 sm_delta_dsoc = di->sm_dischrg_dsoc -
2692 ((di->dsoc + 1) * 1000 - MIN_ACCURACY);
2693 di->sm_dischrg_dsoc = (di->dsoc + 1) * 1000 -
2694 MIN_ACCURACY;
2695 di->zero_dsoc += sm_delta_dsoc;
2696 DBG("ZERO1: take sm dischrg,delta=%d\n", sm_delta_dsoc);
2697 }
2698 }
2699
2700 /* check overflow */
2701 if (di->zero_dsoc > (di->dsoc + 1) * 1000 - MIN_ACCURACY) {
2702 DBG("ZERO1: zero dsoc overflow: %d\n", di->zero_dsoc);
2703 di->zero_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
2704 }
2705
2706 /* check new dsoc */
2707 tmp_soc = di->zero_dsoc / 1000;
2708 if (tmp_soc != di->dsoc) {
2709 /* avoid dsoc jump when heavy load */
2710 if ((di->dsoc - tmp_soc) > 1) {
2711 di->dsoc--;
2712 di->zero_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
2713 DBG("ZERO1: heavy load...\n");
2714 } else {
2715 di->dsoc = tmp_soc;
2716 }
2717 di->zero_drop_sec = 0;
2718 }
2719
2720 out:
2721 DBG("ZERO1: zero_dsoc(Y0)=%d, dsoc=%d, rsoc=%d, tmp_soc=%d\n",
2722 di->zero_dsoc, di->dsoc, di->rsoc, tmp_soc);
2723 DBG("ZERO1: sm_dischrg_dsoc=%d, sm_chrg_dsoc=%d\n",
2724 di->sm_dischrg_dsoc, di->sm_chrg_dsoc);
2725 }
2726
rk816_bat_zero_algorithm(struct rk816_battery * di)2727 static void rk816_bat_zero_algorithm(struct rk816_battery *di)
2728 {
2729 int delta_cap = 0, delta_soc = 0;
2730
2731 di->zero_timeout_cnt++;
2732 delta_cap = di->zero_remain_cap - di->remain_cap;
2733 delta_soc = di->zero_linek * (delta_cap * 100) / DIV(di->fcc);
2734
2735 DBG("ZERO1: zero_linek=%d, zero_dsoc(Y0)=%d, dsoc=%d, rsoc=%d\n"
2736 "ZERO1: delta_soc(X0)=%d, delta_cap=%d, zero_remain_cap = %d\n"
2737 "ZERO1: timeout_cnt=%d, sm_dischrg=%d, sm_chrg=%d\n\n",
2738 di->zero_linek, di->zero_dsoc, di->dsoc, di->rsoc,
2739 delta_soc, delta_cap, di->zero_remain_cap,
2740 di->zero_timeout_cnt, di->sm_dischrg_dsoc, di->sm_chrg_dsoc);
2741
2742 if ((delta_soc >= MIN_ZERO_DSOC_ACCURACY) ||
2743 (di->zero_timeout_cnt > MIN_ZERO_OVERCNT) ||
2744 (di->zero_linek == 0)) {
2745 DBG("ZERO1:--------- enter calc -----------\n");
2746 di->zero_timeout_cnt = 0;
2747 di->zero_dsoc -= delta_soc;
2748 rk816_bat_calc_zero_algorithm(di);
2749 rk816_bat_calc_zero_linek(di);
2750 }
2751 }
2752
rk816_bat_dump_time_table(struct rk816_battery * di)2753 static void rk816_bat_dump_time_table(struct rk816_battery *di)
2754 {
2755 u8 i;
2756 static int old_index;
2757 static int old_min;
2758 u32 time;
2759 int mod = di->dsoc % 10;
2760 int index = di->dsoc / 10;
2761
2762 if (rk816_bat_chrg_online(di))
2763 time = base2min(di->plug_in_base);
2764 else
2765 time = base2min(di->plug_out_base);
2766
2767 if ((mod == 0) && (index > 0) && (old_index != index)) {
2768 di->dbg_chrg_min[index - 1] = time - old_min;
2769 old_min = time;
2770 old_index = index;
2771 }
2772
2773 for (i = 1; i < 11; i++)
2774 DBG("Time[%d]=%d, ", (i * 10), di->dbg_chrg_min[i - 1]);
2775 DBG("\n");
2776 }
2777
rk816_bat_debug_info(struct rk816_battery * di)2778 static void rk816_bat_debug_info(struct rk816_battery *di)
2779 {
2780 u8 sup_tst, ggcon, ggsts, vb_mod, ts_ctrl, reboot_cnt;
2781 u8 usb_ctrl, chrg_ctrl1, thermal;
2782 u8 int_sts1, int_sts2, int_sts3;
2783 u8 int_msk1, int_msk2, int_msk3;
2784 u8 chrg_ctrl2, chrg_ctrl3, rtc, misc, dcdc_en2;
2785 u32 chrg_sel;
2786 const char *work_mode[] = {"ZERO", "FINISH", "UN", "UN", "SMOOTH"};
2787 const char *bat_mode[] = {"BAT", "VIRTUAL"};
2788
2789 if (rk816_bat_chrg_online(di))
2790 di->plug_out_base = get_boot_sec();
2791 else
2792 di->plug_in_base = get_boot_sec();
2793
2794 rk816_bat_dump_time_table(di);
2795
2796 if (!dbg_enable)
2797 return;
2798
2799 reboot_cnt = rk816_bat_read(di, RK816_REBOOT_CNT_REG);
2800 ts_ctrl = rk816_bat_read(di, RK816_TS_CTRL_REG);
2801 misc = rk816_bat_read(di, RK816_MISC_MARK_REG);
2802 ggcon = rk816_bat_read(di, RK816_GGCON_REG);
2803 ggsts = rk816_bat_read(di, RK816_GGSTS_REG);
2804 sup_tst = rk816_bat_read(di, RK816_SUP_STS_REG);
2805 vb_mod = rk816_bat_read(di, RK816_VB_MON_REG);
2806 usb_ctrl = rk816_bat_read(di, RK816_USB_CTRL_REG);
2807 chrg_ctrl1 = rk816_bat_read(di, RK816_CHRG_CTRL_REG1);
2808 chrg_ctrl2 = rk816_bat_read(di, RK816_CHRG_CTRL_REG2);
2809 chrg_ctrl3 = rk816_bat_read(di, RK816_CHRG_CTRL_REG3);
2810 rtc = rk816_bat_read(di, RK808_SECONDS_REG);
2811 thermal = rk816_bat_read(di, RK816_THERMAL_REG);
2812 int_sts1 = rk816_bat_read(di, RK816_INT_STS_REG1);
2813 int_sts2 = rk816_bat_read(di, RK816_INT_STS_REG2);
2814 int_sts3 = rk816_bat_read(di, RK816_INT_STS_REG3);
2815 int_msk1 = rk816_bat_read(di, RK816_INT_STS_MSK_REG1);
2816 int_msk2 = rk816_bat_read(di, RK816_INT_STS_MSK_REG2);
2817 int_msk3 = rk816_bat_read(di, RK816_INT_STS_MSK_REG3);
2818 dcdc_en2 = rk816_bat_read(di, RK816_DCDC_EN_REG2);
2819 chrg_sel = CHRG_CUR_SEL[chrg_ctrl1 & 0x0f];
2820 if (!di->over_20mR)
2821 chrg_sel = RES_FAC_MUX(chrg_sel, di->res_fac);
2822 else
2823 chrg_sel = RES_FAC_DIV(chrg_sel, di->res_fac);
2824
2825 DBG("\n------- DEBUG REGS, [Ver: %s] -------------------\n"
2826 "GGCON=0x%2x, GGSTS=0x%2x, RTC=0x%2x, DCDC_EN2=0x%2x\n"
2827 "SUP_STS= 0x%2x, VB_MOD=0x%2x, USB_CTRL=0x%2x\n"
2828 "THERMAL=0x%2x, MISC_MARK=0x%2x, TS_CTRL=0x%2x\n"
2829 "CHRG_CTRL:REG1=0x%2x, REG2=0x%2x, REG3=0x%2x\n"
2830 "INT_STS: REG1=0x%2x, REG2=0x%2x, REG3=0x%2x\n"
2831 "INT_MSK: REG1=0x%2x, REG2=0x%2x, REG3=0x%2x\n",
2832 DRIVER_VERSION, ggcon, ggsts, rtc, dcdc_en2,
2833 sup_tst, vb_mod, usb_ctrl,
2834 thermal, misc, ts_ctrl,
2835 chrg_ctrl1, chrg_ctrl2, chrg_ctrl3,
2836 int_sts1, int_sts2, int_sts3,
2837 int_msk1, int_msk2, int_msk3
2838 );
2839
2840 DBG("###############################################################\n"
2841 "Dsoc=%d, Rsoc=%d, Vavg=%d, Iavg=%d, Cap=%d, Fcc=%d, d=%d\n"
2842 "K=%d, Mode=%s, Oldcap=%d, Is=%d, Ip=%d, Vs=%d, Vusb=%d\n"
2843 "AC=%d, USB=%d, DC=%d, OTG=%d, 5V=%d, PROP=%d, Tfb=%d, Tbat=%d\n"
2844 "off:i=0x%x, c=0x%x, p=%d, Rbat=%d, age_ocv_cap=%d, fb=%d, hot=%d\n"
2845 "adp:in=%lu, out=%lu, finish=%lu, LFcc=%d, boot_min=%lu, sleep_min=%lu, adc=%d, Rfac=%d\n"
2846 "bat:%s, meet: soc=%d, calc: dsoc=%d, rsoc=%d, Vocv=%d, Rsam=%d\n"
2847 "pwr: dsoc=%d, rsoc=%d, vol=%d, halt: st=%d, cnt=%d, reboot=%d\n"
2848 "ocv_c=%d: %d -> %d; max_c=%d: %d -> %d; force_c=%d: %d -> %d\n"
2849 "min=%d, init=%d, sw=%d, below0=%d, first=%d, changed=%d\n"
2850 "###############################################################\n",
2851 di->dsoc, di->rsoc, di->voltage_avg, di->current_avg,
2852 di->remain_cap, di->fcc, di->dsoc - di->rsoc,
2853 di->sm_linek, work_mode[di->work_mode], di->sm_remain_cap,
2854 chrg_sel,
2855 CHRG_CUR_INPUT[usb_ctrl & 0x0f],
2856 CHRG_VOL_SEL[(chrg_ctrl1 & 0x70) >> 4],
2857 rk816_bat_get_usb_voltage(di),
2858 di->ac_in, di->usb_in, di->dc_in, di->otg_in, di->otg_pmic5v,
2859 di->prop_status,
2860 FEED_BACK_TEMP[(thermal & 0x0c) >> 2], di->temperature,
2861 rk816_bat_get_ioffset(di), rk816_bat_get_coffset(di),
2862 di->poffset, di->bat_res, di->age_adjust_cap, di->fb_blank,
2863 !!(thermal & HOTDIE_STS),
2864 base2min(di->plug_in_base), base2min(di->plug_out_base),
2865 base2min(di->chrg_finish_base), di->lock_fcc,
2866 base2min(di->boot_base), di->sleep_sum_sec / 60,
2867 di->adc_allow_update, di->res_fac,
2868 bat_mode[di->pdata->bat_mode], di->dbg_meet_soc,
2869 di->dbg_calc_dsoc, di->dbg_calc_rsoc, di->voltage_ocv,
2870 di->pdata->sample_res,
2871 di->dbg_pwr_dsoc, di->dbg_pwr_rsoc, di->dbg_pwr_vol, di->is_halt,
2872 di->halt_cnt, reboot_cnt,
2873 di->is_ocv_calib, di->ocv_pre_dsoc, di->ocv_new_dsoc,
2874 di->is_max_soc_offset, di->max_pre_dsoc, di->max_new_dsoc,
2875 di->is_force_calib, di->force_pre_dsoc, di->force_new_dsoc,
2876 di->pwroff_min, di->is_initialized, di->is_sw_reset,
2877 di->dbg_cap_low0, di->is_first_on, di->last_dsoc
2878 );
2879 }
2880
rk816_bat_init_capacity(struct rk816_battery * di,u32 cap)2881 static void rk816_bat_init_capacity(struct rk816_battery *di, u32 cap)
2882 {
2883 int delta_cap;
2884
2885 delta_cap = cap - di->remain_cap;
2886 if (!delta_cap)
2887 return;
2888
2889 di->age_adjust_cap += delta_cap;
2890 rk816_bat_init_coulomb_cap(di, cap);
2891 rk816_bat_smooth_algo_prepare(di);
2892 rk816_bat_zero_algo_prepare(di);
2893 }
2894
rk816_bat_update_age_fcc(struct rk816_battery * di)2895 static void rk816_bat_update_age_fcc(struct rk816_battery *di)
2896 {
2897 int fcc;
2898 int remain_cap;
2899 int age_keep_min;
2900
2901 di->lock_fcc = rk816_bat_get_lock_fcc(di);
2902 if (di->lock_fcc == 0)
2903 return;
2904
2905 fcc = di->lock_fcc;
2906 remain_cap = fcc - di->age_ocv_cap - di->age_adjust_cap;
2907 age_keep_min = base2min(di->age_keep_sec);
2908
2909 DBG("%s: lock_fcc=%d, age_ocv_cap=%d, age_adjust_cap=%d, remain_cap=%d, age_allow_update=%d, age_keep_min=%d\n",
2910 __func__, fcc, di->age_ocv_cap, di->age_adjust_cap, remain_cap,
2911 di->age_allow_update, age_keep_min);
2912
2913 if ((di->chrg_status == CHARGE_FINISH) && (di->age_allow_update) &&
2914 (age_keep_min < 1200)) {
2915 di->age_allow_update = false;
2916 fcc = remain_cap * 100 / DIV(100 - di->age_ocv_soc);
2917 BAT_INFO("lock_fcc=%d, calc_cap=%d, age: soc=%d, cap=%d, level=%d, fcc:%d->%d?\n",
2918 di->lock_fcc, remain_cap, di->age_ocv_soc,
2919 di->age_ocv_cap, di->age_level, di->fcc, fcc);
2920
2921 if ((fcc < di->qmax) && (fcc > MIN_FCC)) {
2922 BAT_INFO("fcc:%d->%d!\n", di->fcc, fcc);
2923 di->fcc = fcc;
2924 rk816_bat_init_capacity(di, di->fcc);
2925 rk816_bat_save_fcc(di, di->fcc);
2926 rk816_bat_save_age_level(di, di->age_level);
2927 }
2928 }
2929 }
2930
rk816_bat_wait_finish_sig(struct rk816_battery * di)2931 static void rk816_bat_wait_finish_sig(struct rk816_battery *di)
2932 {
2933 int chrg_finish_vol = di->pdata->max_chrg_voltage;
2934
2935 if (!rk816_bat_chrg_online(di))
2936 return;
2937
2938 if ((di->chrg_status == CHARGE_FINISH) &&
2939 (!is_rk816_bat_st_cvtlim(di)) &&
2940 (di->voltage_avg > chrg_finish_vol - 150) && di->adc_allow_update) {
2941 rk816_bat_update_age_fcc(di);/* save new fcc*/
2942 if (rk816_bat_adc_calib(di))
2943 di->adc_allow_update = false;
2944 }
2945 }
2946
rk816_bat_finish_algorithm(struct rk816_battery * di)2947 static void rk816_bat_finish_algorithm(struct rk816_battery *di)
2948 {
2949 unsigned long finish_sec, soc_sec;
2950 int plus_soc, finish_current, rest = 0;
2951
2952 /* rsoc */
2953 if ((di->remain_cap != di->fcc) &&
2954 (rk816_bat_get_chrg_status(di) == CHARGE_FINISH)) {
2955 di->age_adjust_cap += (di->fcc - di->remain_cap);
2956 rk816_bat_init_coulomb_cap(di, di->fcc);
2957 }
2958
2959 /* dsoc */
2960 if (di->dsoc < 100) {
2961 if (!di->chrg_finish_base)
2962 di->chrg_finish_base = get_boot_sec();
2963
2964 finish_current = (di->rsoc - di->dsoc) > FINISH_MAX_SOC_DELAY ?
2965 FINISH_CHRG_CUR2 : FINISH_CHRG_CUR1;
2966 finish_sec = base2sec(di->chrg_finish_base);
2967 soc_sec = di->fcc * 3600 / 100 / DIV(finish_current);
2968 plus_soc = finish_sec / DIV(soc_sec);
2969 if (finish_sec > soc_sec) {
2970 rest = finish_sec % soc_sec;
2971 di->dsoc += plus_soc;
2972 di->chrg_finish_base = get_boot_sec();
2973 if (di->chrg_finish_base > rest)
2974 di->chrg_finish_base = get_boot_sec() - rest;
2975 }
2976 DBG("<%s>.CHARGE_FINISH:dsoc<100,dsoc=%d\n"
2977 "soc_time=%lu, sec_finish=%lu, plus_soc=%d, rest=%d\n",
2978 __func__, di->dsoc, soc_sec, finish_sec, plus_soc, rest);
2979 }
2980 }
2981
rk816_bat_calc_smooth_dischrg(struct rk816_battery * di)2982 static void rk816_bat_calc_smooth_dischrg(struct rk816_battery *di)
2983 {
2984 int tmp_soc = 0, sm_delta_dsoc = 0, zero_delta_dsoc = 0;
2985
2986 tmp_soc = di->sm_dischrg_dsoc / 1000;
2987 if (tmp_soc == di->dsoc)
2988 goto out;
2989
2990 DBG("<%s>. enter: dsoc=%d, rsoc=%d\n", __func__, di->dsoc, di->rsoc);
2991 /* when dischrge slow down, take sm charge rest into calc */
2992 if (di->dsoc < di->rsoc) {
2993 tmp_soc = di->sm_chrg_dsoc / 1000;
2994 if (tmp_soc == di->dsoc) {
2995 sm_delta_dsoc = di->sm_chrg_dsoc - di->dsoc * 1000;
2996 di->sm_chrg_dsoc = di->dsoc * 1000;
2997 di->sm_dischrg_dsoc += sm_delta_dsoc;
2998 DBG("<%s>. take sm dischrg, delta=%d\n",
2999 __func__, sm_delta_dsoc);
3000 }
3001 }
3002
3003 /* when discharge speed up, take zero discharge rest into calc */
3004 if (di->dsoc > di->rsoc) {
3005 tmp_soc = di->zero_dsoc / 1000;
3006 if (tmp_soc == di->dsoc) {
3007 zero_delta_dsoc = di->zero_dsoc - ((di->dsoc + 1) *
3008 1000 - MIN_ACCURACY);
3009 di->zero_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
3010 di->sm_dischrg_dsoc += zero_delta_dsoc;
3011 DBG("<%s>. take zero schrg, delta=%d\n",
3012 __func__, zero_delta_dsoc);
3013 }
3014 }
3015
3016 /* check up overflow */
3017 if ((di->sm_dischrg_dsoc) > ((di->dsoc + 1) * 1000 - MIN_ACCURACY)) {
3018 DBG("<%s>. dischrg_dsoc up overflow\n", __func__);
3019 di->sm_dischrg_dsoc = (di->dsoc + 1) *
3020 1000 - MIN_ACCURACY;
3021 }
3022
3023 /* check new dsoc */
3024 tmp_soc = di->sm_dischrg_dsoc / 1000;
3025 if (tmp_soc != di->dsoc) {
3026 di->dsoc = tmp_soc;
3027 di->sm_chrg_dsoc = di->dsoc * 1000;
3028 }
3029 out:
3030 DBG("<%s>. dsoc=%d, rsoc=%d, dsoc:sm_dischrg=%d, sm_chrg=%d, zero=%d\n",
3031 __func__, di->dsoc, di->rsoc, di->sm_dischrg_dsoc, di->sm_chrg_dsoc,
3032 di->zero_dsoc);
3033 }
3034
rk816_bat_calc_smooth_chrg(struct rk816_battery * di)3035 static void rk816_bat_calc_smooth_chrg(struct rk816_battery *di)
3036 {
3037 int tmp_soc = 0, sm_delta_dsoc = 0, zero_delta_dsoc = 0;
3038
3039 tmp_soc = di->sm_chrg_dsoc / 1000;
3040 if (tmp_soc == di->dsoc)
3041 goto out;
3042
3043 DBG("<%s>. enter: dsoc=%d, rsoc=%d\n", __func__, di->dsoc, di->rsoc);
3044 /* when charge slow down, take zero & sm dischrg into calc */
3045 if (di->dsoc > di->rsoc) {
3046 /* take sm discharge rest into calc */
3047 tmp_soc = di->sm_dischrg_dsoc / 1000;
3048 if (tmp_soc == di->dsoc) {
3049 sm_delta_dsoc = di->sm_dischrg_dsoc -
3050 ((di->dsoc + 1) * 1000 - MIN_ACCURACY);
3051 di->sm_dischrg_dsoc = (di->dsoc + 1) * 1000 -
3052 MIN_ACCURACY;
3053 di->sm_chrg_dsoc += sm_delta_dsoc;
3054 DBG("<%s>. take sm dischrg, delta=%d\n",
3055 __func__, sm_delta_dsoc);
3056 }
3057
3058 /* take zero discharge rest into calc */
3059 tmp_soc = di->zero_dsoc / 1000;
3060 if (tmp_soc == di->dsoc) {
3061 zero_delta_dsoc = di->zero_dsoc -
3062 ((di->dsoc + 1) * 1000 - MIN_ACCURACY);
3063 di->zero_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
3064 di->sm_chrg_dsoc += zero_delta_dsoc;
3065 DBG("<%s>. take zero dischrg, delta=%d\n",
3066 __func__, zero_delta_dsoc);
3067 }
3068 }
3069
3070 /* check down overflow */
3071 if (di->sm_chrg_dsoc < di->dsoc * 1000) {
3072 DBG("<%s>. chrg_dsoc down overflow\n", __func__);
3073 di->sm_chrg_dsoc = di->dsoc * 1000;
3074 }
3075
3076 /* check new dsoc */
3077 tmp_soc = di->sm_chrg_dsoc / 1000;
3078 if (tmp_soc != di->dsoc) {
3079 di->dsoc = tmp_soc;
3080 di->sm_dischrg_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
3081 }
3082 out:
3083 DBG("<%s>.dsoc=%d, rsoc=%d, dsoc: sm_dischrg=%d, sm_chrg=%d, zero=%d\n",
3084 __func__, di->dsoc, di->rsoc, di->sm_dischrg_dsoc, di->sm_chrg_dsoc,
3085 di->zero_dsoc);
3086 }
3087
rk816_bat_smooth_algorithm(struct rk816_battery * di)3088 static void rk816_bat_smooth_algorithm(struct rk816_battery *di)
3089 {
3090 int ydsoc = 0, delta_cap = 0, old_cap = 0;
3091 unsigned long tgt_sec = 0;
3092
3093 di->remain_cap = rk816_bat_get_coulomb_cap(di);
3094
3095 /* full charge: slow down */
3096 if ((di->dsoc == 99) && (di->chrg_status == CC_OR_CV) &&
3097 (di->current_avg > 0)) {
3098 di->sm_linek = FULL_CHRG_K;
3099 /* terminal charge, slow down */
3100 } else if ((di->current_avg >= TERM_CHRG_CURR) &&
3101 (di->chrg_status == CC_OR_CV) && (di->dsoc >= TERM_CHRG_DSOC)) {
3102 di->sm_linek = TERM_CHRG_K;
3103 DBG("<%s>. terminal mode..\n", __func__);
3104 /* simulate charge, speed up */
3105 } else if ((di->current_avg <= SIMULATE_CHRG_CURR) &&
3106 (di->current_avg > 0) && (di->chrg_status == CC_OR_CV) &&
3107 (di->dsoc < TERM_CHRG_DSOC) &&
3108 ((di->rsoc - di->dsoc) >= SIMULATE_CHRG_INTV)) {
3109 di->sm_linek = SIMULATE_CHRG_K;
3110 DBG("<%s>. simulate mode..\n", __func__);
3111 } else {
3112 /* charge and discharge switch */
3113 if ((di->sm_linek * di->current_avg <= 0) ||
3114 (di->sm_linek == TERM_CHRG_K) ||
3115 (di->sm_linek == FULL_CHRG_K) ||
3116 (di->sm_linek == SIMULATE_CHRG_K)) {
3117 DBG("<%s>. linek mode, retinit sm linek..\n", __func__);
3118 rk816_bat_calc_sm_linek(di);
3119 }
3120 }
3121
3122 old_cap = di->sm_remain_cap;
3123 /*
3124 * when dsoc equal rsoc(not include full, term, simulate case),
3125 * sm_linek should change to -1000/1000 smoothly to avoid dsoc+1/-1
3126 * right away, so change it after flat seconds
3127 */
3128 if ((di->dsoc == di->rsoc) && (abs(di->sm_linek) != 1000) &&
3129 (di->sm_linek != FULL_CHRG_K && di->sm_linek != TERM_CHRG_K &&
3130 di->sm_linek != SIMULATE_CHRG_K)) {
3131 if (!di->flat_match_sec)
3132 di->flat_match_sec = get_boot_sec();
3133 tgt_sec = di->fcc * 3600 / 100 / DIV(abs(di->current_avg)) / 3;
3134 if (base2sec(di->flat_match_sec) >= tgt_sec) {
3135 di->flat_match_sec = 0;
3136 di->sm_linek = (di->current_avg >= 0) ? 1000 : -1000;
3137 }
3138 DBG("<%s>. flat_sec=%ld, tgt_sec=%ld, sm_k=%d\n", __func__,
3139 base2sec(di->flat_match_sec), tgt_sec, di->sm_linek);
3140 } else {
3141 di->flat_match_sec = 0;
3142 }
3143
3144 /* abs(k)=1000 or dsoc=100, stop calc */
3145 if ((abs(di->sm_linek) == 1000) || (di->current_avg >= 0 &&
3146 di->chrg_status == CC_OR_CV && di->dsoc >= 100)) {
3147 DBG("<%s>. sm_linek=%d\n", __func__, di->sm_linek);
3148 if (abs(di->sm_linek) == 1000) {
3149 di->dsoc = di->rsoc;
3150 di->sm_linek = (di->sm_linek > 0) ? 1000 : -1000;
3151 DBG("<%s>. dsoc == rsoc, sm_linek=%d\n",
3152 __func__, di->sm_linek);
3153 }
3154 di->sm_remain_cap = di->remain_cap;
3155 di->sm_chrg_dsoc = di->dsoc * 1000;
3156 di->sm_dischrg_dsoc = (di->dsoc + 1) * 1000 - MIN_ACCURACY;
3157 DBG("<%s>. sm_dischrg_dsoc=%d, sm_chrg_dsoc=%d\n",
3158 __func__, di->sm_dischrg_dsoc, di->sm_chrg_dsoc);
3159 } else {
3160 delta_cap = di->remain_cap - di->sm_remain_cap;
3161 if (delta_cap == 0) {
3162 DBG("<%s>. delta_cap = 0\n", __func__);
3163 return;
3164 }
3165 ydsoc = di->sm_linek * abs(delta_cap) * 100 / DIV(di->fcc);
3166 if (ydsoc == 0) {
3167 DBG("<%s>. ydsoc = 0\n", __func__);
3168 return;
3169 }
3170 di->sm_remain_cap = di->remain_cap;
3171
3172 DBG("<%s>. k=%d, ydsoc=%d; cap:old=%d, new:%d; delta_cap=%d\n",
3173 __func__, di->sm_linek, ydsoc, old_cap,
3174 di->sm_remain_cap, delta_cap);
3175
3176 /* discharge mode */
3177 if (ydsoc < 0) {
3178 di->sm_dischrg_dsoc += ydsoc;
3179 rk816_bat_calc_smooth_dischrg(di);
3180 /* charge mode */
3181 } else {
3182 di->sm_chrg_dsoc += ydsoc;
3183 rk816_bat_calc_smooth_chrg(di);
3184 }
3185
3186 if (di->s2r) {
3187 di->s2r = false;
3188 rk816_bat_calc_sm_linek(di);
3189 }
3190 }
3191 }
3192
rk816_bat_fake_finish_mode(struct rk816_battery * di)3193 static bool rk816_bat_fake_finish_mode(struct rk816_battery *di)
3194 {
3195 if ((di->rsoc == 100) && (rk816_bat_get_chrg_status(di) == CC_OR_CV) &&
3196 (abs(di->current_avg) <= 100))
3197 return true;
3198 else
3199 return false;
3200 }
3201
rk816_bat_display_smooth(struct rk816_battery * di)3202 static void rk816_bat_display_smooth(struct rk816_battery *di)
3203 {
3204 /* discharge: reinit "zero & smooth" algorithm to avoid handling dsoc */
3205 if (di->s2r && !di->sleep_chrg_online) {
3206 DBG("s2r: discharge, reset algorithm...\n");
3207 di->s2r = false;
3208 rk816_bat_zero_algo_prepare(di);
3209 rk816_bat_smooth_algo_prepare(di);
3210 return;
3211 }
3212
3213 if (di->work_mode == MODE_FINISH) {
3214 DBG("step1: charge finish...\n");
3215 rk816_bat_finish_algorithm(di);
3216 if ((rk816_bat_get_chrg_status(di) != CHARGE_FINISH) &&
3217 !rk816_bat_fake_finish_mode(di)) {
3218 if ((di->current_avg < 0) &&
3219 (di->voltage_avg < di->pdata->zero_algorithm_vol)) {
3220 DBG("step1: change to zero mode...\n");
3221 rk816_bat_zero_algo_prepare(di);
3222 di->work_mode = MODE_ZERO;
3223 } else {
3224 DBG("step1: change to smooth mode...\n");
3225 rk816_bat_smooth_algo_prepare(di);
3226 di->work_mode = MODE_SMOOTH;
3227 }
3228 }
3229 } else if (di->work_mode == MODE_ZERO) {
3230 DBG("step2: zero algorithm...\n");
3231 rk816_bat_zero_algorithm(di);
3232 if ((di->voltage_avg >= di->pdata->zero_algorithm_vol + 50) ||
3233 (di->current_avg >= 0)) {
3234 DBG("step2: change to smooth mode...\n");
3235 rk816_bat_smooth_algo_prepare(di);
3236 di->work_mode = MODE_SMOOTH;
3237 } else if ((rk816_bat_get_chrg_status(di) == CHARGE_FINISH) ||
3238 rk816_bat_fake_finish_mode(di)) {
3239 DBG("step2: change to finish mode...\n");
3240 rk816_bat_finish_algo_prepare(di);
3241 di->work_mode = MODE_FINISH;
3242 }
3243 } else {
3244 DBG("step3: smooth algorithm...\n");
3245 rk816_bat_smooth_algorithm(di);
3246 if ((di->current_avg < 0) &&
3247 (di->voltage_avg < di->pdata->zero_algorithm_vol)) {
3248 DBG("step3: change to zero mode...\n");
3249 rk816_bat_zero_algo_prepare(di);
3250 di->work_mode = MODE_ZERO;
3251 } else if ((rk816_bat_get_chrg_status(di) == CHARGE_FINISH) ||
3252 rk816_bat_fake_finish_mode(di)) {
3253 DBG("step3: change to finish mode...\n");
3254 rk816_bat_finish_algo_prepare(di);
3255 di->work_mode = MODE_FINISH;
3256 }
3257 }
3258 }
3259
rk816_bat_relax_vol_calib(struct rk816_battery * di)3260 static void rk816_bat_relax_vol_calib(struct rk816_battery *di)
3261 {
3262 int soc, cap, vol;
3263
3264 vol = di->voltage_relax - (di->current_relax * di->bat_res) / 1000;
3265 soc = rk816_bat_vol_to_ocvsoc(di, vol);
3266 cap = rk816_bat_vol_to_ocvcap(di, vol);
3267 rk816_bat_init_capacity(di, cap);
3268 BAT_INFO("sleep ocv calib: rsoc=%d, cap=%d\n", soc, cap);
3269 }
3270
rk816_bat_relife_age_flag(struct rk816_battery * di)3271 static void rk816_bat_relife_age_flag(struct rk816_battery *di)
3272 {
3273 u8 ocv_soc, ocv_cap, soc_level;
3274
3275 if (di->voltage_relax <= 0)
3276 return;
3277
3278 ocv_soc = rk816_bat_vol_to_ocvsoc(di, di->voltage_relax);
3279 ocv_cap = rk816_bat_vol_to_ocvcap(di, di->voltage_relax);
3280 DBG("<%s>. ocv_soc=%d, min=%lu, vol=%d\n", __func__,
3281 ocv_soc, di->sleep_dischrg_sec / 60, di->voltage_relax);
3282
3283 /* sleep enough time and ocv_soc enough low */
3284 if (!di->age_allow_update && ocv_soc <= 10) {
3285 di->age_voltage = di->voltage_relax;
3286 di->age_ocv_cap = ocv_cap;
3287 di->age_ocv_soc = ocv_soc;
3288 di->age_adjust_cap = 0;
3289
3290 if (ocv_soc <= 1)
3291 di->age_level = 100;
3292 else if (ocv_soc < 5)
3293 di->age_level = 90;
3294 else
3295 di->age_level = 80;
3296
3297 soc_level = rk816_bat_get_age_level(di);
3298 if (soc_level > di->age_level) {
3299 di->age_allow_update = false;
3300 } else {
3301 di->age_allow_update = true;
3302 di->age_keep_sec = get_boot_sec();
3303 }
3304
3305 BAT_INFO("resume: age_vol:%d, age_ocv_cap:%d, age_ocv_soc:%d, age_soc_level:%d, age_allow_update:%d, age_level:%d\n",
3306 di->age_voltage, di->age_ocv_cap, ocv_soc, soc_level,
3307 di->age_allow_update, di->age_level);
3308 }
3309 }
3310
rk816_bat_sleep_dischrg(struct rk816_battery * di)3311 static int rk816_bat_sleep_dischrg(struct rk816_battery *di)
3312 {
3313 bool ocv_soc_updated = false;
3314 int tgt_dsoc, gap_soc, sleep_soc = 0;
3315 int pwroff_vol = di->pdata->pwroff_vol;
3316 unsigned long sleep_sec = di->sleep_dischrg_sec;
3317
3318 DBG("<%s>. enter: dsoc=%d, rsoc=%d, rv=%d, v=%d, sleep_min=%lu\n",
3319 __func__, di->dsoc, di->rsoc, di->voltage_relax,
3320 di->voltage_avg, sleep_sec / 60);
3321
3322 if (di->voltage_relax >= di->voltage_avg) {
3323 rk816_bat_relax_vol_calib(di);
3324 rk816_bat_restart_relax(di);
3325 rk816_bat_relife_age_flag(di);
3326 ocv_soc_updated = true;
3327 }
3328
3329 /*handle dsoc*/
3330 if (di->dsoc <= di->rsoc) {
3331 di->sleep_sum_cap = (SLP_CURR_MIN * sleep_sec / 3600);
3332 sleep_soc = di->sleep_sum_cap * 100 / DIV(di->fcc);
3333 tgt_dsoc = di->dsoc - sleep_soc;
3334 if (sleep_soc > 0) {
3335 BAT_INFO("calib0: rl=%d, dl=%d, intval=%d\n",
3336 di->rsoc, di->dsoc, sleep_soc);
3337 if (di->dsoc < 5) {
3338 di->dsoc--;
3339 } else if ((tgt_dsoc < 5) && (di->dsoc >= 5)) {
3340 if (di->dsoc == 5)
3341 di->dsoc--;
3342 else
3343 di->dsoc = 5;
3344 } else if (tgt_dsoc > 5) {
3345 di->dsoc = tgt_dsoc;
3346 }
3347 }
3348
3349 DBG("%s: dsoc<=rsoc, sum_cap=%d==>sleep_soc=%d, tgt_dsoc=%d\n",
3350 __func__, di->sleep_sum_cap, sleep_soc, tgt_dsoc);
3351 } else {
3352 /*di->dsoc > di->rsoc*/
3353 di->sleep_sum_cap = (SLP_CURR_MAX * sleep_sec / 3600);
3354 sleep_soc = di->sleep_sum_cap / DIV(di->fcc / 100);
3355 gap_soc = di->dsoc - di->rsoc;
3356
3357 BAT_INFO("calib1: rsoc=%d, dsoc=%d, intval=%d\n",
3358 di->rsoc, di->dsoc, sleep_soc);
3359 if (gap_soc > sleep_soc) {
3360 if ((gap_soc - 5) > (sleep_soc * 2))
3361 di->dsoc -= (sleep_soc * 2);
3362 else
3363 di->dsoc -= sleep_soc;
3364 } else {
3365 di->dsoc = di->rsoc;
3366 }
3367
3368 DBG("%s: dsoc>rsoc, sum_cap=%d=>sleep_soc=%d, gap_soc=%d\n",
3369 __func__, di->sleep_sum_cap, sleep_soc, gap_soc);
3370 }
3371
3372 if (di->voltage_avg <= pwroff_vol - 70) {
3373 di->dsoc = 0;
3374 rk_send_wakeup_key();
3375 BAT_INFO("low power sleeping, shutdown... %d\n", di->dsoc);
3376 }
3377
3378 if (ocv_soc_updated && sleep_soc && (di->rsoc - di->dsoc) < 5 &&
3379 di->dsoc < 40) {
3380 di->dsoc--;
3381 BAT_INFO("low power sleeping, reserved... %d\n", di->dsoc);
3382 }
3383
3384 if (di->dsoc <= 0) {
3385 di->dsoc = 0;
3386 rk_send_wakeup_key();
3387 BAT_INFO("sleep dsoc is %d...\n", di->dsoc);
3388 }
3389
3390 DBG("<%s>. out: dsoc=%d, rsoc=%d, sum_cap=%d\n",
3391 __func__, di->dsoc, di->rsoc, di->sleep_sum_cap);
3392
3393 return sleep_soc;
3394 }
3395
rk816_bat_power_supply_changed(struct rk816_battery * di)3396 static void rk816_bat_power_supply_changed(struct rk816_battery *di)
3397 {
3398 u8 status, thermal;
3399 static int old_soc = -1;
3400
3401 /* check dsoc */
3402 if (di->dsoc > 100)
3403 di->dsoc = 100;
3404 else if (di->dsoc < 0)
3405 di->dsoc = 0;
3406
3407 /* update prop and leds */
3408 if (rk816_bat_chrg_online(di)) {
3409 if (di->dsoc == 100)
3410 di->prop_status = POWER_SUPPLY_STATUS_FULL;
3411 else
3412 di->prop_status = POWER_SUPPLY_STATUS_CHARGING;
3413 rk816_bat_update_leds(di, di->prop_status);
3414 }
3415
3416 if (di->dsoc == old_soc)
3417 return;
3418
3419 /* report changed dsoc */
3420 thermal = rk816_bat_read(di, RK816_THERMAL_REG);
3421 status = rk816_bat_read(di, RK816_SUP_STS_REG);
3422 status = (status & CHRG_STATUS_MSK) >> 4;
3423 old_soc = di->dsoc;
3424 di->last_dsoc = di->dsoc;
3425 power_supply_changed(di->bat);
3426 BAT_INFO("changed: dsoc=%d, rsoc=%d, v=%d, ov=%d c=%d, cap=%d, f=%d, st=%s, hotdie=%d\n",
3427 di->dsoc, di->rsoc, di->voltage_avg, di->voltage_ocv,
3428 di->current_avg, di->remain_cap, di->fcc, bat_status[status],
3429 !!(thermal & HOTDIE_STS));
3430
3431 BAT_INFO("dl=%d, rl=%d, v=%d, halt=%d, halt_n=%d, max=%d, init=%d, sw=%d, calib=%d, below0=%d, force=%d\n",
3432 di->dbg_pwr_dsoc, di->dbg_pwr_rsoc, di->dbg_pwr_vol,
3433 di->is_halt, di->halt_cnt, di->is_max_soc_offset,
3434 di->is_initialized, di->is_sw_reset, di->is_ocv_calib,
3435 di->dbg_cap_low0, di->is_force_calib);
3436 }
3437
rk816_bat_check_reboot(struct rk816_battery * di)3438 static u8 rk816_bat_check_reboot(struct rk816_battery *di)
3439 {
3440 u8 cnt;
3441
3442 cnt = rk816_bat_read(di, RK816_REBOOT_CNT_REG);
3443 cnt++;
3444
3445 if (cnt >= REBOOT_MAX_CNT) {
3446 BAT_INFO("reboot: %d --> %d\n", di->dsoc, di->rsoc);
3447 di->dsoc = di->rsoc;
3448 if (di->dsoc > 100)
3449 di->dsoc = 100;
3450 else if (di->dsoc < 0)
3451 di->dsoc = 0;
3452 rk816_bat_save_dsoc(di, di->dsoc);
3453 cnt = REBOOT_MAX_CNT;
3454 }
3455
3456 rk816_bat_save_reboot_cnt(di, cnt);
3457 DBG("reboot cnt: %d\n", cnt);
3458
3459 return cnt;
3460 }
3461
rk816_bat_check_charger(struct rk816_battery * di)3462 static void rk816_bat_check_charger(struct rk816_battery *di)
3463 {
3464 u8 buf;
3465
3466 buf = rk816_bat_read(di, RK816_VB_MON_REG);
3467 /* pmic detect plug in, but ac/usb/dc_in offline, do check */
3468 if ((buf & PLUG_IN_STS) != 0 && !rk816_bat_chrg_online(di)) {
3469 rk816_bat_set_chrg_param(di, USB_TYPE_USB_CHARGER);
3470 BAT_INFO("pmic detect charger.. USB\n");
3471 /* pmic not detect plug in, but one of ac/usb/dc_in online, reset */
3472 } else if ((buf & PLUG_IN_STS) == 0 && rk816_bat_chrg_online(di)) {
3473 rk816_bat_set_chrg_param(di, USB_TYPE_UNKNOWN_CHARGER);
3474 BAT_INFO("pmic not detect charger..\n");
3475 }
3476 }
3477
rk816_bat_rsoc_daemon(struct rk816_battery * di)3478 static void rk816_bat_rsoc_daemon(struct rk816_battery *di)
3479 {
3480 int est_vol, remain_cap;
3481 static unsigned long sec;
3482
3483 if ((di->remain_cap < 0) && (di->fb_blank != 0)) {
3484 if (!sec)
3485 sec = get_boot_sec();
3486 wake_lock_timeout(&di->wake_lock,
3487 (di->pdata->monitor_sec + 1) * HZ);
3488 DBG("sec=%ld, hold_sec=%ld\n", sec, base2sec(sec));
3489 if (base2sec(sec) >= 60) {
3490 sec = 0;
3491 di->dbg_cap_low0++;
3492 est_vol = di->voltage_avg -
3493 (di->bat_res * di->current_avg) / 1000;
3494 remain_cap = rk816_bat_vol_to_ocvcap(di, est_vol);
3495 rk816_bat_init_capacity(di, remain_cap);
3496 BAT_INFO("adjust cap below 0 --> %d, rsoc=%d\n",
3497 di->remain_cap, di->rsoc);
3498 wake_unlock(&di->wake_lock);
3499 }
3500 } else {
3501 sec = 0;
3502 }
3503 }
3504
rk816_bat_update_info(struct rk816_battery * di)3505 static void rk816_bat_update_info(struct rk816_battery *di)
3506 {
3507 bool is_charging;
3508
3509 di->voltage_avg = rk816_bat_get_avg_voltage(di);
3510 di->current_avg = rk816_bat_get_avg_current(di);
3511 di->chrg_status = rk816_bat_get_chrg_status(di);
3512 di->voltage_relax = rk816_bat_get_relax_voltage(di);
3513 di->rsoc = rk816_bat_get_rsoc(di);
3514 di->remain_cap = rk816_bat_get_coulomb_cap(di);
3515 is_charging = rk816_bat_chrg_online(di);
3516 if (is_charging != di->is_charging) {
3517 di->is_charging = is_charging;
3518 if (is_charging)
3519 di->charge_count++;
3520 }
3521 if (di->voltage_avg > di->voltage_max)
3522 di->voltage_max = di->voltage_avg;
3523 if (di->current_avg > di->current_max)
3524 di->current_max = di->current_avg;
3525
3526 /* smooth charge */
3527 if (di->remain_cap > di->fcc) {
3528 di->sm_remain_cap -= (di->remain_cap - di->fcc);
3529 DBG("<%s>. cap: remain=%d, sm_remain=%d\n",
3530 __func__, di->remain_cap, di->sm_remain_cap);
3531 rk816_bat_init_coulomb_cap(di, di->fcc);
3532 }
3533
3534 if (di->chrg_status != CHARGE_FINISH)
3535 di->chrg_finish_base = get_boot_sec();
3536
3537 /*
3538 * we need update fcc in continuous charging state, if discharge state
3539 * keep at least 2 hour, we decide not to update fcc, so clear the
3540 * fcc update flag: age_allow_update.
3541 */
3542 if (base2min(di->plug_out_base) > 120)
3543 di->age_allow_update = false;
3544 /* do adc calib: status must from cccv mode to finish mode */
3545 if (di->chrg_status == CC_OR_CV) {
3546 di->adc_allow_update = true;
3547 di->adc_calib_cnt = 0;
3548 }
3549 }
3550
rk816_bat_init_dsoc_algorithm(struct rk816_battery * di)3551 static void rk816_bat_init_dsoc_algorithm(struct rk816_battery *di)
3552 {
3553 u8 buf;
3554 int16_t rest = 0;
3555 unsigned long soc_sec;
3556 const char *mode_name[] = { "MODE_ZERO", "MODE_FINISH",
3557 "MODE_SMOOTH_CHRG", "MODE_SMOOTH_DISCHRG", "MODE_SMOOTH", };
3558
3559 /* get rest */
3560 rest |= rk816_bat_read(di, RK816_CALC_REST_REGH) << 8;
3561 rest |= rk816_bat_read(di, RK816_CALC_REST_REGL) << 0;
3562
3563 /* get mode */
3564 buf = rk816_bat_read(di, RK816_MISC_MARK_REG);
3565 di->algo_rest_mode = (buf & ALGO_REST_MODE_MSK) >> ALGO_REST_MODE_SHIFT;
3566
3567 if (rk816_bat_get_chrg_status(di) == CHARGE_FINISH) {
3568 if (di->algo_rest_mode == MODE_FINISH) {
3569 soc_sec = di->fcc * 3600 / 100 / FINISH_CHRG_CUR1;
3570 if ((rest / DIV(soc_sec)) > 0) {
3571 if (di->dsoc < 100) {
3572 di->dsoc++;
3573 di->algo_rest_val = rest % soc_sec;
3574 BAT_INFO("algorithm rest(%d) dsoc inc: %d\n",
3575 rest, di->dsoc);
3576 } else {
3577 di->algo_rest_val = 0;
3578 }
3579 } else {
3580 di->algo_rest_val = rest;
3581 }
3582 } else {
3583 di->algo_rest_val = rest;
3584 }
3585 } else {
3586 buf = rk816_bat_read(di, RK816_VB_MON_REG);
3587 /* charge speed up */
3588 if ((rest / 1000) > 0 && (buf & PLUG_IN_STS)) {
3589 if (di->dsoc < di->rsoc) {
3590 di->dsoc++;
3591 di->algo_rest_val = rest % 1000;
3592 BAT_INFO("algorithm rest(%d) dsoc inc: %d\n",
3593 rest, di->dsoc);
3594 } else {
3595 di->algo_rest_val = 0;
3596 }
3597 /* discharge speed up */
3598 } else if (((rest / 1000) < 0) && !(buf & PLUG_IN_STS)) {
3599 if (di->dsoc > di->rsoc) {
3600 di->dsoc--;
3601 di->algo_rest_val = rest % 1000;
3602 BAT_INFO("algorithm rest(%d) dsoc sub: %d\n",
3603 rest, di->dsoc);
3604 } else {
3605 di->algo_rest_val = 0;
3606 }
3607 } else {
3608 di->algo_rest_val = rest;
3609 }
3610 }
3611
3612 if (di->dsoc >= 100)
3613 di->dsoc = 100;
3614 else if (di->dsoc <= 0)
3615 di->dsoc = 0;
3616
3617 /* init current mode */
3618 di->voltage_avg = rk816_bat_get_avg_voltage(di);
3619 di->current_avg = rk816_bat_get_avg_current(di);
3620 if (rk816_bat_get_chrg_status(di) == CHARGE_FINISH) {
3621 rk816_bat_finish_algo_prepare(di);
3622 di->work_mode = MODE_FINISH;
3623 } else {
3624 rk816_bat_smooth_algo_prepare(di);
3625 di->work_mode = MODE_SMOOTH;
3626 }
3627
3628 DBG("<%s>. init: org_rest=%d, rest=%d, mode=%s; "
3629 "doc(x1000): zero=%d, chrg=%d, dischrg=%d, finish=%lu\n",
3630 __func__, rest, di->algo_rest_val, mode_name[di->algo_rest_mode],
3631 di->zero_dsoc, di->sm_chrg_dsoc, di->sm_dischrg_dsoc,
3632 di->chrg_finish_base);
3633 }
3634
rk816_bat_save_algo_rest(struct rk816_battery * di)3635 static void rk816_bat_save_algo_rest(struct rk816_battery *di)
3636 {
3637 u8 buf, mode;
3638 int16_t algo_rest = 0;
3639 int tmp_soc;
3640 int zero_rest = 0, sm_chrg_rest = 0;
3641 int sm_dischrg_rest = 0, finish_rest = 0;
3642 static const char *mode_name[] = { "MODE_ZERO", "MODE_FINISH",
3643 "MODE_SMOOTH_CHRG", "MODE_SMOOTH_DISCHRG", "MODE_SMOOTH", };
3644
3645 /* zero dischrg */
3646 tmp_soc = (di->zero_dsoc) / 1000;
3647 if (tmp_soc == di->dsoc)
3648 zero_rest = di->zero_dsoc - ((di->dsoc + 1) * 1000 -
3649 MIN_ACCURACY);
3650
3651 /* sm chrg */
3652 tmp_soc = di->sm_chrg_dsoc / 1000;
3653 if (tmp_soc == di->dsoc)
3654 sm_chrg_rest = di->sm_chrg_dsoc - di->dsoc * 1000;
3655
3656 /* sm dischrg */
3657 tmp_soc = (di->sm_dischrg_dsoc) / 1000;
3658 if (tmp_soc == di->dsoc)
3659 sm_dischrg_rest = di->sm_dischrg_dsoc - ((di->dsoc + 1) * 1000 -
3660 MIN_ACCURACY);
3661
3662 /* last time is also finish chrg, then add last rest */
3663 if (di->algo_rest_mode == MODE_FINISH && di->algo_rest_val)
3664 finish_rest = base2sec(di->chrg_finish_base) +
3665 di->algo_rest_val;
3666 else
3667 finish_rest = base2sec(di->chrg_finish_base);
3668
3669 /* total calc */
3670 if ((rk816_bat_chrg_online(di) && (di->dsoc > di->rsoc)) ||
3671 (!rk816_bat_chrg_online(di) && (di->dsoc < di->rsoc)) ||
3672 (di->dsoc == di->rsoc)) {
3673 di->algo_rest_val = 0;
3674 algo_rest = 0;
3675 DBG("<%s>. step1..\n", __func__);
3676 } else if (di->work_mode == MODE_FINISH) {
3677 algo_rest = finish_rest;
3678 DBG("<%s>. step2..\n", __func__);
3679 } else if (di->algo_rest_mode == MODE_FINISH) {
3680 algo_rest = zero_rest + sm_dischrg_rest + sm_chrg_rest;
3681 DBG("<%s>. step3..\n", __func__);
3682 } else {
3683 if (rk816_bat_chrg_online(di) && (di->dsoc < di->rsoc))
3684 algo_rest = sm_chrg_rest + di->algo_rest_val;
3685 else if (!rk816_bat_chrg_online(di) && (di->dsoc > di->rsoc))
3686 algo_rest = zero_rest + sm_dischrg_rest +
3687 di->algo_rest_val;
3688 else
3689 algo_rest = zero_rest + sm_dischrg_rest + sm_chrg_rest +
3690 di->algo_rest_val;
3691 DBG("<%s>. step4..\n", __func__);
3692 }
3693
3694 /* check mode */
3695 if ((di->work_mode == MODE_FINISH) || (di->work_mode == MODE_ZERO)) {
3696 mode = di->work_mode;
3697 } else {/* MODE_SMOOTH */
3698 if (di->sm_linek > 0)
3699 mode = MODE_SMOOTH_CHRG;
3700 else
3701 mode = MODE_SMOOTH_DISCHRG;
3702 }
3703
3704 /* save mode */
3705 buf = rk816_bat_read(di, RK816_MISC_MARK_REG);
3706 buf &= ~ALGO_REST_MODE_MSK;
3707 buf |= (mode << ALGO_REST_MODE_SHIFT);
3708 rk816_bat_write(di, RK816_MISC_MARK_REG, buf);
3709
3710 /* save rest */
3711 buf = (algo_rest >> 8) & 0xff;
3712 rk816_bat_write(di, RK816_CALC_REST_REGH, buf);
3713 buf = (algo_rest >> 0) & 0xff;
3714 rk816_bat_write(di, RK816_CALC_REST_REGL, buf);
3715
3716 DBG("<%s>. rest: algo=%d, mode=%s, last_rest=%d; zero=%d, chrg=%d, dischrg=%d, finish=%lu\n",
3717 __func__, algo_rest, mode_name[mode], di->algo_rest_val, zero_rest,
3718 sm_chrg_rest, sm_dischrg_rest, base2sec(di->chrg_finish_base));
3719 }
3720
rk816_bat_save_data(struct rk816_battery * di)3721 static void rk816_bat_save_data(struct rk816_battery *di)
3722 {
3723 rk816_bat_save_dsoc(di, di->dsoc);
3724 rk816_bat_save_cap(di, di->remain_cap);
3725 rk816_bat_save_algo_rest(di);
3726 }
3727
3728 /*get ntc resistance*/
rk816_bat_get_ntc_res(struct rk816_battery * di)3729 static int rk816_bat_get_ntc_res(struct rk816_battery *di)
3730 {
3731 int res, val = 0;
3732
3733 val |= rk816_bat_read(di, RK816_TS_ADC_REGL) << 0;
3734 val |= rk816_bat_read(di, RK816_TS_ADC_REGH) << 8;
3735
3736 res = ((di->voltage_k * val) / 1000 + di->voltage_b) * 1000 / 2200;
3737 res = res * 1000 / di->pdata->ntc_factor;
3738
3739 DBG("<%s>. val=%d, ntc_res=%d, factor=%d\n",
3740 __func__, val, res, di->pdata->ntc_factor);
3741
3742 DBG("<%s>. t=[%d'C(%d) ~ %dC(%d)]\n", __func__,
3743 di->pdata->ntc_degree_from, di->pdata->ntc_table[0],
3744 di->pdata->ntc_degree_from + di->pdata->ntc_size - 1,
3745 di->pdata->ntc_table[di->pdata->ntc_size - 1]);
3746
3747 return res;
3748 }
3749
rk816_bat_temperature_chrg(struct rk816_battery * di,int temp)3750 static int rk816_bat_temperature_chrg(struct rk816_battery *di, int temp)
3751 {
3752 static int temp_triggered, config_index = -1;
3753 int i, up_temp, down_temp, cfg_current;
3754 u8 usb_ctrl, chrg_ctrl1;
3755 int now_temp = temp;
3756 int cur;
3757
3758 for (i = 0; i < di->pdata->tc_count; i++) {
3759 up_temp = di->pdata->tc_table[i].temp_up;
3760 down_temp = di->pdata->tc_table[i].temp_down;
3761 cfg_current = di->pdata->tc_table[i].chrg_current;
3762
3763 if (now_temp >= down_temp && now_temp <= up_temp) {
3764 /* Temp range or charger are not update, return */
3765 if (config_index == i && !di->charger_changed)
3766 return 0;
3767
3768 config_index = i;
3769 di->charger_changed = 0;
3770 temp_triggered = 1;
3771
3772 if (di->pdata->tc_table[i].set_chrg_current) {
3773 rk816_bat_set_chrg_current(di, cfg_current);
3774 if (!di->over_20mR)
3775 cur =
3776 RES_FAC_MUX(CHRG_CUR_SEL[cfg_current],
3777 di->res_fac);
3778 else
3779 cur =
3780 RES_FAC_DIV(CHRG_CUR_SEL[cfg_current],
3781 di->res_fac);
3782 BAT_INFO("temperature = %d'C[%d~%d'C], chrg current = %d\n",
3783 now_temp, down_temp, up_temp, cur);
3784 } else {
3785 rk816_bat_set_input_current(di, cfg_current);
3786 BAT_INFO("temperature = %d'C[%d~%d'C], input current = %d\n",
3787 now_temp, down_temp, up_temp,
3788 CHRG_CUR_INPUT[cfg_current]);
3789 }
3790 return 0; /* return after configure */
3791 }
3792 }
3793
3794 /*
3795 * means: current temperature not covers above case, temperature rolls
3796 * back to normal range, so restore default value
3797 */
3798 if (temp_triggered) {
3799 temp_triggered = 0;
3800 config_index = -1;
3801 rk816_bat_set_chrg_current(di, di->chrg_cur_sel);
3802 if (di->ac_in || di->dc_in)
3803 rk816_bat_set_input_current(di, di->chrg_cur_input);
3804 else
3805 rk816_bat_set_input_current(di, INPUT_CUR450MA);
3806 usb_ctrl = rk816_bat_read(di, RK816_USB_CTRL_REG);
3807 chrg_ctrl1 = rk816_bat_read(di, RK816_CHRG_CTRL_REG1);
3808 cfg_current = chrg_ctrl1 & 0x0f;
3809 if (!di->over_20mR)
3810 cur =
3811 RES_FAC_MUX(CHRG_CUR_SEL[cfg_current], di->res_fac);
3812 else
3813 cur =
3814 RES_FAC_DIV(CHRG_CUR_SEL[cfg_current], di->res_fac);
3815 BAT_INFO("roll back temp %d'C, current chrg = %d, input = %d\n",
3816 now_temp, cur, CHRG_CUR_INPUT[(usb_ctrl & 0x0f)]);
3817 }
3818
3819 return 0;
3820 }
3821
rk816_bat_update_temperature(struct rk816_battery * di)3822 static void rk816_bat_update_temperature(struct rk816_battery *di)
3823 {
3824 u32 ntc_size, *ntc_table;
3825 int i, res;
3826
3827 ntc_table = di->pdata->ntc_table;
3828 ntc_size = di->pdata->ntc_size;
3829 di->temperature = VIRTUAL_TEMPERATURE;
3830
3831 if (ntc_size) {
3832 res = rk816_bat_get_ntc_res(di);
3833 if (res < ntc_table[ntc_size - 1]) {
3834 BAT_INFO("bat ntc upper max degree: R=%d\n", res);
3835 rk816_bat_set_input_current(di, INPUT_CUR80MA);
3836 } else if (res > ntc_table[0]) {
3837 BAT_INFO("bat ntc lower min degree: R=%d\n", res);
3838 rk816_bat_set_input_current(di, INPUT_CUR80MA);
3839 } else {
3840 for (i = 0; i < ntc_size; i++) {
3841 if (res >= ntc_table[i])
3842 break;
3843 }
3844
3845 di->temperature = (i + di->pdata->ntc_degree_from) * 10;
3846 rk816_bat_temperature_chrg(di, di->temperature / 10);
3847 }
3848 }
3849 }
3850
rk816_bat_update_ocv_table(struct rk816_battery * di)3851 static void rk816_bat_update_ocv_table(struct rk816_battery *di)
3852 {
3853 static bool initialized;
3854 static int temp_idx, temperature_sum, last_avg_temp, curr_avg_temp;
3855 static int temp_record_table[TEMP_RECORD_NUM];
3856 int i, curr_temp = di->temperature / 10;
3857
3858 if (di->pdata->temp_t_num < 2)
3859 return;
3860
3861 /* only run once for initialize */
3862 if (!initialized) {
3863 for (i = 0; i < TEMP_RECORD_NUM; i++)
3864 temp_record_table[i] = curr_temp;
3865
3866 temperature_sum = curr_temp * TEMP_RECORD_NUM;
3867 last_avg_temp = curr_temp;
3868 initialized = true;
3869 }
3870
3871 /* pick out earliest temperature from sum */
3872 temperature_sum -= temp_record_table[temp_idx];
3873
3874 /* add current temperature into sum */
3875 temp_record_table[temp_idx] = curr_temp;
3876 temperature_sum += curr_temp;
3877
3878 /* new avg temperature currently */
3879 curr_avg_temp = temperature_sum / TEMP_RECORD_NUM;
3880
3881 /* move to next idx */
3882 temp_idx = (temp_idx + 1) % TEMP_RECORD_NUM;
3883
3884 DBG("<%s>: temp_idx=%d, curr_temp=%d, last_avg=%d, curr_avg=%d\n",
3885 __func__, temp_idx, curr_temp, last_avg_temp, curr_avg_temp);
3886
3887 /* tempearture changed, update ocv table */
3888 if (curr_avg_temp != last_avg_temp) {
3889 BAT_INFO("OCV table update, temperature now=%d, last=%d\n",
3890 curr_avg_temp, last_avg_temp);
3891 rk816_bat_setup_ocv_table(di, curr_avg_temp);
3892 last_avg_temp = curr_avg_temp;
3893
3894 if (!dbg_enable)
3895 return;
3896
3897 for (i = 0; i < di->pdata->ocv_size; i++)
3898 DBG("* ocv_table[%d]=%d\n", i, di->pdata->ocv_table[i]);
3899 }
3900 }
3901
rk816_battery_work(struct work_struct * work)3902 static void rk816_battery_work(struct work_struct *work)
3903 {
3904 struct rk816_battery *di =
3905 container_of(work, struct rk816_battery, bat_delay_work.work);
3906
3907 rk816_bat_update_info(di);
3908 rk816_bat_wait_finish_sig(di);
3909 rk816_bat_rsoc_daemon(di);
3910 rk816_bat_check_charger(di);
3911 rk816_bat_update_temperature(di);
3912 rk816_bat_update_ocv_table(di);
3913 rk816_bat_lowpwr_check(di);
3914 rk816_bat_display_smooth(di);
3915 rk816_bat_power_supply_changed(di);
3916 rk816_bat_save_data(di);
3917 rk816_bat_debug_info(di);
3918
3919 queue_delayed_work(di->bat_monitor_wq, &di->bat_delay_work,
3920 msecs_to_jiffies(di->monitor_ms));
3921 }
3922
rk816_bat_discnt_evt_worker(struct work_struct * work)3923 static void rk816_bat_discnt_evt_worker(struct work_struct *work)
3924 {
3925 struct rk816_battery *di = container_of(work,
3926 struct rk816_battery, discnt_work.work);
3927
3928 if (extcon_get_state(di->cable_edev, EXTCON_USB) == 0) {
3929 BAT_INFO("receive extcon notifier event: DISCNT...\n");
3930 rk816_bat_set_chrg_param(di, USB_TYPE_NONE_CHARGER);
3931 }
3932 }
3933
rk816_bat_host_evt_worker(struct work_struct * work)3934 static void rk816_bat_host_evt_worker(struct work_struct *work)
3935 {
3936 struct rk816_battery *di = container_of(work,
3937 struct rk816_battery, host_work.work);
3938 struct extcon_dev *edev = di->cable_edev;
3939
3940 /* Determine charger type */
3941 if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) > 0) {
3942 rk816_bat_set_otg_in(di, ONLINE);
3943 BAT_INFO("receive extcon notifier event: OTG ON...\n");
3944 if (di->dc_in && di->pdata->power_dc2otg)
3945 BAT_INFO("otg power from dc adapter\n");
3946 else
3947 rk816_bat_set_otg_power(di, USB_OTG_POWER_ON);
3948 } else if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) == 0) {
3949 BAT_INFO("receive extcon notifier event: OTG OFF...\n");
3950 rk816_bat_set_otg_in(di, OFFLINE);
3951 rk816_bat_set_otg_power(di, USB_OTG_POWER_OFF);
3952 }
3953 }
3954
rk816_bat_charger_evt_worker(struct work_struct * work)3955 static void rk816_bat_charger_evt_worker(struct work_struct *work)
3956 {
3957 struct rk816_battery *di = container_of(work,
3958 struct rk816_battery, usb_work.work);
3959 struct extcon_dev *edev = di->cable_edev;
3960 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
3961 static const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
3962
3963 /* Determine charger type */
3964 if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0)
3965 charger = USB_TYPE_USB_CHARGER;
3966 else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0)
3967 charger = USB_TYPE_AC_CHARGER;
3968 else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0)
3969 charger = USB_TYPE_CDP_CHARGER;
3970 else
3971 charger = USB_TYPE_NONE_CHARGER;
3972
3973 if (charger != USB_TYPE_UNKNOWN_CHARGER) {
3974 BAT_INFO("receive extcon notifier event: %s...\n",
3975 event[charger]);
3976 rk816_bat_set_chrg_param(di, charger);
3977 }
3978 }
3979
rk816_bat_charger_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)3980 static int rk816_bat_charger_evt_notifier(struct notifier_block *nb,
3981 unsigned long event, void *ptr)
3982 {
3983 struct rk816_battery *di =
3984 container_of(nb, struct rk816_battery, cable_cg_nb);
3985
3986 queue_delayed_work(di->usb_charger_wq, &di->usb_work,
3987 msecs_to_jiffies(10));
3988
3989 return NOTIFY_DONE;
3990 }
3991
rk816_bat_discnt_evt_notfier(struct notifier_block * nb,unsigned long event,void * ptr)3992 static int rk816_bat_discnt_evt_notfier(struct notifier_block *nb,
3993 unsigned long event, void *ptr)
3994 {
3995 struct rk816_battery *di =
3996 container_of(nb, struct rk816_battery, cable_discnt_nb);
3997
3998 queue_delayed_work(di->usb_charger_wq, &di->discnt_work,
3999 msecs_to_jiffies(10));
4000
4001 return NOTIFY_DONE;
4002 }
4003
rk816_bat_host_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)4004 static int rk816_bat_host_evt_notifier(struct notifier_block *nb,
4005 unsigned long event, void *ptr)
4006 {
4007 struct rk816_battery *di =
4008 container_of(nb, struct rk816_battery, cable_host_nb);
4009
4010 queue_delayed_work(di->usb_charger_wq, &di->host_work,
4011 msecs_to_jiffies(10));
4012
4013 return NOTIFY_DONE;
4014 }
4015
rk816_vb_low_irq(int irq,void * bat)4016 static irqreturn_t rk816_vb_low_irq(int irq, void *bat)
4017 {
4018 struct rk816_battery *di = (struct rk816_battery *)bat;
4019
4020 BAT_INFO("lower power yet, power off system! v=%d\n",
4021 di->voltage_avg);
4022 di->dsoc = 0;
4023 rk_send_wakeup_key();
4024 power_supply_changed(di->bat);
4025
4026 return IRQ_HANDLED;
4027 }
4028
rk816_plug_in(int irq,void * bat)4029 static irqreturn_t rk816_plug_in(int irq, void *bat)
4030 {
4031 rk_send_wakeup_key();
4032 BAT_INFO("pmic: plug in\n");
4033
4034 return IRQ_HANDLED;
4035 }
4036
rk816_cvtlmt(int irq,void * bat)4037 static irqreturn_t rk816_cvtlmt(int irq, void *bat)
4038 {
4039 struct rk816_battery *di = (struct rk816_battery *)bat;
4040
4041 di->cvtlmt_int_event = 1;
4042 BAT_INFO("pmic: cvtlmt irq\n");
4043
4044 return IRQ_HANDLED;
4045 }
4046
rk816_plug_out(int irq,void * bat)4047 static irqreturn_t rk816_plug_out(int irq, void *bat)
4048 {
4049 rk_send_wakeup_key();
4050 BAT_INFO("pmic: plug out\n");
4051
4052 return IRQ_HANDLED;
4053 }
4054
rk816_vbat_dc_det(int irq,void * bat)4055 static irqreturn_t rk816_vbat_dc_det(int irq, void *bat)
4056 {
4057 struct rk816_battery *di = (struct rk816_battery *)bat;
4058
4059 if (gpio_get_value(di->pdata->dc_det_pin))
4060 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
4061 else
4062 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
4063
4064 BAT_INFO("dc det in/out\n");
4065 queue_delayed_work(di->usb_charger_wq,
4066 &di->dc_delay_work, msecs_to_jiffies(500));
4067 rk_send_wakeup_key();
4068
4069 return IRQ_HANDLED;
4070 }
4071
rk816_bat_init_sysfs(struct rk816_battery * di)4072 static void rk816_bat_init_sysfs(struct rk816_battery *di)
4073 {
4074 int i, ret;
4075
4076 for (i = 0; i < ARRAY_SIZE(rk816_bat_attr); i++) {
4077 ret = sysfs_create_file(&di->dev->kobj,
4078 &rk816_bat_attr[i].attr);
4079 if (ret)
4080 dev_err(di->dev, "create bat node(%s) error\n",
4081 rk816_bat_attr[i].attr.name);
4082 }
4083 }
4084
rk816_bat_init_irqs(struct rk816_battery * di)4085 static int rk816_bat_init_irqs(struct rk816_battery *di)
4086 {
4087 int ret;
4088 int plug_in_irq, plug_out_irq, vb_lo_irq, cvtlmt_irq;
4089 struct rk808 *rk816 = di->rk816;
4090 struct platform_device *pdev = di->pdev;
4091
4092 vb_lo_irq = regmap_irq_get_virq(rk816->irq_data, RK816_IRQ_VB_LOW);
4093 if (vb_lo_irq < 0) {
4094 dev_err(&pdev->dev, "find vb_lo_irq error\n");
4095 return vb_lo_irq;
4096 }
4097
4098 plug_in_irq = regmap_irq_get_virq(rk816->battery_irq_data,
4099 RK816_IRQ_PLUG_IN);
4100 if (plug_in_irq < 0) {
4101 dev_err(&pdev->dev, "find plug_in_irq error\n");
4102 return plug_in_irq;
4103 }
4104
4105 plug_out_irq = regmap_irq_get_virq(rk816->battery_irq_data,
4106 RK816_IRQ_PLUG_OUT);
4107 if (plug_out_irq < 0) {
4108 dev_err(&pdev->dev, "find plug_out_irq error\n");
4109 return plug_out_irq;
4110 }
4111
4112 cvtlmt_irq = regmap_irq_get_virq(rk816->battery_irq_data,
4113 RK816_IRQ_CHG_CVTLIM);
4114 if (cvtlmt_irq < 0) {
4115 dev_err(&pdev->dev, "find cvtlmt_irq error\n");
4116 return cvtlmt_irq;
4117 }
4118
4119 /* low power */
4120 ret = devm_request_threaded_irq(di->dev, vb_lo_irq, NULL,
4121 rk816_vb_low_irq,
4122 IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
4123 "rk816_vb_low", di);
4124 if (ret) {
4125 dev_err(di->dev, "vb low irq request failed!\n");
4126 return ret;
4127 }
4128
4129 enable_irq_wake(vb_lo_irq);
4130
4131 /* plug in */
4132 ret = devm_request_threaded_irq(di->dev, plug_in_irq, NULL,
4133 rk816_plug_in,
4134 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
4135 "rk816_plug_in", di);
4136 if (ret) {
4137 dev_err(di->dev, "plug in irq request failed!\n");
4138 return ret;
4139 }
4140
4141 /* plug out */
4142 ret = devm_request_threaded_irq(di->dev, plug_out_irq, NULL,
4143 rk816_plug_out,
4144 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
4145 "rk816_plug_out", di);
4146 if (ret) {
4147 dev_err(di->dev, "plug out irq request failed!\n");
4148 return ret;
4149 }
4150
4151 /* cvtlmt */
4152 ret = devm_request_threaded_irq(di->dev, cvtlmt_irq, NULL,
4153 rk816_cvtlmt,
4154 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
4155 "rk816_cvtlmt", di);
4156 if (ret) {
4157 dev_err(di->dev, "cvtlmt irq request failed!\n");
4158 return ret;
4159 }
4160 disable_irq(cvtlmt_irq);
4161
4162 di->cvtlmt_irq = cvtlmt_irq;
4163
4164 return 0;
4165 }
4166
rk816_bat_init_info(struct rk816_battery * di)4167 static void rk816_bat_init_info(struct rk816_battery *di)
4168 {
4169 di->design_cap = di->pdata->design_capacity;
4170 di->qmax = di->pdata->design_qmax;
4171 di->bat_res = di->pdata->bat_res;
4172 di->sleep_chrg_status = rk816_bat_get_chrg_status(di);
4173 di->monitor_ms = di->pdata->monitor_sec * TIMER_MS_COUNTS;
4174 di->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
4175 di->boot_base = POWER_ON_SEC_BASE;
4176 di->chrg_finish_base = 0;
4177 di->plug_in_base = 0;
4178 di->plug_out_base = 0;
4179 }
4180
rk816_bat_init_adc_dc_det(struct rk816_battery * di)4181 static enum charger_t rk816_bat_init_adc_dc_det(struct rk816_battery *di)
4182 {
4183 return rk816_bat_get_adc_dc_state(di);
4184 }
4185
rk816_bat_init_gpio_dc_det(struct rk816_battery * di)4186 static enum charger_t rk816_bat_init_gpio_dc_det(struct rk816_battery *di)
4187 {
4188 int ret, level;
4189 unsigned long irq_flags;
4190 unsigned int dc_det_irq;
4191 enum charger_t type = DC_TYPE_NONE_CHARGER;
4192
4193 if (gpio_is_valid(di->pdata->dc_det_pin)) {
4194 ret = devm_gpio_request(di->dev, di->pdata->dc_det_pin,
4195 "rk816_dc_det");
4196 if (ret < 0) {
4197 dev_err(di->dev, "Failed to request gpio %d\n",
4198 di->pdata->dc_det_pin);
4199 goto out;
4200 }
4201
4202 ret = gpio_direction_input(di->pdata->dc_det_pin);
4203 if (ret) {
4204 dev_err(di->dev, "failed to set gpio input\n");
4205 goto out;
4206 }
4207
4208 level = gpio_get_value(di->pdata->dc_det_pin);
4209 if (level == di->pdata->dc_det_level)
4210 type = DC_TYPE_DC_CHARGER;
4211 else
4212 type = DC_TYPE_NONE_CHARGER;
4213
4214 if (level)
4215 irq_flags = IRQF_TRIGGER_LOW;
4216 else
4217 irq_flags = IRQF_TRIGGER_HIGH;
4218
4219 dc_det_irq = gpio_to_irq(di->pdata->dc_det_pin);
4220 ret = devm_request_irq(di->dev, dc_det_irq, rk816_vbat_dc_det,
4221 irq_flags, "rk816_dc_det", di);
4222 if (ret != 0) {
4223 dev_err(di->dev, "rk816_dc_det_irq request failed!\n");
4224 goto out;
4225 }
4226
4227 enable_irq_wake(dc_det_irq);
4228 }
4229 out:
4230 return type;
4231 }
4232
rk816_bat_init_dc_det(struct rk816_battery * di)4233 static enum charger_t rk816_bat_init_dc_det(struct rk816_battery *di)
4234 {
4235 enum charger_t type;
4236
4237 if (di->pdata->dc_det_adc)
4238 type = rk816_bat_init_adc_dc_det(di);
4239 else
4240 type = rk816_bat_init_gpio_dc_det(di);
4241
4242 return type;
4243 }
4244
rk816_bat_init_charger(struct rk816_battery * di)4245 static int rk816_bat_init_charger(struct rk816_battery *di)
4246 {
4247 enum charger_t dc_charger;
4248 struct device *dev = di->dev;
4249 struct extcon_dev *edev;
4250 int ret;
4251
4252 di->usb_charger_wq = alloc_ordered_workqueue("%s",
4253 WQ_MEM_RECLAIM | WQ_FREEZABLE,
4254 "rk816-bat-charger-wq");
4255 INIT_DELAYED_WORK(&di->dc_delay_work, rk816_bat_dc_delay_work);
4256
4257 /* Find extcon phandle */
4258 edev = extcon_get_edev_by_phandle(dev->parent, 0);
4259 if (IS_ERR(edev)) {
4260 if (PTR_ERR(edev) != -EPROBE_DEFER)
4261 dev_err(dev, "Invalid or missing extcon\n");
4262 return PTR_ERR(edev);
4263 }
4264
4265 /* Register chargers */
4266 INIT_DELAYED_WORK(&di->usb_work, rk816_bat_charger_evt_worker);
4267 di->cable_cg_nb.notifier_call = rk816_bat_charger_evt_notifier;
4268 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
4269 &di->cable_cg_nb);
4270 if (ret < 0) {
4271 dev_err(dev, "failed to register notifier for SDP\n");
4272 return ret;
4273 }
4274
4275 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
4276 &di->cable_cg_nb);
4277 if (ret < 0) {
4278 dev_err(dev, "failed to register notifier for DCP\n");
4279 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
4280 &di->cable_cg_nb);
4281 return ret;
4282 }
4283
4284 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
4285 &di->cable_cg_nb);
4286 if (ret < 0) {
4287 dev_err(dev, "failed to register notifier for CDP\n");
4288 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
4289 &di->cable_cg_nb);
4290 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
4291 &di->cable_cg_nb);
4292 return ret;
4293 }
4294
4295 /* Register host */
4296 INIT_DELAYED_WORK(&di->host_work, rk816_bat_host_evt_worker);
4297 di->cable_host_nb.notifier_call = rk816_bat_host_evt_notifier;
4298 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
4299 &di->cable_host_nb);
4300 if (ret < 0) {
4301 dev_err(dev, "failed to register notifier for HOST\n");
4302 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
4303 &di->cable_cg_nb);
4304 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
4305 &di->cable_cg_nb);
4306 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
4307 &di->cable_cg_nb);
4308
4309 return ret;
4310 }
4311
4312 /* Register discnt usb */
4313 INIT_DELAYED_WORK(&di->discnt_work, rk816_bat_discnt_evt_worker);
4314 di->cable_discnt_nb.notifier_call = rk816_bat_discnt_evt_notfier;
4315 ret = extcon_register_notifier(edev, EXTCON_USB,
4316 &di->cable_discnt_nb);
4317 if (ret < 0) {
4318 dev_err(dev, "failed to register notifier for HOST\n");
4319 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
4320 &di->cable_cg_nb);
4321 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
4322 &di->cable_cg_nb);
4323 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
4324 &di->cable_cg_nb);
4325 extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
4326 &di->cable_host_nb);
4327 return ret;
4328 }
4329
4330 di->cable_edev = edev;
4331
4332 /* Check usb and otg state */
4333 schedule_delayed_work(&di->host_work, 0);
4334 schedule_delayed_work(&di->usb_work, 0);
4335
4336 BAT_INFO("register extcon evt notifier\n");
4337
4338 /* adc dc need poll every 1s */
4339 if (di->pdata->dc_det_adc)
4340 queue_delayed_work(di->usb_charger_wq, &di->dc_delay_work,
4341 msecs_to_jiffies(1000));
4342
4343 dc_charger = rk816_bat_init_dc_det(di);
4344 rk816_bat_set_chrg_param(di, dc_charger);
4345 if (di->dc_in && di->otg_in && di->pdata->power_dc2otg) {
4346 BAT_INFO("otg power from dc adapter\n");
4347 rk816_bat_set_otg_power(di, USB_OTG_POWER_OFF);
4348 }
4349
4350 return 0;
4351 }
4352
rk816_get_rtc_sec(void)4353 static time64_t rk816_get_rtc_sec(void)
4354 {
4355 int err;
4356 struct rtc_time tm;
4357 struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
4358
4359 err = rtc_read_time(rtc, &tm);
4360 if (err) {
4361 dev_err(rtc->dev.parent, "read hardware clk failed\n");
4362 return 0;
4363 }
4364
4365 err = rtc_valid_tm(&tm);
4366 if (err) {
4367 dev_err(rtc->dev.parent, "invalid date time\n");
4368 return 0;
4369 }
4370
4371 return rtc_tm_to_time64(&tm);
4372 }
4373
rk816_bat_rtc_sleep_sec(struct rk816_battery * di)4374 static int rk816_bat_rtc_sleep_sec(struct rk816_battery *di)
4375 {
4376 int interval_sec;
4377
4378 interval_sec = rk816_get_rtc_sec() - di->rtc_base;
4379
4380 return (interval_sec > 0) ? interval_sec : 0;
4381 }
4382
rk816_bat_init_ts_detect(struct rk816_battery * di)4383 static void rk816_bat_init_ts_detect(struct rk816_battery *di)
4384 {
4385 u8 buf;
4386
4387 if (!di->pdata->ntc_size)
4388 return;
4389
4390 /* Pin func: ts */
4391 buf = rk816_bat_read(di, RK816_GPIO_IO_POL_REG);
4392 buf &= ~BIT(2);
4393 rk816_bat_write(di, RK816_GPIO_IO_POL_REG, buf);
4394
4395 /* External temperature monitoring */
4396 buf = rk816_bat_read(di, RK816_TS_CTRL_REG);
4397 buf &= ~BIT(4);
4398 rk816_bat_write(di, RK816_TS_CTRL_REG, buf);
4399
4400 /* select ua */
4401 buf = rk816_bat_read(di, RK816_TS_CTRL_REG);
4402 buf &= ~ADC_CUR_MSK;
4403 if (di->pdata->ntc_factor == NTC_CALC_FACTOR_80UA)
4404 buf |= ADC_CUR_80UA;
4405 else if (di->pdata->ntc_factor == NTC_CALC_FACTOR_60UA)
4406 buf |= ADC_CUR_60UA;
4407 else if (di->pdata->ntc_factor == NTC_CALC_FACTOR_40UA)
4408 buf |= ADC_CUR_40UA;
4409 else
4410 buf |= ADC_CUR_20UA;
4411 rk816_bat_write(di, RK816_TS_CTRL_REG, buf);
4412
4413 /* ADC_TS_EN */
4414 buf = rk816_bat_read(di, RK816_ADC_CTRL_REG);
4415 buf |= BIT(5);
4416 rk816_bat_write(di, RK816_ADC_CTRL_REG, buf);
4417 }
4418
rk816_bat_init_fg(struct rk816_battery * di)4419 static void rk816_bat_init_fg(struct rk816_battery *di)
4420 {
4421 rk816_bat_enable_input_current(di);
4422 rk816_bat_enable_gauge(di);
4423 rk816_bat_init_voltage_kb(di);
4424 rk816_bat_init_poffset(di);
4425 rk816_bat_select_sample_res(di);
4426 rk816_bat_set_relax_sample(di);
4427 rk816_bat_set_ioffset_sample(di);
4428 rk816_bat_set_ocv_sample(di);
4429 rk816_bat_init_ts_detect(di);
4430 rk816_bat_update_temperature(di);
4431 rk816_bat_setup_ocv_table(di, di->temperature / 10);
4432 rk816_bat_init_rsoc(di);
4433 rk816_bat_init_coulomb_cap(di, di->nac);
4434 rk816_bat_init_age_algorithm(di);
4435 rk816_bat_init_chrg_config(di);
4436 rk816_bat_init_zero_table(di);
4437 rk816_bat_init_caltimer(di);
4438 rk816_bat_init_dsoc_algorithm(di);
4439
4440 di->voltage_avg = rk816_bat_get_avg_voltage(di);
4441 di->voltage_ocv = rk816_bat_get_ocv_voltage(di);
4442 di->voltage_relax = rk816_bat_get_relax_voltage(di);
4443 di->current_avg = rk816_bat_get_avg_current(di);
4444 di->current_relax = rk816_bat_get_relax_current(di);
4445 di->remain_cap = rk816_bat_get_coulomb_cap(di);
4446 di->dbg_pwr_dsoc = di->dsoc;
4447 di->dbg_pwr_rsoc = di->rsoc;
4448 di->dbg_pwr_vol = di->voltage_avg;
4449
4450 rk816_bat_dump_regs(di, 0x99, 0xee);
4451 DBG("nac=%d cap=%d ov=%d v=%d rv=%d dl=%d rl=%d c=%d\n",
4452 di->nac, di->remain_cap, di->voltage_ocv, di->voltage_avg,
4453 di->voltage_relax, di->dsoc, di->rsoc, di->current_avg);
4454 }
4455
rk816_bat_read_ocv_tables(struct rk816_battery * di,struct device_node * np)4456 static int rk816_bat_read_ocv_tables(struct rk816_battery *di,
4457 struct device_node *np)
4458 {
4459 struct battery_platform_data *pdata = di->pdata;
4460 u32 negative, value;
4461 int length, i, j;
4462 int idx = 0;
4463
4464 /* t0 */
4465 if (of_find_property(np, "table_t0", &length) &&
4466 of_find_property(np, "temp_t0", &length)) {
4467 DBG("%s: read table_t0\n", __func__);
4468
4469 if (of_property_read_u32_array(np, "table_t0",
4470 pdata->table_t[idx],
4471 pdata->ocv_size)) {
4472 dev_err(di->dev, "invalid table_t0\n");
4473 return -EINVAL;
4474 }
4475
4476 if (of_property_read_u32_index(np, "temp_t0", 1, &value) ||
4477 of_property_read_u32_index(np, "temp_t0", 0, &negative)) {
4478 dev_err(di->dev, "invalid temp_t0\n");
4479 return -EINVAL;
4480 }
4481 if (negative)
4482 pdata->temp_t[idx] = -value;
4483 else
4484 pdata->temp_t[idx] = value;
4485 idx++;
4486 }
4487
4488 /* t1 */
4489 if (of_find_property(np, "table_t1", &length) &&
4490 of_find_property(np, "temp_t1", &length)) {
4491 DBG("%s: read table_t1\n", __func__);
4492
4493 if (of_property_read_u32_array(np, "table_t1",
4494 pdata->table_t[idx],
4495 pdata->ocv_size)) {
4496 dev_err(di->dev, "invalid table_t1\n");
4497 return -EINVAL;
4498 }
4499
4500 if (of_property_read_u32_index(np, "temp_t1", 1, &value) ||
4501 of_property_read_u32_index(np, "temp_t1", 0, &negative)) {
4502 dev_err(di->dev, "invalid temp_t1\n");
4503 return -EINVAL;
4504 }
4505 if (negative)
4506 pdata->temp_t[idx] = -value;
4507 else
4508 pdata->temp_t[idx] = value;
4509 idx++;
4510 }
4511
4512 /* t2 */
4513 if (of_find_property(np, "table_t2", &length) &&
4514 of_find_property(np, "temp_t2", &length)) {
4515 DBG("%s: read table_t2\n", __func__);
4516
4517 if (of_property_read_u32_array(np, "table_t2",
4518 pdata->table_t[idx],
4519 pdata->ocv_size)) {
4520 dev_err(di->dev, "invalid table_t2\n");
4521 return -EINVAL;
4522 }
4523
4524 if (of_property_read_u32_index(np, "temp_t2", 1, &value) ||
4525 of_property_read_u32_index(np, "temp_t2", 0, &negative)) {
4526 dev_err(di->dev, "invalid temp_t2\n");
4527 return -EINVAL;
4528 }
4529 if (negative)
4530 pdata->temp_t[idx] = -value;
4531 else
4532 pdata->temp_t[idx] = value;
4533 idx++;
4534 }
4535
4536 /* t3 */
4537 if (of_find_property(np, "table_t3", &length) &&
4538 of_find_property(np, "temp_t3", &length)) {
4539 DBG("%s: read table_t3\n", __func__);
4540
4541 if (of_property_read_u32_array(np, "table_t3",
4542 pdata->table_t[idx],
4543 pdata->ocv_size)) {
4544 dev_err(di->dev, "invalid table_t3\n");
4545 return -EINVAL;
4546 }
4547
4548 if (of_property_read_u32_index(np, "temp_t3", 1, &value) ||
4549 of_property_read_u32_index(np, "temp_t3", 0, &negative)) {
4550 dev_err(di->dev, "invalid temp_t3\n");
4551 return -EINVAL;
4552 }
4553 if (negative)
4554 pdata->temp_t[idx] = -value;
4555 else
4556 pdata->temp_t[idx] = value;
4557 idx++;
4558 }
4559
4560 di->pdata->temp_t_num = idx;
4561
4562 DBG("realtime ocv table nums=%d\n", di->pdata->temp_t_num);
4563
4564 if (dbg_enable) {
4565 for (j = 0; j < pdata->temp_t_num; j++) {
4566 DBG("\n\ntemperature[%d]=%d\n", j, pdata->temp_t[j]);
4567 for (i = 0; i < di->pdata->ocv_size; i++)
4568 DBG("table_t%d[%d]=%d\n",
4569 j, i, pdata->table_t[j][i]);
4570 }
4571 }
4572
4573 return 0;
4574 }
4575
parse_temperature_chrg_table(struct rk816_battery * di,struct device_node * np)4576 static int parse_temperature_chrg_table(struct rk816_battery *di,
4577 struct device_node *np)
4578 {
4579 int size, count;
4580 int i, chrg_current;
4581 const __be32 *list;
4582
4583 if (!of_find_property(np, "temperature_chrg_table_v2", &size))
4584 return 0;
4585
4586 list = of_get_property(np, "temperature_chrg_table_v2", &size);
4587 size /= sizeof(u32);
4588 if (!size || (size % 3)) {
4589 dev_err(di->dev,
4590 "invalid temperature_chrg_table: size=%d\n", size);
4591 return -EINVAL;
4592 }
4593
4594 count = size / 3;
4595 di->pdata->tc_count = count;
4596 di->pdata->tc_table = devm_kzalloc(di->dev,
4597 count * sizeof(*di->pdata->tc_table),
4598 GFP_KERNEL);
4599 if (!di->pdata->tc_table)
4600 return -ENOMEM;
4601
4602 for (i = 0; i < count; i++) {
4603 /* temperature */
4604 di->pdata->tc_table[i].temp_down = be32_to_cpu(*list++);
4605 di->pdata->tc_table[i].temp_up = be32_to_cpu(*list++);
4606
4607 /*
4608 * because charge current lowest level is 1000mA:
4609 * higher than or equal 1000ma, select charge current;
4610 * lower than 1000ma, must select input current.
4611 */
4612 chrg_current = be32_to_cpu(*list++);
4613 if (chrg_current >= 1000) {
4614 di->pdata->tc_table[i].set_chrg_current = 1;
4615 di->pdata->tc_table[i].chrg_current =
4616 rk816_bat_decode_chrg_current(di, chrg_current);
4617 } else {
4618 di->pdata->tc_table[i].chrg_current =
4619 rk816_bat_decode_input_current(di, chrg_current);
4620 }
4621
4622 DBG("temp%d: [%d, %d], chrg_current=%d\n",
4623 i, di->pdata->tc_table[i].temp_down,
4624 di->pdata->tc_table[i].temp_up,
4625 di->pdata->tc_table[i].chrg_current);
4626 }
4627
4628 return 0;
4629 }
4630
4631
rk816_bat_parse_dt(struct rk816_battery * di)4632 static int rk816_bat_parse_dt(struct rk816_battery *di)
4633 {
4634 u32 out_value;
4635 int length, ret;
4636 size_t size;
4637 struct device_node *np;
4638 struct battery_platform_data *pdata;
4639 struct device *dev = di->dev;
4640 enum of_gpio_flags flags;
4641
4642 np = of_find_node_by_name(di->rk816->i2c->dev.of_node, "battery");
4643 if (!np) {
4644 dev_err(dev, "battery node not found!\n");
4645 return -ENODEV;
4646 }
4647
4648 pdata = devm_kzalloc(di->dev, sizeof(*pdata), GFP_KERNEL);
4649 if (!pdata)
4650 return -ENOMEM;
4651
4652 di->pdata = pdata;
4653 /* init default param */
4654 pdata->bat_res = DEFAULT_BAT_RES;
4655 pdata->monitor_sec = DEFAULT_MONITOR_SEC;
4656 pdata->pwroff_vol = DEFAULT_PWROFF_VOL_THRESD;
4657 pdata->sleep_exit_current = DEFAULT_SLP_EXIT_CUR;
4658 pdata->sleep_enter_current = DEFAULT_SLP_ENTER_CUR;
4659 pdata->sleep_filter_current = DEFAULT_SLP_FILTER_CUR;
4660 pdata->bat_mode = MODE_BATTARY;
4661 pdata->max_soc_offset = DEFAULT_MAX_SOC_OFFSET;
4662 pdata->fb_temp = DEFAULT_FB_TEMP;
4663 pdata->energy_mode = DEFAULT_ENERGY_MODE;
4664 pdata->zero_reserve_dsoc = DEFAULT_ZERO_RESERVE_DSOC;
4665 pdata->sample_res = DEFAULT_SAMPLE_RES;
4666
4667 /* parse necessary param */
4668 if (!of_find_property(np, "ocv_table", &length)) {
4669 dev_err(dev, "ocv_table not found!\n");
4670 return -EINVAL;
4671 }
4672
4673 pdata->ocv_size = length / sizeof(u32);
4674 if (pdata->ocv_size <= 0) {
4675 dev_err(dev, "invalid ocv table\n");
4676 return -EINVAL;
4677 }
4678
4679 size = sizeof(*pdata->ocv_table) * pdata->ocv_size;
4680 pdata->ocv_table = devm_kzalloc(di->dev, size, GFP_KERNEL);
4681 if (!pdata->ocv_table)
4682 return -ENOMEM;
4683
4684 ret = of_property_read_u32_array(np, "ocv_table", pdata->ocv_table,
4685 pdata->ocv_size);
4686 if (ret < 0)
4687 return ret;
4688
4689 ret = rk816_bat_read_ocv_tables(di, np);
4690 if (ret < 0) {
4691 di->pdata->temp_t_num = 0;
4692 dev_err(dev, "read table_t error\n");
4693 return ret;
4694 }
4695
4696 ret = of_property_read_u32(np, "design_capacity", &out_value);
4697 if (ret < 0) {
4698 dev_err(dev, "design_capacity not found!\n");
4699 return ret;
4700 }
4701 pdata->design_capacity = out_value;
4702
4703 ret = of_property_read_u32(np, "design_qmax", &out_value);
4704 if (ret < 0) {
4705 dev_err(dev, "design_qmax not found!\n");
4706 return ret;
4707 }
4708 pdata->design_qmax = out_value;
4709
4710 ret = of_property_read_u32(np, "max_chrg_current", &out_value);
4711 if (ret < 0) {
4712 dev_err(dev, "max_chrg_current missing!\n");
4713 return ret;
4714 }
4715 pdata->max_chrg_current = out_value;
4716
4717 ret = of_property_read_u32(np, "max_input_current", &out_value);
4718 if (ret < 0) {
4719 dev_err(dev, "max_input_current missing!\n");
4720 return ret;
4721 }
4722 pdata->max_input_current = out_value;
4723
4724 ret = of_property_read_u32(np, "max_chrg_voltage", &out_value);
4725 if (ret < 0) {
4726 dev_err(dev, "max_chrg_voltage missing!\n");
4727 return ret;
4728 }
4729 pdata->max_chrg_voltage = out_value;
4730 if (out_value >= 4300)
4731 pdata->zero_algorithm_vol = DEFAULT_ALGR_VOL_THRESD2;
4732 else
4733 pdata->zero_algorithm_vol = DEFAULT_ALGR_VOL_THRESD1;
4734
4735 pdata->extcon = device_property_read_bool(dev->parent, "extcon");
4736 if (!pdata->extcon) {
4737 dev_err(dev, "Can't find extcon node under rk816 node\n");
4738 return -EINVAL;
4739 }
4740
4741 /* parse unnecessary param */
4742 of_property_read_u32(np, "sample_res", &pdata->sample_res);
4743
4744 ret = of_property_read_u32(np, "fb_temperature", &pdata->fb_temp);
4745 if (ret < 0)
4746 dev_err(dev, "fb_temperature missing!\n");
4747
4748 ret = of_property_read_u32(np, "energy_mode", &pdata->energy_mode);
4749 if (ret < 0)
4750 dev_err(dev, "energy_mode missing!\n");
4751
4752 ret = of_property_read_u32(np, "max_soc_offset",
4753 &pdata->max_soc_offset);
4754 if (ret < 0)
4755 dev_err(dev, "max_soc_offset missing!\n");
4756
4757 ret = of_property_read_u32(np, "monitor_sec", &pdata->monitor_sec);
4758 if (ret < 0)
4759 dev_err(dev, "monitor_sec missing!\n");
4760
4761 ret = of_property_read_u32(np, "zero_algorithm_vol",
4762 &pdata->zero_algorithm_vol);
4763 if (ret < 0)
4764 dev_err(dev, "zero_algorithm_vol missing!\n");
4765
4766 ret = of_property_read_u32(np, "zero_reserve_dsoc",
4767 &pdata->zero_reserve_dsoc);
4768
4769 ret = of_property_read_u32(np, "virtual_power", &pdata->bat_mode);
4770 if (ret < 0)
4771 dev_err(dev, "virtual_power missing!\n");
4772
4773 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
4774 if (ret < 0)
4775 dev_err(dev, "power_dc2otg missing!\n");
4776
4777 ret = of_property_read_u32(np, "bat_res", &pdata->bat_res);
4778 if (ret < 0)
4779 dev_err(dev, "bat_res missing!\n");
4780
4781 ret = of_property_read_u32(np, "sleep_enter_current",
4782 &pdata->sleep_enter_current);
4783 if (ret < 0)
4784 dev_err(dev, "sleep_enter_current missing!\n");
4785
4786 ret = of_property_read_u32(np, "sleep_exit_current",
4787 &pdata->sleep_exit_current);
4788 if (ret < 0)
4789 dev_err(dev, "sleep_exit_current missing!\n");
4790
4791 ret = of_property_read_u32(np, "sleep_filter_current",
4792 &pdata->sleep_filter_current);
4793 if (ret < 0)
4794 dev_err(dev, "sleep_filter_current missing!\n");
4795
4796 ret = of_property_read_u32(np, "power_off_thresd", &pdata->pwroff_vol);
4797 if (ret < 0)
4798 dev_err(dev, "power_off_thresd missing!\n");
4799
4800 ret = of_property_read_u32(np, "otg5v_suspend_enable",
4801 &pdata->otg5v_suspend_enable);
4802 if (ret < 0)
4803 pdata->otg5v_suspend_enable = 1;
4804
4805 if (!of_find_property(np, "dc_det_gpio", &length)) {
4806 pdata->dc_det_pin = -1;
4807 of_property_read_u32(np, "dc_det_adc", &pdata->dc_det_adc);
4808 if (!pdata->dc_det_adc)
4809 BAT_INFO("not support dc\n");
4810 else
4811 BAT_INFO("support adc dc\n");
4812 } else {
4813 BAT_INFO("support gpio dc\n");
4814 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
4815 0, &flags);
4816 if (gpio_is_valid(pdata->dc_det_pin)) {
4817 pdata->dc_det_level =
4818 (flags & OF_GPIO_ACTIVE_LOW) ? 0 : 1;
4819 /* if support dc, default set power_dc2otg = 1 */
4820 pdata->power_dc2otg = 1;
4821 }
4822 }
4823
4824 if (!of_find_property(np, "ntc_table", &length)) {
4825 pdata->ntc_size = 0;
4826 } else {
4827 /* get ntc degree base value */
4828 ret = of_property_read_s32(np, "ntc_degree_from_v2",
4829 &pdata->ntc_degree_from);
4830 if (ret) {
4831 dev_err(dev, "invalid ntc_degree_from_v2\n");
4832 return -EINVAL;
4833 }
4834
4835 pdata->ntc_size = length / sizeof(u32);
4836 }
4837
4838 if (pdata->ntc_size) {
4839 size = sizeof(*pdata->ntc_table) * pdata->ntc_size;
4840 pdata->ntc_table = devm_kzalloc(di->dev, size, GFP_KERNEL);
4841 if (!pdata->ntc_table)
4842 return -ENOMEM;
4843
4844 ret = of_property_read_u32_array(np, "ntc_table",
4845 pdata->ntc_table,
4846 pdata->ntc_size);
4847 if (ret < 0)
4848 return ret;
4849
4850 if (pdata->ntc_table[0] < NTC_80UA_MAX_MEASURE)
4851 pdata->ntc_factor = NTC_CALC_FACTOR_80UA;
4852 else if (pdata->ntc_table[0] < NTC_60UA_MAX_MEASURE)
4853 pdata->ntc_factor = NTC_CALC_FACTOR_60UA;
4854 else if (pdata->ntc_table[0] < NTC_40UA_MAX_MEASURE)
4855 pdata->ntc_factor = NTC_CALC_FACTOR_40UA;
4856 else
4857 pdata->ntc_factor = NTC_CALC_FACTOR_20UA;
4858 }
4859
4860 ret = parse_temperature_chrg_table(di, np);
4861 if (ret)
4862 return ret;
4863
4864 DBG("the battery dts info dump:\n"
4865 "bat_res:%d\n"
4866 "res_sample:%d\n"
4867 "max_input_currentmA:%d\n"
4868 "max_chrg_current:%d\n"
4869 "max_chrg_voltage:%d\n"
4870 "design_capacity:%d\n"
4871 "design_qmax :%d\n"
4872 "sleep_enter_current:%d\n"
4873 "sleep_exit_current:%d\n"
4874 "sleep_filter_current:%d\n"
4875 "zero_algorithm_vol:%d\n"
4876 "zero_reserve_dsoc:%d\n"
4877 "monitor_sec:%d\n"
4878 "power_dc2otg:%d\n"
4879 "max_soc_offset:%d\n"
4880 "virtual_power:%d\n"
4881 "pwroff_vol:%d\n"
4882 "dc_det_adc:%d\n"
4883 "ntc_factor:%d\n"
4884 "ntc_size=%d\n"
4885 "ntc_degree_from_v2:%d\n"
4886 "ntc_degree_to:%d\n",
4887 pdata->bat_res, pdata->sample_res, pdata->max_input_current,
4888 pdata->max_chrg_current, pdata->max_chrg_voltage,
4889 pdata->design_capacity, pdata->design_qmax,
4890 pdata->sleep_enter_current, pdata->sleep_exit_current,
4891 pdata->sleep_filter_current, pdata->zero_algorithm_vol,
4892 pdata->zero_reserve_dsoc, pdata->monitor_sec, pdata->power_dc2otg,
4893 pdata->max_soc_offset, pdata->bat_mode, pdata->pwroff_vol,
4894 pdata->dc_det_adc, pdata->ntc_factor,
4895 pdata->ntc_size, pdata->ntc_degree_from,
4896 pdata->ntc_degree_from + pdata->ntc_size - 1
4897 );
4898
4899 return 0;
4900 }
4901
4902 static const struct of_device_id rk816_battery_of_match[] = {
4903 {.compatible = "rk816-battery",},
4904 { },
4905 };
4906
rk816_battery_probe(struct platform_device * pdev)4907 static int rk816_battery_probe(struct platform_device *pdev)
4908 {
4909 const struct of_device_id *of_id =
4910 of_match_device(rk816_battery_of_match, &pdev->dev);
4911 struct rk816_battery *di;
4912 struct rk808 *rk816 = dev_get_drvdata(pdev->dev.parent);
4913 int ret;
4914
4915 if (!of_id) {
4916 dev_err(&pdev->dev, "Failed to find matching dt id\n");
4917 return -ENODEV;
4918 }
4919
4920 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
4921 if (!di)
4922 return -ENOMEM;
4923
4924 di->rk816 = rk816;
4925 di->pdev = pdev;
4926 di->dev = &pdev->dev;
4927 di->regmap = rk816->regmap;
4928 platform_set_drvdata(pdev, di);
4929
4930 ret = rk816_bat_parse_dt(di);
4931 if (ret < 0) {
4932 dev_err(&pdev->dev, "rk816 battery parse dt failed!\n");
4933 return ret;
4934 }
4935
4936 if (!is_rk816_bat_exist(di)) {
4937 di->pdata->bat_mode = MODE_VIRTUAL;
4938 dev_err(&pdev->dev, "no battery, virtual power mode\n");
4939 }
4940
4941 ret = rk816_bat_init_power_supply(di);
4942 if (ret) {
4943 dev_err(&pdev->dev, "rk816 power supply register failed!\n");
4944 return ret;
4945 }
4946
4947 rk816_bat_init_info(di);
4948 rk816_bat_init_fg(di);
4949 rk816_bat_init_leds(di);
4950 rk816_bat_init_charger(di);
4951 rk816_bat_init_sysfs(di);
4952 rk816_bat_register_fb_notify(di);
4953 wake_lock_init(&di->wake_lock, WAKE_LOCK_SUSPEND, "rk816_bat_lock");
4954 di->bat_monitor_wq = alloc_ordered_workqueue("%s",
4955 WQ_MEM_RECLAIM | WQ_FREEZABLE, "rk816-bat-monitor-wq");
4956 INIT_DELAYED_WORK(&di->bat_delay_work, rk816_battery_work);
4957
4958 ret = rk816_bat_init_irqs(di);
4959 if (ret) {
4960 dev_err(&pdev->dev, "rk816 bat irq init failed!\n");
4961 goto irq_fail;
4962 }
4963
4964 queue_delayed_work(di->bat_monitor_wq, &di->bat_delay_work,
4965 msecs_to_jiffies(TIMER_MS_COUNTS * 5));
4966
4967 BAT_INFO("driver version %s\n", DRIVER_VERSION);
4968
4969 return 0;
4970
4971 irq_fail:
4972 cancel_delayed_work(&di->dc_delay_work);
4973 cancel_delayed_work(&di->bat_delay_work);
4974 cancel_delayed_work(&di->calib_delay_work);
4975 destroy_workqueue(di->bat_monitor_wq);
4976 destroy_workqueue(di->usb_charger_wq);
4977 rk816_bat_unregister_fb_notify(di);
4978 del_timer(&di->caltimer);
4979 wake_lock_destroy(&di->wake_lock);
4980
4981 return ret;
4982 }
4983
rk816_battery_suspend(struct platform_device * dev,pm_message_t state)4984 static int rk816_battery_suspend(struct platform_device *dev,
4985 pm_message_t state)
4986 {
4987 struct rk816_battery *di = platform_get_drvdata(dev);
4988 u8 st;
4989
4990 cancel_delayed_work_sync(&di->bat_delay_work);
4991 di->s2r = false;
4992 di->sleep_chrg_online = rk816_bat_chrg_online(di);
4993 di->sleep_chrg_status = rk816_bat_get_chrg_status(di);
4994 di->current_avg = rk816_bat_get_avg_current(di);
4995 di->remain_cap = rk816_bat_get_coulomb_cap(di);
4996 di->rsoc = rk816_bat_get_rsoc(di);
4997 di->rtc_base = rk816_get_rtc_sec();
4998 rk816_bat_save_data(di);
4999 st = (rk816_bat_read(di, RK816_SUP_STS_REG) & CHRG_STATUS_MSK) >> 4;
5000 di->slp_dcdc_en_reg = rk816_bat_read(di, RK816_SLP_DCDC_EN_REG);
5001
5002 /* enable sleep boost5v and otg5v */
5003 if (di->pdata->otg5v_suspend_enable) {
5004 if ((di->otg_in && !di->dc_in) ||
5005 (di->otg_in && di->dc_in && !di->pdata->power_dc2otg)) {
5006 rk816_bat_set_bits(di, RK816_SLP_DCDC_EN_REG,
5007 OTG_BOOST_SLP_ON, OTG_BOOST_SLP_ON);
5008 BAT_INFO("suspend: otg 5v on\n");
5009 } else {
5010 /* disable sleep otg5v */
5011 rk816_bat_set_bits(di, RK816_SLP_DCDC_EN_REG,
5012 OTG_BOOST_SLP_ON, 0);
5013 BAT_INFO("suspend: otg 5v off\n");
5014 }
5015 } else {
5016 /* disable sleep otg5v */
5017 rk816_bat_set_bits(di, RK816_SLP_DCDC_EN_REG,
5018 OTG_BOOST_SLP_ON, 0);
5019 BAT_INFO("suspend: otg 5v off\n");
5020 }
5021
5022 /* if not CHARGE_FINISH, reinit chrg_finish_base.
5023 * avoid sleep loop in suspend and resume all the time
5024 */
5025 if (di->sleep_chrg_status != CHARGE_FINISH)
5026 di->chrg_finish_base = get_boot_sec();
5027
5028 /* avoid: enter suspend from MODE_ZERO: load from heavy to light */
5029 if ((di->work_mode == MODE_ZERO) &&
5030 (di->sleep_chrg_online) && (di->current_avg >= 0)) {
5031 DBG("suspend: MODE_ZERO exit...\n");
5032 /* it need't do prepare for mode finish and smooth, it will
5033 * be done in display_smooth
5034 */
5035 if (di->sleep_chrg_status == CHARGE_FINISH) {
5036 di->work_mode = MODE_FINISH;
5037 di->chrg_finish_base = get_boot_sec();
5038 } else {
5039 di->work_mode = MODE_SMOOTH;
5040 rk816_bat_smooth_algo_prepare(di);
5041 }
5042 }
5043
5044 BAT_INFO("suspend: dl=%d rl=%d c=%d v=%d cap=%d at=%ld ch=%d st=%s\n",
5045 di->dsoc, di->rsoc, di->current_avg,
5046 rk816_bat_get_avg_voltage(di), rk816_bat_get_coulomb_cap(di),
5047 di->sleep_dischrg_sec, di->sleep_chrg_online, bat_status[st]);
5048
5049 return 0;
5050 }
5051
rk816_battery_resume(struct platform_device * dev)5052 static int rk816_battery_resume(struct platform_device *dev)
5053 {
5054 int interval_sec, pwroff_vol, time_step = DISCHRG_TIME_STEP1;
5055 struct rk816_battery *di = platform_get_drvdata(dev);
5056 u8 st;
5057
5058 di->s2r = true;
5059 di->voltage_avg = rk816_bat_get_avg_voltage(di);
5060 di->current_avg = rk816_bat_get_avg_current(di);
5061 di->voltage_relax = rk816_bat_get_relax_voltage(di);
5062 di->current_relax = rk816_bat_get_relax_current(di);
5063 di->remain_cap = rk816_bat_get_coulomb_cap(di);
5064 di->rsoc = rk816_bat_get_rsoc(di);
5065 interval_sec = rk816_bat_rtc_sleep_sec(di);
5066 di->sleep_sum_sec += interval_sec;
5067 pwroff_vol = di->pdata->pwroff_vol;
5068 st = (rk816_bat_read(di, RK816_SUP_STS_REG) & CHRG_STATUS_MSK) >> 4;
5069 /* resume sleep boost5v and otg5v */
5070 rk816_bat_set_bits(di, RK816_SLP_DCDC_EN_REG,
5071 OTG_BOOST_SLP_ON, di->slp_dcdc_en_reg);
5072
5073 if (!di->sleep_chrg_online) {
5074 /* only add up discharge sleep seconds */
5075 di->sleep_dischrg_sec += interval_sec;
5076 if (di->voltage_avg <= pwroff_vol + 50)
5077 time_step = DISCHRG_TIME_STEP1;
5078 else
5079 time_step = DISCHRG_TIME_STEP2;
5080 }
5081
5082 BAT_INFO("resume: dl=%d rl=%d c=%d v=%d rv=%d cap=%d dt=%d at=%ld ch=%d st=%s\n",
5083 di->dsoc, di->rsoc, di->current_avg, di->voltage_avg,
5084 di->voltage_relax, rk816_bat_get_coulomb_cap(di), interval_sec,
5085 di->sleep_dischrg_sec, di->sleep_chrg_online, bat_status[st]);
5086
5087 /* sleep: enough time and discharge */
5088 if ((di->sleep_dischrg_sec > time_step) && (!di->sleep_chrg_online)) {
5089 if (rk816_bat_sleep_dischrg(di))
5090 di->sleep_dischrg_sec = 0;
5091 }
5092
5093 rk816_bat_save_data(di);
5094
5095 /* charge/lowpower lock: for battery work to update dsoc and rsoc */
5096 if ((di->sleep_chrg_online) ||
5097 (!di->sleep_chrg_online && di->voltage_avg <= pwroff_vol))
5098 wake_lock_timeout(&di->wake_lock, msecs_to_jiffies(2000));
5099
5100 queue_delayed_work(di->bat_monitor_wq, &di->bat_delay_work,
5101 msecs_to_jiffies(1000));
5102
5103 return 0;
5104 }
5105
rk816_battery_shutdown(struct platform_device * dev)5106 static void rk816_battery_shutdown(struct platform_device *dev)
5107 {
5108 u8 cnt = 0;
5109 struct rk816_battery *di = platform_get_drvdata(dev);
5110
5111 extcon_unregister_notifier(di->cable_edev, EXTCON_CHG_USB_SDP,
5112 &di->cable_cg_nb);
5113 extcon_unregister_notifier(di->cable_edev, EXTCON_CHG_USB_DCP,
5114 &di->cable_cg_nb);
5115 extcon_unregister_notifier(di->cable_edev, EXTCON_CHG_USB_CDP,
5116 &di->cable_cg_nb);
5117 extcon_unregister_notifier(di->cable_edev, EXTCON_USB_VBUS_EN,
5118 &di->cable_host_nb);
5119 extcon_unregister_notifier(di->cable_edev, EXTCON_USB,
5120 &di->cable_discnt_nb);
5121
5122 rk816_bat_unregister_fb_notify(di);
5123 cancel_delayed_work_sync(&di->dc_delay_work);
5124 cancel_delayed_work_sync(&di->bat_delay_work);
5125 cancel_delayed_work_sync(&di->calib_delay_work);
5126 cancel_delayed_work_sync(&di->usb_work);
5127 cancel_delayed_work_sync(&di->host_work);
5128 cancel_delayed_work_sync(&di->discnt_work);
5129 destroy_workqueue(di->bat_monitor_wq);
5130 destroy_workqueue(di->usb_charger_wq);
5131
5132 del_timer(&di->caltimer);
5133 rk816_bat_set_otg_power(di, USB_OTG_POWER_OFF);
5134
5135 if (base2sec(di->boot_base) < REBOOT_PERIOD_SEC)
5136 cnt = rk816_bat_check_reboot(di);
5137 else
5138 rk816_bat_save_reboot_cnt(di, 0);
5139
5140 BAT_INFO("shutdown: dl=%d rl=%d c=%d v=%d cap=%d f=%d ch=%d otg=%d 5v=%d n=%d mode=%d rest=%d\n",
5141 di->dsoc, di->rsoc, di->current_avg, di->voltage_avg,
5142 di->remain_cap, di->fcc, rk816_bat_chrg_online(di),
5143 di->otg_in, di->otg_pmic5v, cnt,
5144 di->algo_rest_mode, di->algo_rest_val);
5145 }
5146
5147 static struct platform_driver rk816_battery_driver = {
5148 .probe = rk816_battery_probe,
5149 .suspend = rk816_battery_suspend,
5150 .resume = rk816_battery_resume,
5151 .shutdown = rk816_battery_shutdown,
5152 .driver = {
5153 .name = "rk816-battery",
5154 .of_match_table = rk816_battery_of_match,
5155 },
5156 };
5157
battery_init(void)5158 static int __init battery_init(void)
5159 {
5160 return platform_driver_register(&rk816_battery_driver);
5161 }
5162 fs_initcall_sync(battery_init);
5163
battery_exit(void)5164 static void __exit battery_exit(void)
5165 {
5166 platform_driver_unregister(&rk816_battery_driver);
5167 }
5168 module_exit(battery_exit);
5169
5170 MODULE_LICENSE("GPL");
5171 MODULE_ALIAS("platform:rk816-battery");
5172 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");
5173