1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * This driver enables to monitor battery health and control charger
4 *
5 * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
6 *
7 * Author: Xu Shengfei <xsf@rock-chips.com>
8 *
9 * This driver enables to monitor battery health and control charger
10 * during suspend-to-mem.
11 * Charger manager depends on other devices. Register this later than
12 * the depending devices.
13 */
14
15 #include <linux/delay.h>
16 #include <linux/io.h>
17 #include <linux/module.h>
18 #include <linux/irq.h>
19 #include <linux/interrupt.h>
20 #include <linux/rtc.h>
21 #include <linux/slab.h>
22 #include <linux/workqueue.h>
23 #include <linux/platform_device.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/sysfs.h>
26 #include <linux/of.h>
27 #include <linux/thermal.h>
28 #include <../drivers/extcon/extcon.h>
29 #include <linux/power_supply.h>
30 #include <linux/extcon.h>
31 #include <linux/alarmtimer.h>
32
33 static int dbg_enable;
34
35 module_param_named(dbg_level, dbg_enable, int, 0644);
36
37 #define CM_DBG(args...) \
38 do { \
39 if (dbg_enable) { \
40 pr_info(args); \
41 } \
42 } while (0)
43
44 /*
45 * Regard CM_JIFFIES_SMALL jiffies is small enough to ignore for
46 * delayed works so that we can run delayed works with CM_JIFFIES_SMALL
47 * without any delays.
48 */
49 #define CM_JIFFIES_SMALL (2)
50
51 /* If y is valid (> 0) and smaller than x, do x = y */
52 #define CM_MIN_VALID(x, y) (x = (((y > 0) && ((x) > (y))) ? (y) : (x)))
53
54 #define PM_WORK_RUN_INTERVAL 300
55 #define TAPER_TIMEOUT (5000 / PM_WORK_RUN_INTERVAL)
56 #define IBUS_CHANGE_TIMEOUT (500 / PM_WORK_RUN_INTERVAL)
57
58 #define FC_VOLTAGE_STEP (20 * 1000)
59 #define FC_CURRENT_STEP (50 * 1000)
60
61 #define USB_SDP_INPUT_CURRENT (500 * 1000)
62 #define USB_DCP_INPUT_CURRENT (2000 * 1000)
63 #define USB_CDP_INPUT_CURRENT (1500 * 1000)
64 #define USB_TYPE_C_INPUT_CURRENT (900 * 1000)
65 #define USB_PPS_INPUT_CURRENT (1000 * 1000)
66 #define SW_FC_CURRENT_STEP (100 * 1000)
67
68 #define FC_VOLTAGE_THRESHOLD_VALUE (50 * 1000)
69
70 enum polling_modes {
71 CM_POLL_DISABLE = 0,
72 CM_POLL_ALWAYS,
73 CM_POLL_EXTERNAL_POWER_ONLY,
74 CM_POLL_CHARGING_ONLY,
75 };
76
77 enum jeita_status {
78 CM_JEITA_COLD,
79 CM_JEITA_COOL,
80 CM_JEITA_GOOD,
81 CM_JEITA_WARM,
82 CM_JEITA_HOT,
83 };
84
85 enum cm_batt_temp {
86 CM_BATT_OK = 0,
87 CM_BATT_OVERHEAT,
88 CM_BATT_COLD,
89 };
90
91 enum cm_charge_type {
92 CHARGE_TYPE_DISCHARGE = 0,
93 CHARGE_TYPE_NORMAL,
94 CHARGE_TYPE_TYPE_C,
95 CHARGE_TYPE_PD,
96 CHARGE_TYPE_PPS,
97 };
98
99 enum cm_pps_state {
100 PPS_PM_STATE_ENTRY,
101 PPS_PM_STATE_FC_ENTRY,
102 PPS_PM_STATE_FC_ENTRY_1,
103 PPS_PM_STATE_FC_ENTRY_2,
104 PPS_PM_STATE_FC_TUNE,
105 PPS_PM_STATE_FC_JEITA,
106 PPS_PM_STATE_FC_EXIT,
107 };
108
109 struct fastcharge_config {
110 /*bat volt loop limit*/
111 int vbat_lmt;
112 int ibat_lmt;
113 int vbat_now;
114 int ibat_now;
115 int pcb_resistance;
116
117 int vbus_lmt;
118 int ibus_lmt;
119
120 int vbus_cp_lmt;
121 int ibus_cp_lmt;
122 int vbus_cp;
123 int ibus_cp;
124
125 int adapter_volt_max_lmt;
126 int adapter_curr_max_lmt;
127 int adaper_power_lmt;
128 int adaper_power_init_flag;
129 int adapter_volt_required;
130 int adapter_curr_required;
131 int cable_resistance;
132
133 bool jeita_charge_support;
134 bool jeita_enable_charge;
135 int jeita_status;
136 int jeita_status_changed;
137 int jeita_temperature;
138 int jeita_charge_current;
139 int jeita_charge_voltage;
140
141 int ibus_dcdc_lmt;
142 int sw_input_current;
143 int sw_charge_current;
144 int sw_charge_voltage;
145 int sw_charge_current_max;
146 int sw_charge_status;
147 /* overvoltage protection */
148 int sw_ovp_flag;
149
150 int min_vbat_for_cp;
151 int fc_taper_current;
152 int fc_steps;
153
154 int charge_type;
155 /* disable switching charger during flash charge*/
156 bool fc_disable_sw;
157 bool fc_charge_error;
158 };
159
160 struct fuel_gauge_info {
161 int vbat_now;
162 int ibat_now;
163 int bat_res;
164 int bat_temperature;
165 };
166
167 struct chargepump_info {
168 bool charge_enabled;
169 bool batt_pres;
170 bool vbus_pres;
171
172 /* alarm/fault status */
173 bool bat_ovp_fault;
174 bool bat_ocp_fault;
175 bool bus_ovp_fault;
176 bool bus_ocp_fault;
177
178 bool bat_ovp_alarm;
179 bool bat_ocp_alarm;
180 bool bus_ovp_alarm;
181 bool bus_ocp_alarm;
182
183 bool bat_ucp_alarm;
184
185 bool bat_therm_alarm;
186 bool bus_therm_alarm;
187 bool die_therm_alarm;
188
189 bool bat_therm_fault;
190 bool bus_therm_fault;
191 bool die_therm_fault;
192
193 bool therm_shutdown_flag;
194 bool therm_shutdown_stat;
195
196 bool vbat_reg;
197 bool ibat_reg;
198
199 int vout_volt;
200 int vbat_volt;
201 int vbus_volt;
202 int vbus_max;
203 int ibat_curr;
204 int ibus_curr;
205 int ibus_max;
206
207 int vbus_error_low;
208 int vbus_error_high;
209
210 int bat_temp;
211 int bus_temp;
212 int die_temp;
213
214 int cp_alarm_status;
215 int cp_fault_status;
216
217 int request_voltage;
218 int request_current;
219 };
220
221 struct jeita_charge_info {
222 int temp_down;
223 int temp_up;
224 int chrg_current;
225 int chrg_voltage;
226 };
227
228 /**
229 * struct charger_desc
230 * @psy_name: the name of power-supply-class for charger manager
231 * @polling_mode:
232 * Determine which polling mode will be used
233 * @polling_interval_ms: interval in millisecond at which
234 * charger manager will monitor battery health
235 * @psy_charger_stat: the names of power-supply for chargers
236 * @psy_fuel_gauge: the name of power-supply for fuel gauge
237 * @temp_min : Minimum battery temperature for charging.
238 * @temp_max : Maximum battery temperature for charging.
239 * @temp_diff : Temperature difference to restart charging.
240 * @measure_battery_temp:
241 * true: measure battery temperature
242 * false: measure ambient temperature
243 * @charging_max_duration_ms: Maximum possible duration for charging
244 * If whole charging duration exceed 'charging_max_duration_ms',
245 * cm stop charging.
246 * @discharging_max_duration_ms:
247 * Maximum possible duration for discharging with charger cable
248 * after full-batt. If discharging duration exceed 'discharging
249 * max_duration_ms', cm start charging.
250 */
251 struct charger_desc {
252 const char *psy_name;
253
254 enum polling_modes polling_mode;
255 unsigned int polling_interval_ms;
256 unsigned int polling_force_enable;
257
258 struct power_supply_battery_info info;
259
260 const char *psy_charger_stat;
261 const char *psy_charger_pump_stat;
262 const char *psy_fuel_gauge;
263 const char *thermal_zone;
264
265 struct power_supply *tcpm_psy;
266 struct extcon_dev *extcon_dev;
267
268 struct jeita_charge_info *jeita_charge_table;
269 int jeita_charge_table_count;
270
271 bool measure_battery_temp;
272
273 u32 charging_max_duration_ms;
274 u32 discharging_max_duration_ms;
275 };
276
277 /**
278 * struct charger_manager
279 * @entry: entry for list
280 * @dev: device pointer
281 * @desc: instance of charger_desc
282 * @fuel_gauge: power_supply for fuel gauge
283 * @charger_stat: array of power_supply for chargers
284 * @tzd_batt : thermal zone device for battery
285 * @fc_charger_enabled: the state of charger
286 * @emergency_stop:
287 * When setting true, stop charging
288 * @status_save_ext_pwr_inserted:
289 * saved status of external power before entering suspend-to-RAM
290 * @status_save_batt:
291 * saved status of battery before entering suspend-to-RAM
292 * @charging_start_time: saved start time of enabling charging
293 * @charging_end_time: saved end time of disabling charging
294 * @battery_status: Current battery status
295 */
296 struct charger_manager {
297 struct list_head entry;
298 struct device *dev;
299 struct charger_desc *desc;
300
301 struct workqueue_struct *cm_wq; /* init at driver add */
302 struct delayed_work cm_monitor_work; /* init at driver add */
303 struct delayed_work cm_jeita_work; /* init at driver add */
304
305 /* The state of charger cable */
306 bool attached;
307 bool fc_charger_enabled;
308
309 enum cm_pps_state state;
310 int emergency_stop;
311
312 /* The rockchip-charger-manager use Extcon framework */
313 struct work_struct wq;
314 struct notifier_block nb;
315
316 struct chargepump_info cp;
317 struct fuel_gauge_info fg_info;
318 struct fastcharge_config *fc_config;
319
320 /* About in-suspend (suspend-again) monitoring */
321 int fc2_taper_timer;
322
323 int is_fast_charge;
324 int is_charge;
325
326 unsigned long next_polling;
327 u64 charging_start_time;
328 u64 charging_end_time;
329
330 int battery_status;
331 };
332
333 enum {
334 PM_ALGO_RET_OK,
335 PM_ALGO_RET_THERM_FAULT,
336 PM_ALGO_RET_OTHER_FAULT,
337 PM_ALGO_RET_CHG_DISABLED,
338 PM_ALGO_RET_TAPER_DONE,
339 };
340
341 enum data_source {
342 CM_BATTERY_PRESENT,
343 CM_NO_BATTERY,
344 CM_FUEL_GAUGE,
345 CM_CHARGER_STAT,
346 };
347
348 static const unsigned char *pm_debug_str[] = {
349 "PPS_PM_STATE_ENTRY",
350 "PPS_PM_STATE_FC_ENTRY",
351 "PPS_PM_STATE_FC_ENTRY_1",
352 "PPS_PM_STATE_FC_ENTRY_2",
353 "PPS_PM_STATE_FC_TUNE",
354 "PPS_PM_STATE_FC_JEITA",
355 "PPS_PM_STATE_FC_EXIT"
356 };
357
358 static struct {
359 const char *name;
360 u64 extcon_type;
361 } extcon_mapping[] = {
362 /* Current textual representations */
363 { "SDP", EXTCON_CHG_USB_SDP },
364 { "DCP", EXTCON_CHG_USB_DCP },
365 { "CDP", EXTCON_CHG_USB_CDP },
366 };
367
368 struct power_supply_battery_info bat_default_info = {
369 .precharge_voltage_max_uv = 3600 * 1000, /* microVolts */
370 .charge_term_current_ua = 100 * 1000, /* microAmps */
371 .charge_restart_voltage_uv = 4100 * 1000, /* microVolts */
372 .constant_charge_current_max_ua = 1000 * 1000, /* microAmps */
373 .constant_charge_voltage_max_uv = 4200 * 1000, /* microVolts */
374 .factory_internal_resistance_uohm = 100, /* microOhms */
375 };
376
377 static struct fastcharge_config fc_config_parameter = {
378 .vbat_lmt = 4400 * 1000,
379 .ibat_lmt = 8000 * 1000,
380 .ibus_dcdc_lmt = 1000 * 1000,
381 .vbus_cp_lmt = 9500 * 1000,
382 .ibus_cp_lmt = 4000 * 1000,
383 .fc_taper_current = 500 * 1000,/* disable cp */
384 .fc_steps = 1, /* 20mV step */
385 .adaper_power_lmt = 45000 * 1000,/* mV * mA */
386 .min_vbat_for_cp = 3600,
387 .fc_disable_sw = true,
388 };
389
390 /**
391 * get_battery_temperature - Get the temperature level of the battery
392 * @cm: the Charger Manager representing the battery.
393 * @temperature: the temperature level returned.
394 *
395 * Returns 0 if there is no error.
396 * Returns a negative value on error.
397 */
get_battery_temperature(struct charger_manager * cm,int * temperature)398 static int get_battery_temperature(struct charger_manager *cm,
399 int *temperature)
400 {
401 union power_supply_propval val;
402 struct power_supply *psy;
403 int ret;
404
405 psy = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
406 if (!psy) {
407 cm->fc_config->fc_charge_error = true;
408 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
409 cm->desc->psy_charger_stat);
410 return -ENODEV;
411 }
412
413 ret = power_supply_get_property(psy,
414 POWER_SUPPLY_PROP_TEMP,
415 &val);
416 power_supply_put(psy);
417 if (ret) {
418 cm->fc_config->fc_charge_error = true;
419 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_TEMP\n",
420 cm->desc->psy_fuel_gauge);
421 return ret;
422 }
423
424 *temperature = val.intval;
425 return 0;
426 }
427
428 /**
429 * get_battery_voltage - Get the voltage level of the battery
430 * @cm: the Charger Manager representing the battery.
431 * @uV: the voltage level returned.
432 *
433 * Returns 0 if there is no error.
434 * Returns a negative value on error.
435 */
get_battery_voltage(struct charger_manager * cm,int * uV)436 static int get_battery_voltage(struct charger_manager *cm, int *uV)
437 {
438 union power_supply_propval val;
439 struct power_supply *psy;
440 int ret;
441
442 /* If at least one of them has one, it's yes. */
443 psy = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
444 if (!psy) {
445 cm->fc_config->fc_charge_error = true;
446 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
447 cm->desc->psy_charger_stat);
448 return -ENODEV;
449 }
450
451 ret = power_supply_get_property(psy,
452 POWER_SUPPLY_PROP_VOLTAGE_NOW,
453 &val);
454 power_supply_put(psy);
455 if (ret) {
456 cm->fc_config->fc_charge_error = true;
457 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_VOLTAGE_NOW\n",
458 cm->desc->psy_fuel_gauge);
459 return ret;
460 }
461
462 *uV = val.intval;
463 return 0;
464 }
465
466 /**
467 * get_battery_current - Get the current level of the battery
468 * @cm: the Charger Manager representing the battery.
469 * @uA: the current level returned.
470 *
471 * Returns 0 if there is no error.
472 * Returns a negative value on error.
473 */
get_battery_current(struct charger_manager * cm,int * uA)474 static int get_battery_current(struct charger_manager *cm, int *uA)
475 {
476 union power_supply_propval val;
477 struct power_supply *psy;
478 int ret;
479
480 /* If at least one of them has one, it's yes. */
481 psy = power_supply_get_by_name(cm->desc->psy_fuel_gauge);
482 if (!psy) {
483 cm->fc_config->fc_charge_error = true;
484 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
485 cm->desc->psy_charger_stat);
486 return -ENODEV;
487 }
488
489 ret = power_supply_get_property(psy,
490 POWER_SUPPLY_PROP_CURRENT_NOW,
491 &val);
492 power_supply_put(psy);
493 if (ret) {
494 cm->fc_config->fc_charge_error = true;
495 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_CURRENT_NOW\n",
496 cm->desc->psy_fuel_gauge);
497 return ret;
498 }
499
500 *uA = val.intval;
501 return 0;
502 }
503
504 /**
505 * is_ext_pwr_online - See if an external power source is attached to charge
506 * @cm: the Charger Manager representing the battery.
507 *
508 * Returns true if at least one of the chargers of the battery has an external
509 * power source attached to charge the battery regardless of whether it is
510 * actually charging or not.
511 */
is_ext_pwr_online(struct charger_manager * cm)512 static bool is_ext_pwr_online(struct charger_manager *cm)
513 {
514 union power_supply_propval val;
515 struct power_supply *psy;
516 bool online = false;
517 int ret;
518
519 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
520 if (!psy) {
521 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
522 cm->desc->psy_charger_stat);
523 return online;
524 }
525
526 ret = power_supply_get_property(psy,
527 POWER_SUPPLY_PROP_ONLINE,
528 &val);
529 power_supply_put(psy);
530 if (ret) {
531 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_ONLINE\n",
532 cm->desc->psy_charger_stat);
533 return ret;
534 }
535
536 if (val.intval)
537 online = true;
538
539 return online;
540 }
541
set_sw_charger_enable(struct charger_manager * cm)542 static int set_sw_charger_enable(struct charger_manager *cm)
543 {
544 union power_supply_propval val;
545 struct power_supply *psy;
546 int ret;
547
548 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
549 if (!psy) {
550 cm->fc_config->fc_charge_error = true;
551 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
552 cm->desc->psy_charger_stat);
553 return -ENODEV;
554 }
555
556 val.intval = 0x01;
557 ret = power_supply_set_property(psy,
558 POWER_SUPPLY_PROP_ONLINE,
559 &val);
560
561 power_supply_put(psy);
562 if (ret) {
563 cm->fc_config->fc_charge_error = true;
564 dev_err(cm->dev, "failed to set %s POWER_SUPPLY_PROP_ONLINE\n",
565 cm->desc->psy_charger_stat);
566 return ret;
567 }
568
569 cm->fc_config->sw_charge_status = 1;
570 return 0;
571 }
572
set_sw_charger_disable(struct charger_manager * cm)573 static int set_sw_charger_disable(struct charger_manager *cm)
574 {
575 union power_supply_propval val;
576 struct power_supply *psy;
577 int ret;
578
579 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
580 if (!psy) {
581 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
582 cm->desc->psy_charger_stat);
583 return -ENODEV;
584 }
585
586 val.intval = 0x00;
587 ret = power_supply_set_property(psy,
588 POWER_SUPPLY_PROP_ONLINE,
589 &val);
590
591 power_supply_put(psy);
592 if (ret) {
593 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_ONLINE\n",
594 cm->desc->psy_charger_stat);
595 return ret;
596 }
597
598 cm->fc_config->sw_charge_status = 0;
599 return 0;
600 }
601
set_sw_charger_input_limit_current(struct charger_manager * cm,int input_current_ua)602 static int set_sw_charger_input_limit_current(struct charger_manager *cm,
603 int input_current_ua)
604 {
605 union power_supply_propval val;
606 struct power_supply *psy;
607 int ret;
608
609 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
610 if (!psy) {
611 cm->fc_config->fc_charge_error = true;
612 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
613 cm->desc->psy_charger_stat);
614 return -ENODEV;
615 }
616
617 val.intval = input_current_ua;
618 ret = power_supply_set_property(psy,
619 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
620 &val);
621
622 power_supply_put(psy);
623 if (ret) {
624 cm->fc_config->fc_charge_error = true;
625 dev_err(cm->dev, "failed to set %s POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT\n",
626 cm->desc->psy_charger_stat);
627 return ret;
628 }
629
630 cm->fc_config->ibus_dcdc_lmt = input_current_ua;
631 return 0;
632 }
633
set_sw_charger_voltage(struct charger_manager * cm,int voltage_uv)634 static int set_sw_charger_voltage(struct charger_manager *cm,
635 int voltage_uv)
636 {
637 union power_supply_propval val;
638 struct power_supply *psy;
639 int ret;
640
641 CM_DBG("POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: sw: %d\n", voltage_uv);
642 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
643 if (!psy) {
644 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
645 cm->desc->psy_charger_stat);
646 cm->fc_config->fc_charge_error = true;
647 return -ENODEV;
648 }
649
650 val.intval = voltage_uv;
651 ret = power_supply_set_property(psy,
652 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
653 &val);
654
655 power_supply_put(psy);
656 if (ret) {
657 dev_err(cm->dev, "failed to set %s POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE\n",
658 cm->desc->psy_charger_stat);
659 cm->fc_config->fc_charge_error = true;
660 return ret;
661 }
662
663 cm->fc_config->sw_charge_voltage = voltage_uv;
664 return 0;
665 }
666
set_sw_charger_current(struct charger_manager * cm,int current_ua)667 static int set_sw_charger_current(struct charger_manager *cm,
668 int current_ua)
669 {
670 union power_supply_propval val;
671 struct power_supply *psy;
672 int ret;
673
674 CM_DBG("POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: sw: %d\n", current_ua);
675 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
676 if (!psy) {
677 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
678 cm->desc->psy_charger_stat);
679 cm->fc_config->fc_charge_error = true;
680 return -ENODEV;
681 }
682
683 val.intval = current_ua;
684 ret = power_supply_set_property(psy,
685 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
686 &val);
687
688 power_supply_put(psy);
689 if (ret) {
690 dev_err(cm->dev, "failed to set %s POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT\n",
691 cm->desc->psy_charger_stat);
692 cm->fc_config->fc_charge_error = true;
693 return ret;
694 }
695
696 return 0;
697 }
698
get_sw_charger_current_max(struct charger_manager * cm,int * uA)699 static int get_sw_charger_current_max(struct charger_manager *cm, int *uA)
700 {
701 union power_supply_propval val;
702 struct power_supply *psy;
703 int ret;
704
705 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
706 if (!psy) {
707 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
708 cm->desc->psy_charger_stat);
709 cm->fc_config->fc_charge_error = true;
710 return -ENODEV;
711 }
712
713 ret = power_supply_get_property(psy,
714 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
715 &val);
716
717 power_supply_put(psy);
718 if (ret) {
719 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX\n",
720 cm->desc->psy_charger_stat);
721 cm->fc_config->fc_charge_error = true;
722 return ret;
723 }
724
725 *uA = val.intval;
726 return 0;
727 }
728
get_sw_charger_input_limit_current(struct charger_manager * cm,int * uA)729 static int get_sw_charger_input_limit_current(struct charger_manager *cm, int *uA)
730 {
731 union power_supply_propval val;
732 struct power_supply *psy;
733 int ret;
734
735 psy = power_supply_get_by_name(cm->desc->psy_charger_stat);
736 if (!psy) {
737 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
738 cm->desc->psy_charger_stat);
739 cm->fc_config->fc_charge_error = true;
740 return -ENODEV;
741 }
742
743 ret = power_supply_get_property(psy,
744 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
745 &val);
746
747 power_supply_put(psy);
748 if (ret) {
749 dev_err(cm->dev, "failed to get %s POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT\n",
750 cm->desc->psy_charger_stat);
751 cm->fc_config->fc_charge_error = true;
752 return ret;
753 }
754
755 *uA = val.intval;
756 return 0;
757 }
758
set_cp_enable(struct charger_manager * cm)759 static int set_cp_enable(struct charger_manager *cm)
760 {
761 union power_supply_propval val;
762 struct power_supply *cp_psy;
763 int ret;
764
765 cp_psy = power_supply_get_by_name(cm->desc->psy_charger_pump_stat);
766 if (!cp_psy) {
767 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
768 cm->desc->psy_charger_pump_stat);
769 cm->fc_config->fc_charge_error = true;
770 return -ENODEV;
771 }
772
773 val.intval = 1;
774 ret = power_supply_set_property(cp_psy,
775 POWER_SUPPLY_PROP_CP_CHARGING_ENABLED,
776 &val);
777
778 power_supply_put(cp_psy);
779 if (ret) {
780 dev_err(cm->dev, "failed to enable %s POWER_SUPPLY_PROP_CP_CHARGING_ENABLED\n",
781 cm->desc->psy_charger_pump_stat);
782 cm->fc_config->fc_charge_error = true;
783 return ret;
784 }
785
786 cm->cp.charge_enabled = 1;
787 return 0;
788 }
789
set_cp_disable(struct charger_manager * cm)790 static int set_cp_disable(struct charger_manager *cm)
791 {
792 union power_supply_propval val;
793 struct power_supply *cp_psy;
794 int ret;
795
796 cp_psy = power_supply_get_by_name(cm->desc->psy_charger_pump_stat);
797 if (!cp_psy) {
798 dev_err(cm->dev, "Cannot find power supply \"%s\"\n",
799 cm->desc->psy_charger_pump_stat);
800 cm->fc_config->fc_charge_error = true;
801 return -ENODEV;
802 }
803
804 val.intval = 0;
805 ret = power_supply_set_property(cp_psy,
806 POWER_SUPPLY_PROP_CP_CHARGING_ENABLED,
807 &val);
808
809 power_supply_put(cp_psy);
810 if (ret) {
811 dev_err(cm->dev, "failed to disable %s POWER_SUPPLY_PROP_CP_CHARGING_ENABLED\n",
812 cm->desc->psy_charger_pump_stat);
813 cm->fc_config->fc_charge_error = true;
814 return ret;
815 }
816
817 cm->cp.charge_enabled = 0;
818 return 0;
819 }
820
821 /**
822 * is_polling_required - Return true if need to continue polling for this CM.
823 * @cm: the Charger Manager representing the battery.
824 */
is_polling_required(struct charger_manager * cm)825 static bool is_polling_required(struct charger_manager *cm)
826 {
827 CM_DBG("cm->desc->polling_mode: %d\n", cm->desc->polling_mode);
828 switch (cm->desc->polling_mode) {
829 case CM_POLL_DISABLE:
830 return false;
831 case CM_POLL_ALWAYS:
832 return true;
833 case CM_POLL_EXTERNAL_POWER_ONLY:
834 return is_ext_pwr_online(cm);
835 case CM_POLL_CHARGING_ONLY:
836 return cm->attached && cm->fc_charger_enabled;
837 default:
838 dev_warn(cm->dev, "Incorrect polling_mode (%d)\n",
839 cm->desc->polling_mode);
840 }
841 return false;
842 }
843
cm_update_jeita_charge_info(struct charger_manager * cm)844 static void cm_update_jeita_charge_info(struct charger_manager *cm)
845 {
846 int temperature;
847 int i, count;
848 int ret;
849
850 if (!cm->desc->measure_battery_temp)
851 return;
852
853 ret = get_battery_temperature(cm, &temperature);
854 if (ret) {
855 /* cm->fc_config->jeita_charge_support = false; */
856 cm->fc_config->jeita_enable_charge = false;
857 return;
858 }
859
860 count = cm->desc->jeita_charge_table_count;
861
862 cm->fc_config->jeita_charge_support = true;
863 cm->fc_config->jeita_temperature = temperature;
864 if (temperature / 10 < cm->desc->jeita_charge_table[0].temp_down) {
865 cm->fc_config->jeita_charge_current = 0;
866 cm->fc_config->jeita_charge_voltage = 0;
867 cm->fc_config->jeita_enable_charge = false;
868 cm->fc_config->jeita_status = CM_JEITA_COLD;
869 return;
870 }
871
872 if (temperature / 10 > cm->desc->jeita_charge_table[count - 1].temp_up) {
873 cm->fc_config->jeita_charge_current = 0;
874 cm->fc_config->jeita_charge_voltage = 0;
875 cm->fc_config->jeita_enable_charge = false;
876 cm->fc_config->jeita_status = CM_JEITA_HOT;
877 return;
878 }
879
880 if (!cm->fc_config->jeita_enable_charge)
881 if ((temperature / 10 > cm->desc->jeita_charge_table[0].temp_down + 3) &&
882 (temperature / 10 < cm->desc->jeita_charge_table[count - 1].temp_up - 3))
883 cm->fc_config->jeita_enable_charge = true;
884
885 for (i = 0; i < count; i++) {
886 if ((temperature / 10 > cm->desc->jeita_charge_table[i].temp_down) &&
887 (temperature / 10 <= cm->desc->jeita_charge_table[i].temp_up)) {
888 cm->fc_config->jeita_charge_current =
889 cm->desc->jeita_charge_table[i].chrg_current;
890 cm->fc_config->jeita_charge_voltage =
891 cm->desc->jeita_charge_table[i].chrg_voltage;
892 cm->fc_config->jeita_status = CM_JEITA_COOL + i;
893 return;
894 }
895 }
896 }
897
cm_update_charge_pump_status(struct charger_manager * cm)898 static void cm_update_charge_pump_status(struct charger_manager *cm)
899 {
900 union power_supply_propval val = {0,};
901 struct power_supply *cp_psy;
902 int ret;
903
904 cp_psy = power_supply_get_by_name(cm->desc->psy_charger_pump_stat);
905 if (!cp_psy) {
906 dev_err(cm->dev, "Cannot find power supply:%s\n",
907 cm->desc->psy_charger_pump_stat);
908 return;
909 }
910
911 ret = power_supply_get_property(cp_psy,
912 POWER_SUPPLY_PROP_VOLTAGE_NOW,
913 &val);
914 if (!ret)
915 cm->cp.vbat_volt = val.intval;
916
917 ret = power_supply_get_property(cp_psy,
918 POWER_SUPPLY_PROP_CURRENT_NOW,
919 &val);
920 if (!ret)
921 cm->cp.ibat_curr = val.intval;
922
923 ret = power_supply_get_property(cp_psy,
924 POWER_SUPPLY_PROP_CP_VBUS,
925 &val);
926 if (!ret)
927 cm->cp.vbus_volt = val.intval;
928
929 ret = power_supply_get_property(cp_psy,
930 POWER_SUPPLY_PROP_CP_IBUS,
931 &val);
932 if (!ret)
933 cm->cp.ibus_curr = val.intval;
934
935 ret = power_supply_get_property(cp_psy,
936 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
937 &val);
938 if (!ret)
939 cm->cp.ibus_max = val.intval;
940
941 ret = power_supply_get_property(cp_psy,
942 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
943 &val);
944 if (!ret)
945 cm->cp.vbus_max = val.intval;
946
947 ret = power_supply_get_property(cp_psy,
948 POWER_SUPPLY_PROP_CP_VBUS_HERROR_STATUS,
949 &val);
950 if (!ret)
951 cm->cp.vbus_error_high = val.intval;
952
953 ret = power_supply_get_property(cp_psy,
954 POWER_SUPPLY_PROP_CP_VBUS_LERROR_STATUS,
955 &val);
956 if (!ret)
957 cm->cp.vbus_error_low = val.intval;
958
959 ret = power_supply_get_property(cp_psy,
960 POWER_SUPPLY_PROP_CP_BAT_TEMPERATURE,
961 &val);
962 if (!ret)
963 cm->cp.bat_temp = val.intval;
964 ret = power_supply_get_property(cp_psy,
965 POWER_SUPPLY_PROP_CP_BUS_TEMPERATURE,
966 &val);
967 if (!ret)
968 cm->cp.bus_temp = val.intval;
969 ret = power_supply_get_property(cp_psy,
970 POWER_SUPPLY_PROP_CP_DIE_TEMPERATURE,
971 &val);
972 if (!ret)
973 cm->cp.die_temp = val.intval;
974 ret = power_supply_get_property(cp_psy,
975 POWER_SUPPLY_PROP_CP_BAT_OVP_ALARM,
976 &val);
977 if (!ret)
978 cm->cp.bat_ovp_alarm = val.intval;
979 ret = power_supply_get_property(cp_psy,
980 POWER_SUPPLY_PROP_CP_BAT_OCP_ALARM,
981 &val);
982 if (!ret)
983 cm->cp.bat_ocp_alarm = val.intval;
984 ret = power_supply_get_property(cp_psy,
985 POWER_SUPPLY_PROP_CP_BAT_UCP_ALARM,
986 &val);
987 if (!ret)
988 cm->cp.bat_ucp_alarm = val.intval;
989 ret = power_supply_get_property(cp_psy,
990 POWER_SUPPLY_PROP_CP_BUS_OVP_ALARM,
991 &val);
992 if (!ret)
993 cm->cp.bus_ovp_alarm = val.intval;
994 ret = power_supply_get_property(cp_psy,
995 POWER_SUPPLY_PROP_CP_BUS_OCP_ALARM,
996 &val);
997 if (!ret)
998 cm->cp.bus_ocp_alarm = val.intval;
999 ret = power_supply_get_property(cp_psy,
1000 POWER_SUPPLY_PROP_CP_BAT_THERM_ALARM,
1001 &val);
1002 if (!ret)
1003 cm->cp.bat_therm_alarm = val.intval;
1004 ret = power_supply_get_property(cp_psy,
1005 POWER_SUPPLY_PROP_CP_BUS_THERM_ALARM,
1006 &val);
1007 if (!ret)
1008 cm->cp.bus_therm_alarm = val.intval;
1009 ret = power_supply_get_property(cp_psy,
1010 POWER_SUPPLY_PROP_CP_DIE_THERM_ALARM,
1011 &val);
1012 if (!ret)
1013 cm->cp.die_therm_alarm = val.intval;
1014
1015 ret = power_supply_get_property(cp_psy,
1016 POWER_SUPPLY_PROP_CP_BAT_OVP_FAULT,
1017 &val);
1018 if (!ret)
1019 cm->cp.bat_ovp_fault = val.intval;
1020 ret = power_supply_get_property(cp_psy,
1021 POWER_SUPPLY_PROP_CP_BAT_OCP_FAULT,
1022 &val);
1023 if (!ret)
1024 cm->cp.bat_ocp_fault = val.intval;
1025 ret = power_supply_get_property(cp_psy,
1026 POWER_SUPPLY_PROP_CP_BUS_OVP_FAULT,
1027 &val);
1028 if (!ret)
1029 cm->cp.bus_ovp_fault = val.intval;
1030 ret = power_supply_get_property(cp_psy,
1031 POWER_SUPPLY_PROP_CP_BUS_OCP_FAULT,
1032 &val);
1033 if (!ret)
1034 cm->cp.bus_ocp_fault = val.intval;
1035 ret = power_supply_get_property(cp_psy,
1036 POWER_SUPPLY_PROP_CP_BAT_THERM_FAULT,
1037 &val);
1038 if (!ret)
1039 cm->cp.bat_therm_fault = val.intval;
1040 ret = power_supply_get_property(cp_psy,
1041 POWER_SUPPLY_PROP_CP_BUS_THERM_FAULT,
1042 &val);
1043 if (!ret)
1044 cm->cp.bus_therm_fault = val.intval;
1045 ret = power_supply_get_property(cp_psy,
1046 POWER_SUPPLY_PROP_CP_DIE_THERM_FAULT,
1047 &val);
1048 if (!ret)
1049 cm->cp.die_therm_fault = val.intval;
1050
1051 power_supply_put(cp_psy);
1052
1053 CM_DBG("cm->cp.cp_alarm_status:0x%x, cm->cp.cp_fault_status:0x%x\n",
1054 cm->cp.cp_alarm_status, cm->cp.cp_fault_status);
1055 }
1056
cm_charge_pump_move_state(struct charger_manager * cm,enum cm_pps_state state)1057 static void cm_charge_pump_move_state(struct charger_manager *cm,
1058 enum cm_pps_state state)
1059 {
1060 CM_DBG("state change:%s -> %s\n",
1061 pm_debug_str[cm->state], pm_debug_str[state]);
1062
1063 cm->state = state;
1064 }
1065
cm_charge_limit_update(struct charger_manager * cm)1066 static int cm_charge_limit_update(struct charger_manager *cm)
1067 {
1068 struct fastcharge_config *fc_config;
1069 struct power_supply_battery_info info;
1070 union power_supply_propval val;
1071 int ibus_dcdc_lmt;
1072 int ret = 0;
1073
1074 info = cm->desc->info;
1075 fc_config = cm->fc_config;
1076
1077 if (fc_config->jeita_charge_support) {
1078 fc_config->vbat_lmt = min(info.constant_charge_voltage_max_uv,
1079 fc_config->jeita_charge_voltage);
1080 fc_config->ibat_lmt = min(info.constant_charge_current_max_ua,
1081 fc_config->jeita_charge_current);
1082 } else {
1083 fc_config->vbat_lmt = info.constant_charge_voltage_max_uv;
1084 fc_config->ibat_lmt = info.constant_charge_current_max_ua;
1085 }
1086
1087 ret = get_battery_voltage(cm, &fc_config->vbat_now);
1088 if (ret)
1089 return ret;
1090 if (fc_config->vbat_now <= 0)
1091 fc_config->vbat_now = cm->cp.vbat_volt;
1092
1093 ret = get_battery_current(cm, &fc_config->ibat_now);
1094 if (ret)
1095 return ret;
1096
1097 if ((fc_config->vbat_now >= fc_config->vbat_lmt/* - FC_VOLTAGE_THRESHOLD_VALUE */) &&
1098 (fc_config->sw_ovp_flag == 0))
1099 fc_config->sw_ovp_flag = 1;
1100
1101 ret = get_sw_charger_current_max(cm, &cm->fc_config->sw_charge_current_max);
1102 if (ret)
1103 return ret;
1104
1105 ret = get_sw_charger_input_limit_current(cm, &ibus_dcdc_lmt);
1106 if (ret)
1107 return ret;
1108 if (ibus_dcdc_lmt != 0)
1109 fc_config->ibus_dcdc_lmt = ibus_dcdc_lmt;
1110
1111 fc_config->vbus_cp_lmt = cm->cp.vbus_max;
1112 fc_config->ibus_cp_lmt = cm->cp.ibus_max;
1113 fc_config->vbus_cp = cm->cp.vbus_volt;
1114 fc_config->ibus_cp = cm->cp.ibus_curr;
1115
1116 fc_config->adapter_curr_required = cm->cp.request_current;
1117 fc_config->adapter_volt_required = cm->cp.request_voltage;
1118
1119 if (fc_config->ibus_cp > 1000 * 1000)
1120 fc_config->cable_resistance =
1121 (fc_config->adapter_volt_required - fc_config->vbus_cp) /
1122 ((fc_config->ibus_cp + fc_config->ibus_dcdc_lmt) / 1000);
1123
1124 ret = power_supply_get_property(cm->desc->tcpm_psy,
1125 POWER_SUPPLY_PROP_VOLTAGE_MAX,
1126 &val);
1127 if (ret) {
1128 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_VOLTAGE_MAX\n", __LINE__);
1129 return ret;
1130 }
1131 fc_config->adapter_volt_max_lmt = val.intval;
1132
1133 ret = power_supply_get_property(cm->desc->tcpm_psy,
1134 POWER_SUPPLY_PROP_CURRENT_MAX,
1135 &val);
1136 if (ret) {
1137 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
1138 return ret;
1139 }
1140 fc_config->adapter_curr_max_lmt = val.intval;
1141
1142 ret = power_supply_get_property(cm->desc->tcpm_psy,
1143 POWER_SUPPLY_PROP_INPUT_POWER_LIMIT,
1144 &val);
1145 if (ret) {
1146 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_INPUT_POWER_LIMIT\n", __LINE__);
1147 return ret;
1148 }
1149 fc_config->adaper_power_lmt = val.intval * 1000;
1150
1151 fc_config->ibus_lmt = fc_config->ibat_lmt >> 1;
1152
1153 CM_DBG("jeita: jeita_charge_voltage: %d\n"
1154 "jeita_charge_current: %d\n"
1155 "jeita_temperature: %d\n",
1156 fc_config->jeita_charge_voltage,
1157 fc_config->jeita_charge_current,
1158 fc_config->jeita_temperature);
1159
1160 CM_DBG("battery info:\n");
1161 CM_DBG("battery info:: charge-full-design-microamp-hours: %d\n",
1162 info.charge_full_design_uah);
1163 CM_DBG("battery info:: factory_internal_resistance_uohm: %d\n",
1164 info.factory_internal_resistance_uohm);
1165 CM_DBG("battery info:: charge_term_current_ua: %d\n",
1166 info.charge_term_current_ua);
1167 CM_DBG("battery info:: constant_charge_voltage_max_uv: %d\n",
1168 info.constant_charge_voltage_max_uv);
1169 CM_DBG("battery info:: constant_charge_current_max_ua: %d\n",
1170 info.constant_charge_current_max_ua);
1171 CM_DBG("battery info:: precharge_current_ua: %d\n",
1172 info.precharge_current_ua);
1173 CM_DBG("battery info:: precharge-upper-limit-microvolt: %d\n",
1174 info.precharge_voltage_max_uv);
1175
1176 CM_DBG("charge type: %d\n", fc_config->charge_type);
1177
1178 CM_DBG("vbat_lmt: %d\n"
1179 "ibat_lmt: %d\n"
1180 "vbat_now: %d\n"
1181 "ibat_now: %d\n"
1182 "cp_ibat: %d\n"
1183 "cm->cp.vbat_volt: %d\n"
1184 "vbus_cp_lmt: %d\n"
1185 "ibus_cp_lmt: %d\n"
1186 "vbus_cp: %d\n"
1187 "ibus_cp: %d\n"
1188 "ibus_lmt: %d\n"
1189 "adapter_volt_max_lmt: %d\n"
1190 "adapter_curr_max_lmt: %d\n"
1191 "adapter_curr_required: %d\n"
1192 "adapter_volt_required: %d\n"
1193 "adaper_power_lmt: %d\n"
1194 "cable_resistance: %d\n",
1195 fc_config->vbat_lmt,
1196 fc_config->ibat_lmt,
1197 fc_config->vbat_now,
1198 fc_config->ibat_now,
1199 cm->cp.ibat_curr,
1200 cm->cp.vbat_volt,
1201 fc_config->vbus_cp_lmt,
1202 fc_config->ibus_cp_lmt,
1203 fc_config->vbus_cp,
1204 fc_config->ibus_cp,
1205 fc_config->ibus_lmt,
1206 fc_config->adapter_volt_max_lmt,
1207 fc_config->adapter_curr_max_lmt,
1208 fc_config->adapter_curr_required,
1209 fc_config->adapter_volt_required,
1210 fc_config->adaper_power_lmt,
1211 fc_config->cable_resistance);
1212
1213 CM_DBG("sw_input_current: %d\n"
1214 "sw_charge_current: %d\n"
1215 "sw_charge_voltage: %d\n"
1216 "sw_charge_status: %d\n"
1217 "sw_ovp_flag:%d\n"
1218 "sw_charge_current_max: %d\n",
1219 fc_config->sw_input_current,
1220 fc_config->sw_charge_current,
1221 fc_config->sw_charge_voltage,
1222 fc_config->sw_charge_status,
1223 fc_config->sw_ovp_flag,
1224 fc_config->sw_charge_current_max);
1225 return 0;
1226 }
1227
cm_charge_pump_algo(struct charger_manager * cm)1228 static int cm_charge_pump_algo(struct charger_manager *cm)
1229 {
1230 struct fastcharge_config *fc_config;
1231 int step_ibus_total = 0;
1232 int sw_ctrl_steps = 0;
1233 int hw_ctrl_steps = 1;
1234 int step_bat_reg = 0;
1235 int step_vbat = 0;
1236 int step_ibus = 0;
1237 int step_ibat = 0;
1238 int ibus_total = 0;
1239 int fc2_steps = 1;
1240 int step_ui = 0;
1241 int ibus_limit;
1242 int steps;
1243
1244 fc_config = cm->fc_config;
1245
1246 /* battery voltage loop*/
1247 if (fc_config->vbat_now > fc_config->vbat_lmt - FC_VOLTAGE_THRESHOLD_VALUE)
1248 step_vbat = -fc2_steps;
1249 else if (fc_config->vbat_now < fc_config->vbat_lmt - FC_VOLTAGE_THRESHOLD_VALUE - 10 * 1000)
1250 step_vbat = fc2_steps;
1251
1252 /* battery charge current loop*/
1253 if (fc_config->ibat_now < fc_config->ibat_lmt - 100 * 1000)
1254 step_ibat = fc2_steps;
1255 else if (fc_config->ibat_now > fc_config->ibat_lmt)
1256 step_ibat = -fc2_steps;
1257
1258 /* bus total current loop */
1259 ibus_limit = fc_config->adapter_curr_required; /* fc_config->ibus_lmt ; */
1260 ibus_total = fc_config->ibus_cp + fc_config->ibus_dcdc_lmt;/* CP + DCDC */
1261 if (ibus_total < ibus_limit - FC_CURRENT_STEP)
1262 step_ibus_total = fc2_steps;
1263 else if (ibus_total > ibus_limit)
1264 step_ibus_total = -fc2_steps;
1265 CM_DBG("ibus_limit: %d cm->cp.ibus_max: %d\n", ibus_limit, cm->cp.ibus_max);
1266
1267 /* bus current loop*/
1268 /* charge pump bus current loop */
1269 if (fc_config->ibus_cp < fc_config->adapter_curr_required - fc_config->ibus_dcdc_lmt - 100 * 1000)
1270 step_ibus = fc2_steps;
1271 else if (fc_config->ibus_cp > fc_config->adapter_curr_required - fc_config->ibus_dcdc_lmt)
1272 step_ibus = -fc2_steps;
1273
1274 if (cm->cp.ibus_curr > fc_config->ibus_cp_lmt)
1275 step_ibus = 0;
1276 CM_DBG("cm->cp.ibus_curr: %d,: fc_config->ibus_cp_lmt%d\n",
1277 cm->cp.ibus_curr, fc_config->ibus_cp_lmt);
1278 /* the adaper voltage loop */
1279 if (cm->cp.request_voltage + FC_VOLTAGE_STEP < fc_config->adapter_volt_max_lmt)
1280 step_bat_reg = fc2_steps;
1281
1282 /* the adapter power negotiation loop*/
1283 if ((fc_config->adapter_volt_required / 1000) * (fc_config->adapter_curr_required / 1000) <= fc_config->adaper_power_lmt)
1284 step_ui = fc2_steps;
1285 else
1286 cm->cp.request_current -= FC_CURRENT_STEP;
1287
1288 cm->cp.request_current = min(fc_config->adapter_curr_max_lmt, cm->cp.request_current);
1289
1290 sw_ctrl_steps = min(min(step_vbat, step_ibus), min(step_ibat, step_ibus_total));
1291 sw_ctrl_steps = min(sw_ctrl_steps, min(step_bat_reg, step_ui));
1292
1293 /* hardware alarm loop */
1294 if (cm->cp.bat_ocp_alarm
1295 || cm->cp.bus_ocp_alarm || cm->cp.bus_ovp_alarm)
1296 hw_ctrl_steps = -fc2_steps;
1297 else
1298 hw_ctrl_steps = fc2_steps;
1299
1300 if (cm->cp.bat_therm_fault || !fc_config->jeita_enable_charge) {
1301 /* battery overheat, stop charge*/
1302 CM_DBG("bat_therm_fault:%d, jeita_enable_charge: %d\n",
1303 cm->cp.bat_therm_fault, fc_config->jeita_enable_charge);
1304 return PM_ALGO_RET_THERM_FAULT;
1305 } else if (cm->cp.bat_ocp_fault || cm->cp.bus_ocp_fault ||
1306 cm->cp.bat_ovp_fault || cm->cp.bus_ovp_fault) {
1307 CM_DBG("bat_ocp_fault:%d\n"
1308 "bus_ocp_fault:%d\n"
1309 "bat_ovp_fault:%d\n"
1310 "bus_ovp_fault:%d\n",
1311 cm->cp.bat_ocp_fault,
1312 cm->cp.bus_ocp_fault,
1313 cm->cp.bat_ovp_fault,
1314 cm->cp.bus_ovp_fault);
1315
1316 return PM_ALGO_RET_OTHER_FAULT;
1317 } else if (cm->cp.vbus_error_low || cm->cp.vbus_error_high) {
1318 /* go to switch, and try to ramp up*/
1319 pr_info("cp.charge_enabled:%d %d %d\n",
1320 cm->cp.charge_enabled, cm->cp.vbus_error_low, cm->cp.vbus_error_high);
1321 return PM_ALGO_RET_CHG_DISABLED;
1322 }
1323
1324 /* charge pump taper charge */
1325 if ((fc_config->vbat_now > (fc_config->vbat_lmt - FC_VOLTAGE_THRESHOLD_VALUE - FC_VOLTAGE_STEP)) &&
1326 (fc_config->ibus_cp < fc_config->fc_taper_current)) {
1327 if (cm->fc2_taper_timer++ > TAPER_TIMEOUT) {
1328 CM_DBG("charge pump taper charging done\n");
1329 cm->fc2_taper_timer = 0;
1330 return PM_ALGO_RET_TAPER_DONE;
1331 }
1332 } else {
1333 cm->fc2_taper_timer = 0;
1334 }
1335
1336 steps = min(sw_ctrl_steps, hw_ctrl_steps);
1337 cm->cp.request_voltage += steps * FC_VOLTAGE_STEP;
1338
1339 CM_DBG(">>>>>>step_bat_reg: %d\n", step_bat_reg);
1340 CM_DBG(">>>>>>step_vbat: %d\n", step_vbat);
1341 CM_DBG(">>>>>>step_ibat: %d\n", step_ibat);
1342 CM_DBG(">>>>>>step_ibus: %d\n", step_ibus);
1343 CM_DBG(">>>>>>step_ibus_total: %d\n", step_ibus_total);
1344 CM_DBG(">>>>>>step_ui: %d\n", step_ui);
1345 CM_DBG(">>>>>>sw_ctrl_steps: %d\n", sw_ctrl_steps);
1346 CM_DBG(">>>>>>hw_ctrl_steps: %d\n", hw_ctrl_steps);
1347 CM_DBG(">>>>>>steps: %d\n", steps);
1348 CM_DBG(">>>>>>%d %d %d %d sw %d hw %d all %d\n",
1349 step_bat_reg, step_vbat, step_ibat,
1350 step_ibus, sw_ctrl_steps, hw_ctrl_steps, steps);
1351 CM_DBG(">>>>>> cm->cp.charge_enabled: %d\n", cm->cp.charge_enabled);
1352
1353 return PM_ALGO_RET_OK;
1354 }
1355
cm_sw_fast_charge_algo(struct charger_manager * cm)1356 static void cm_sw_fast_charge_algo(struct charger_manager *cm)
1357 {
1358 struct fastcharge_config *fc_config;
1359 /* over-temperature protection */
1360 int step_otp_charge = 0;
1361 /* over-current protection */
1362 int step_ocp_charge = 0;
1363 /* over-voltage protection */
1364 int step_ovp_charge = 0;
1365 int charge_voltage;
1366 int charge_current;
1367 int sw_fc_steps = 1;
1368 int steps;
1369 int ret;
1370
1371 fc_config = cm->fc_config;
1372
1373 if (fc_config->jeita_charge_support && !fc_config->jeita_enable_charge)
1374 step_otp_charge = -sw_fc_steps;
1375 else
1376 step_otp_charge = sw_fc_steps;
1377
1378 if (fc_config->ibat_lmt / 2 < cm->cp.request_current)
1379 step_ocp_charge = -sw_fc_steps;
1380 else
1381 step_ocp_charge = sw_fc_steps;
1382
1383 if (fc_config->sw_ovp_flag == 1) {
1384 if (fc_config->vbat_now >= fc_config->vbat_lmt)/* FC_VOLTAGE_THRESHOLD_VALUE */
1385 step_ovp_charge = -sw_fc_steps;
1386 else
1387 step_ovp_charge = 0;
1388 } else
1389 step_ovp_charge = sw_fc_steps;
1390
1391 if (fc_config->jeita_charge_support)
1392 charge_current = min(min(fc_config->jeita_charge_current, fc_config->ibat_lmt),
1393 fc_config->sw_charge_current);
1394 else
1395 charge_current = min(fc_config->ibat_lmt, fc_config->sw_charge_current);
1396
1397 charge_voltage = fc_config->vbat_lmt + 200 * 1000;
1398 ret = set_sw_charger_voltage(cm, charge_voltage);
1399 if (ret)
1400 return;
1401
1402 steps = min(min(step_otp_charge, step_ocp_charge), step_ovp_charge);
1403 charge_current += steps * SW_FC_CURRENT_STEP;
1404 CM_DBG(">>>>>>charge_current: %d\n", charge_current);
1405
1406 if ((fc_config->sw_charge_current >= SW_FC_CURRENT_STEP) &&
1407 (charge_current <= fc_config->sw_charge_current_max)) {
1408 fc_config->sw_charge_current = charge_current;
1409 if (steps == 1) {
1410 ret = set_sw_charger_enable(cm);
1411 if (ret)
1412 return;
1413 }
1414 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1415 if (ret)
1416 return;
1417
1418 } else {
1419 if (charge_current < SW_FC_CURRENT_STEP) {
1420 ret = set_sw_charger_disable(cm);
1421 if (ret)
1422 return;
1423 }
1424 }
1425 CM_DBG(">>>>>>>fast_charge_algo:setp: %d\n"
1426 ">>>>>> step_otp_charge: %d\n"
1427 ">>>>>>>step_ocp_charge: %d\n"
1428 ">>>>>>>step_ovp_charge: %d\n"
1429 ">>>>>>>sw_charge_status: %d\n",
1430 steps,
1431 step_otp_charge,
1432 step_ocp_charge,
1433 step_ovp_charge,
1434 fc_config->sw_charge_status);
1435 }
1436
cm_charge_pump_sm(struct charger_manager * cm)1437 static int cm_charge_pump_sm(struct charger_manager *cm)
1438 {
1439 struct power_supply_battery_info info;
1440 struct fastcharge_config *fc_config;
1441 union power_supply_propval val;
1442 static int tune_vbus_retry;
1443 int vbus_volt_init_up = 0;
1444 int adapter_volt_max;
1445 static bool recover;
1446 int bat_voltage;
1447 int bat_res = 0;
1448 int ibat_max;
1449 int ret;
1450
1451 info = cm->desc->info;
1452 fc_config = cm->fc_config;
1453 switch (cm->state) {
1454 case PPS_PM_STATE_ENTRY:
1455 recover = false;
1456 if (fc_config->jeita_charge_support && !fc_config->jeita_enable_charge) {
1457 CM_DBG("the temperature: %d.%d\n", fc_config->jeita_temperature / 10,
1458 fc_config->jeita_temperature % 10);
1459 ret = power_supply_get_property(cm->desc->tcpm_psy,
1460 POWER_SUPPLY_PROP_CURRENT_MAX,
1461 &val);
1462 if (ret) {
1463 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_VOLTAGE_MAX\n", __LINE__);
1464 return ret;
1465 }
1466 ret = set_sw_charger_input_limit_current(cm, val.intval);
1467 if (ret)
1468 return ret;
1469 if (cm->fc_config->sw_charge_status) {
1470 ret = set_sw_charger_disable(cm);
1471 if (ret)
1472 return ret;
1473 }
1474 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_JEITA);
1475 cm->desc->polling_interval_ms = 3000;
1476 return 0;
1477 }
1478
1479 if (fc_config->jeita_charge_support) {
1480 ret = set_sw_charger_voltage(cm, fc_config->vbat_lmt);
1481 if (ret)
1482 return ret;
1483 fc_config->sw_charge_current = min(fc_config->jeita_charge_current,
1484 fc_config->sw_charge_current_max);
1485 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1486 if (ret)
1487 return ret;
1488
1489 if (!cm->fc_config->sw_charge_status) {
1490 ret = set_sw_charger_enable(cm);
1491 if (ret)
1492 return ret;
1493 }
1494 } else {
1495 ret = set_sw_charger_voltage(cm, fc_config->vbat_lmt);
1496 if (ret)
1497 return ret;
1498 fc_config->sw_charge_current = fc_config->sw_charge_current_max;
1499 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1500 if (ret)
1501 return ret;
1502
1503 if (!cm->fc_config->sw_charge_status) {
1504 ret = set_sw_charger_enable(cm);
1505 if (ret)
1506 return ret;
1507 }
1508 }
1509
1510 if (cm->cp.vbat_volt < info.precharge_voltage_max_uv) {
1511 ret = power_supply_get_property(cm->desc->tcpm_psy,
1512 POWER_SUPPLY_PROP_CURRENT_MAX,
1513 &val);
1514 if (ret) {
1515 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
1516 return ret;
1517 }
1518 ret = set_sw_charger_input_limit_current(cm, val.intval);
1519 if (ret)
1520 return ret;
1521 CM_DBG("batt_volt-%d, waiting... > %d\n",
1522 cm->cp.vbat_volt, info.precharge_voltage_max_uv);
1523 } else if (cm->cp.vbat_volt > cm->fc_config->vbat_lmt - 100 * 1000) {
1524 pr_info("batt_volt-%d is too high for cp, charging with switch charger(%duv)\n",
1525 cm->cp.vbat_volt, cm->fc_config->vbat_lmt - 100 * 1000);
1526 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_EXIT);
1527 } else {
1528 pr_info("batt_volt-%d is ok, start flash charging\n",
1529 cm->cp.vbat_volt);
1530
1531 cm->desc->polling_interval_ms = 300;
1532
1533 val.intval = 2;
1534 ret = power_supply_set_property(cm->desc->tcpm_psy,
1535 POWER_SUPPLY_PROP_ONLINE,
1536 &val);
1537 if (ret) {
1538 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_ONLINE\n", __LINE__);
1539 return ret;
1540 }
1541 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_ENTRY);
1542 }
1543 break;
1544 case PPS_PM_STATE_FC_ENTRY:
1545 CM_DBG("PPS_PM_STATE_FC_ENTRY:\n");
1546 ret = set_sw_charger_input_limit_current(cm, USB_PPS_INPUT_CURRENT);
1547 if (ret)
1548 return ret;
1549 mdelay(10);
1550 ret = power_supply_get_property(cm->desc->tcpm_psy,
1551 POWER_SUPPLY_PROP_CURRENT_MAX,
1552 &val);
1553 if (ret) {
1554 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
1555 return ret;
1556 }
1557 CM_DBG("CURRENT_MAX:%d\n", val.intval);
1558
1559 cm->cp.request_current = min(cm->cp.ibus_max + fc_config->ibus_dcdc_lmt, val.intval);
1560
1561 bat_voltage = fc_config->vbat_now - fc_config->ibat_now / 1000 * info.factory_internal_resistance_uohm;
1562 ibat_max = min(fc_config->ibat_lmt, 2 * cm->cp.request_current);
1563 vbus_volt_init_up = ibat_max / 1000 * info.factory_internal_resistance_uohm;
1564 /* cm->cp.request_voltage = bat_voltage * 2 + 2 * vbus_volt_init_up + ibat_max / 2 * 100 / 1000; */
1565 cm->cp.request_voltage = bat_voltage * 2 + 15 * vbus_volt_init_up / 10 + ibat_max / 2 * 100 / 1000;
1566
1567 CM_DBG("cm->cp.request_voltage: %d cm->cp.vbat_volt: %d, vbus_volt_init_up: %d, bat_voltage: %d\n",
1568 cm->cp.request_voltage, cm->cp.vbat_volt, vbus_volt_init_up, bat_voltage);
1569
1570 adapter_volt_max = fc_config->adaper_power_lmt / (cm->cp.request_current / 1000);
1571 cm->cp.request_voltage = min(cm->cp.request_voltage, adapter_volt_max * 1000);
1572
1573 ret = set_sw_charger_voltage(cm, cm->fc_config->vbat_lmt + 200 * 1000);
1574 if (ret)
1575 return ret;
1576 if (fc_config->jeita_charge_support) {
1577 fc_config->sw_charge_current = min(fc_config->jeita_charge_current,
1578 fc_config->sw_charge_current_max);
1579 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1580 if (ret)
1581 return ret;
1582 }
1583 if ((fc_config->jeita_charge_support && !fc_config->jeita_enable_charge) ||
1584 (fc_config->ibat_lmt / 2 < cm->cp.request_current) ||
1585 (fc_config->sw_ovp_flag)) {
1586 CM_DBG("PPS_PM_STATE_ENTRY: disable SW charge\n");
1587 if (cm->fc_config->sw_charge_status) {
1588 ret = set_sw_charger_disable(cm);
1589 if (ret)
1590 return ret;
1591 }
1592 } else {
1593 CM_DBG("PPS_PM_STATE_ENTRY: enable SW charge\n");
1594 if (!cm->fc_config->sw_charge_status &&
1595 fc_config->jeita_charge_support &&
1596 fc_config->jeita_enable_charge) {
1597 ret = set_sw_charger_enable(cm);
1598 if (ret)
1599 return ret;
1600 }
1601 }
1602
1603 val.intval = cm->cp.request_voltage;
1604 ret = power_supply_set_property(cm->desc->tcpm_psy,
1605 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1606 &val);
1607 if (ret) {
1608 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_VOLTAGE_NOW\n", __LINE__);
1609 return ret;
1610 }
1611
1612 val.intval = cm->cp.request_current;
1613 ret = power_supply_set_property(cm->desc->tcpm_psy,
1614 POWER_SUPPLY_PROP_CURRENT_NOW,
1615 &val);
1616 if (ret) {
1617 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_CURRENT_NOW\n", __LINE__);
1618 return ret;
1619 }
1620 CM_DBG("request_voltage:%d, request_current:%d\n",
1621 cm->cp.request_voltage, cm->cp.request_current);
1622
1623 if (!cm->cp.charge_enabled) {
1624 ret = set_cp_enable(cm);
1625 if (ret)
1626 return ret;
1627 }
1628 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_ENTRY_1);
1629 cm->desc->polling_interval_ms = 300;
1630 tune_vbus_retry = 0;
1631
1632 break;
1633 case PPS_PM_STATE_FC_ENTRY_1:
1634 CM_DBG("PPS_PM_STATE_FC_ENTRY_1: old cm->cp.request_voltage: %d\n",
1635 cm->cp.request_voltage);
1636 ret = set_sw_charger_input_limit_current(cm, USB_PPS_INPUT_CURRENT);
1637 if (ret)
1638 return ret;
1639
1640 cm->cp.request_voltage += cm->cp.request_voltage - cm->cp.vbus_volt;
1641
1642 adapter_volt_max = fc_config->adaper_power_lmt / (cm->cp.request_current / 1000);
1643 cm->cp.request_voltage = min(cm->cp.request_voltage, adapter_volt_max * 1000);
1644 ret = set_sw_charger_voltage(cm, cm->fc_config->vbat_lmt + 200 * 1000);
1645 if (ret)
1646 return ret;
1647 if (fc_config->jeita_charge_support) {
1648 fc_config->sw_charge_current = min(fc_config->jeita_charge_current,
1649 fc_config->sw_charge_current_max);
1650 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1651 if (ret)
1652 return ret;
1653 }
1654 if ((fc_config->jeita_charge_support && !fc_config->jeita_enable_charge) ||
1655 (fc_config->ibat_lmt / 2 < cm->cp.request_current) ||
1656 (fc_config->sw_ovp_flag)) {
1657 CM_DBG("PPS_PM_STATE_ENTRY: disable SW charge\n");
1658 if (cm->fc_config->sw_charge_status) {
1659 ret = set_sw_charger_disable(cm);
1660 if (ret)
1661 return ret;
1662 }
1663 } else {
1664 CM_DBG("PPS_PM_STATE_ENTRY: enable SW charge\n");
1665 if (!cm->fc_config->sw_charge_status &&
1666 fc_config->jeita_charge_support &&
1667 fc_config->jeita_enable_charge) {
1668 ret = set_sw_charger_enable(cm);
1669 if (ret)
1670 return ret;
1671 }
1672 }
1673
1674 val.intval = cm->cp.request_voltage;
1675 ret = power_supply_set_property(cm->desc->tcpm_psy,
1676 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1677 &val);
1678 if (ret) {
1679 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_VOLTAGE_NOW\n", __LINE__);
1680 return ret;
1681 }
1682 val.intval = cm->cp.request_current;
1683 ret = power_supply_set_property(cm->desc->tcpm_psy,
1684 POWER_SUPPLY_PROP_CURRENT_NOW,
1685 &val);
1686 if (ret) {
1687 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_CURRENT_NOW\n", __LINE__);
1688 return ret;
1689 }
1690 cm->desc->polling_interval_ms = 300;
1691 CM_DBG("PPS_PM_STATE_FC_ENTRY_1: request_voltage:%d, request_current:%d\n",
1692 cm->cp.request_voltage, cm->cp.request_current);
1693 CM_DBG("PPS_PM_STATE_FC_ENTRY_1: cm->cp.vbus_volt: %d vbus_volt_init_up: %d\n"
1694 "bat_res: %d, factory_internal_resistance_uohm: %d\n",
1695 cm->cp.vbus_volt, vbus_volt_init_up, bat_res,
1696 info.factory_internal_resistance_uohm);
1697 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_ENTRY_2);
1698 break;
1699 case PPS_PM_STATE_FC_ENTRY_2:
1700 CM_DBG("PPS_PM_STATE_FC_ENTRY_2: request_voltage:%d,vbus_volt: %d, %d\n",
1701 cm->cp.request_voltage, cm->cp.vbus_volt, cm->cp.vbat_volt);
1702 ret = set_sw_charger_input_limit_current(cm, USB_PPS_INPUT_CURRENT);
1703 if (ret)
1704 return ret;
1705 ret = set_sw_charger_voltage(cm, cm->fc_config->vbat_lmt + 200 * 1000);
1706 if (ret)
1707 return ret;
1708 if (fc_config->jeita_charge_support) {
1709 fc_config->sw_charge_current = min(fc_config->jeita_charge_current,
1710 fc_config->sw_charge_current_max);
1711 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1712 if (ret)
1713 return ret;
1714 }
1715 if ((fc_config->jeita_charge_support && !fc_config->jeita_enable_charge) ||
1716 (fc_config->ibat_lmt / 2 < cm->cp.request_current) ||
1717 (fc_config->sw_ovp_flag)) {
1718 CM_DBG("PPS_PM_STATE_ENTRY: disable SW charge\n");
1719 if (cm->fc_config->sw_charge_status) {
1720 ret = set_sw_charger_disable(cm);
1721 if (ret)
1722 return ret;
1723 }
1724 } else {
1725 CM_DBG("PPS_PM_STATE_ENTRY: enable SW charge\n");
1726 if (!cm->fc_config->sw_charge_status &&
1727 fc_config->jeita_charge_support &&
1728 fc_config->jeita_enable_charge) {
1729 ret = set_sw_charger_enable(cm);
1730 if (ret)
1731 return ret;
1732 }
1733 }
1734
1735 if (cm->cp.vbus_error_low) {
1736 tune_vbus_retry++;
1737 cm->cp.request_voltage += FC_VOLTAGE_STEP * 2;
1738
1739 val.intval = cm->cp.request_voltage;
1740 ret = power_supply_set_property(cm->desc->tcpm_psy,
1741 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1742 &val);
1743 if (ret) {
1744 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_VOLTAGE_NOW\n", __LINE__);
1745 return ret;
1746 }
1747 ret = set_cp_enable(cm);
1748 if (ret)
1749 return ret;
1750 CM_DBG("vbus_error_low: request_voltage:%d, request_current:%d\n",
1751 cm->cp.request_voltage, cm->cp.request_current);
1752 } else if (cm->cp.vbus_error_high) {
1753 tune_vbus_retry++;
1754 cm->cp.request_voltage -= FC_VOLTAGE_STEP * 2;
1755 val.intval = cm->cp.request_voltage;
1756 ret = power_supply_set_property(cm->desc->tcpm_psy,
1757 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1758 &val);
1759 if (ret) {
1760 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_VOLTAGE_NOW\n", __LINE__);
1761 return ret;
1762 }
1763 ret = set_cp_enable(cm);
1764 if (ret)
1765 return ret;
1766 CM_DBG("vbus_error_high: request_voltage:%d, request_current:%d\n",
1767 cm->cp.request_voltage, cm->cp.request_current);
1768 } else {
1769 CM_DBG("adapter volt tune ok, retry %d times\n", tune_vbus_retry);
1770 cm->fc2_taper_timer = 0;
1771 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_TUNE);
1772 break;
1773 }
1774 if (tune_vbus_retry > 25) {
1775 CM_DBG("Failed to tune adapter volt into valid range.\n");
1776 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_EXIT);
1777 }
1778 cm->desc->polling_interval_ms = 100;
1779 break;
1780
1781 case PPS_PM_STATE_FC_TUNE:
1782 CM_DBG("PPS_PM_STATE_FC_TUNE:\n");
1783 ret = set_sw_charger_input_limit_current(cm, USB_PPS_INPUT_CURRENT);
1784 if (ret)
1785 return ret;
1786 ret = cm_charge_pump_algo(cm);
1787 if (ret == PM_ALGO_RET_THERM_FAULT) {
1788 CM_DBG("Move to stop charging\n");
1789 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_JEITA);
1790 } else if (ret == PM_ALGO_RET_OTHER_FAULT || ret == PM_ALGO_RET_TAPER_DONE) {
1791 CM_DBG("Move to switch charging\n");
1792 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_EXIT);
1793 } else if (ret == PM_ALGO_RET_CHG_DISABLED) {
1794 CM_DBG("Move to switch charging, will try to recover flash charging\n");
1795 recover = true;
1796 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_EXIT);
1797 } else {
1798 if (!cm->cp.charge_enabled) {
1799 ret = set_cp_enable(cm);
1800 if (ret)
1801 return ret;
1802 }
1803
1804 cm_sw_fast_charge_algo(cm);
1805 cm->cp.request_voltage = min(cm->cp.request_voltage, cm->cp.vbus_max);
1806
1807 CM_DBG("cm->cp.vbat_volt: %d\n", cm->cp.vbat_volt);
1808 val.intval = cm->cp.request_voltage;
1809 CM_DBG("cm->cp.request_voltage: %d\n", cm->cp.request_voltage);
1810 ret = power_supply_set_property(cm->desc->tcpm_psy,
1811 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1812 &val);
1813 if (ret) {
1814 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_VOLTAGE_NOW\n", __LINE__);
1815 return ret;
1816 }
1817 val.intval = cm->cp.request_current;
1818 ret = power_supply_set_property(cm->desc->tcpm_psy,
1819 POWER_SUPPLY_PROP_CURRENT_NOW,
1820 &val);
1821 if (ret) {
1822 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_NOW\n", __LINE__);
1823 return ret;
1824 }
1825 cm->desc->polling_interval_ms = 1000;
1826 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_TUNE);
1827 }
1828 break;
1829 case PPS_PM_STATE_FC_JEITA:
1830 CM_DBG("PPS_PM_STATE_FC_JEITA:%d\n", cm->fc_config->jeita_temperature);
1831
1832 if (!cm->cp.charge_enabled) {
1833 ret = power_supply_get_property(cm->desc->tcpm_psy,
1834 POWER_SUPPLY_PROP_CURRENT_MAX,
1835 &val);
1836 if (ret) {
1837 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
1838 return ret;
1839 }
1840 ret = set_sw_charger_input_limit_current(cm, val.intval);
1841 if (ret)
1842 return ret;
1843 }
1844
1845 if (!cm->fc_config->jeita_enable_charge && cm->cp.charge_enabled) {
1846 ret = set_cp_disable(cm);
1847 if (ret)
1848 return ret;
1849 if (cm->fc_config->sw_charge_status) {
1850 ret = set_sw_charger_disable(cm);
1851 if (ret)
1852 return ret;
1853 }
1854 ret = set_sw_charger_voltage(cm, cm->fc_config->vbat_lmt);
1855 if (ret)
1856 return ret;
1857 if (fc_config->jeita_charge_support) {
1858 fc_config->sw_charge_current = min(fc_config->jeita_charge_current,
1859 fc_config->sw_charge_current_max);
1860 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1861 if (ret)
1862 return ret;
1863 }
1864 val.intval = 1;
1865 ret = power_supply_set_property(cm->desc->tcpm_psy,
1866 POWER_SUPPLY_PROP_ONLINE,
1867 &val);
1868 if (ret) {
1869 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_ONLINE\n", __LINE__);
1870 return ret;
1871 }
1872 cm_charge_pump_move_state(cm, PPS_PM_STATE_FC_JEITA);
1873 }
1874
1875 if (cm->fc_config->jeita_enable_charge) {
1876 CM_DBG("EXIT PPS_PM_STATE_FC_JEITA:%d\n", cm->fc_config->jeita_temperature);
1877 cm_charge_pump_move_state(cm, PPS_PM_STATE_ENTRY);
1878 }
1879 break;
1880 case PPS_PM_STATE_FC_EXIT:
1881 CM_DBG("PPS_PM_STATE_FC_EXIT:\n");
1882 if (cm->cp.charge_enabled) {
1883 ret = set_cp_disable(cm);
1884 if (ret)
1885 return ret;
1886 if (cm->fc_config->sw_charge_status) {
1887 ret = set_sw_charger_disable(cm);
1888 if (ret)
1889 return ret;
1890 }
1891 ret = set_sw_charger_voltage(cm, cm->fc_config->vbat_lmt);
1892 if (ret)
1893 return ret;
1894 if (fc_config->jeita_charge_support) {
1895 fc_config->sw_charge_current = min(fc_config->jeita_charge_current,
1896 fc_config->sw_charge_current_max);
1897 ret = set_sw_charger_current(cm, fc_config->sw_charge_current);
1898 if (ret)
1899 return ret;
1900 }
1901 if ((!cm->fc_config->sw_charge_status) &&
1902 (fc_config->jeita_charge_support && fc_config->jeita_enable_charge)) {
1903 ret = set_sw_charger_enable(cm);
1904 if (ret)
1905 return ret;
1906 }
1907 } else {
1908 ret = power_supply_get_property(cm->desc->tcpm_psy,
1909 POWER_SUPPLY_PROP_CURRENT_MAX,
1910 &val);
1911 if (ret) {
1912 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
1913 return ret;
1914 }
1915 ret = set_sw_charger_input_limit_current(cm, val.intval);
1916 if (ret)
1917 return ret;
1918 }
1919
1920 val.intval = 1;
1921 ret = power_supply_set_property(cm->desc->tcpm_psy,
1922 POWER_SUPPLY_PROP_ONLINE,
1923 &val);
1924 if (ret) {
1925 dev_err(cm->dev, "[%d] failed to set POWER_SUPPLY_PROP_ONLINE\n", __LINE__);
1926 return ret;
1927 }
1928 if (recover)
1929 cm_charge_pump_move_state(cm, PPS_PM_STATE_ENTRY);
1930 break;
1931
1932 }
1933 return 0;
1934 }
1935 static void cm_disable_charge(struct charger_manager *cm);
1936 /**
1937 * _cm_monitor - Monitor the temperature and return true for exceptions.
1938 * @cm: the Charger Manager representing the battery.
1939 *
1940 * Returns true if there is an event to notify for the battery.
1941 * (True if the status of "emergency_stop" changes)
1942 */
_cm_monitor(struct charger_manager * cm)1943 static void _cm_monitor(struct charger_manager *cm)
1944 {
1945 int ret;
1946
1947 cm_update_charge_pump_status(cm);
1948 cm_update_jeita_charge_info(cm);
1949 ret = cm_charge_limit_update(cm);
1950 if (ret || cm->fc_config->fc_charge_error) {
1951 cm_disable_charge(cm);
1952 return;
1953 }
1954
1955 ret = cm_charge_pump_sm(cm);
1956 if (ret || cm->fc_config->fc_charge_error)
1957 cm_disable_charge(cm);
1958 }
1959
1960 /**
1961 * _setup_polling - Setup the next instance of polling.
1962 * @work: work_struct of the function _setup_polling.
1963 */
_setup_polling(struct charger_manager * cm)1964 static void _setup_polling(struct charger_manager *cm)
1965 {
1966 unsigned long polling_jiffy = ULONG_MAX; /* ULONG_MAX: no polling */
1967 unsigned long min = ULONG_MAX;
1968 bool keep_polling = false;
1969 unsigned long _next_polling;
1970
1971 if ((is_polling_required(cm) && cm->desc->polling_interval_ms) ||
1972 (cm->attached && cm->fc_charger_enabled)) {
1973 CM_DBG("cm->attached: %d\n", cm->attached);
1974 keep_polling = true;
1975
1976 if (min > cm->desc->polling_interval_ms)
1977 min = cm->desc->polling_interval_ms;
1978 }
1979
1980 CM_DBG("keep_polling: %d\n", keep_polling);
1981 polling_jiffy = msecs_to_jiffies(min);
1982 if (polling_jiffy <= CM_JIFFIES_SMALL)
1983 polling_jiffy = CM_JIFFIES_SMALL + 1;
1984
1985 if (!keep_polling)
1986 polling_jiffy = ULONG_MAX;
1987
1988 if (polling_jiffy == ULONG_MAX)
1989 goto out;
1990
1991 WARN(cm->cm_wq == NULL, "rockchip-charger-manager: workqueue not initialized\n");
1992
1993 /*
1994 * Use mod_delayed_work() iff the next polling interval should
1995 * occur before the currently scheduled one. If @cm_monitor_work
1996 * isn't active, the end result is the same, so no need to worry
1997 * about stale @next_polling.
1998 */
1999 _next_polling = jiffies + polling_jiffy;
2000
2001 if (time_before(_next_polling, cm->next_polling)) {
2002 queue_delayed_work(cm->cm_wq, &cm->cm_monitor_work, polling_jiffy);
2003 cm->next_polling = _next_polling;
2004 } else {
2005 if (queue_delayed_work(cm->cm_wq, &cm->cm_monitor_work, polling_jiffy))
2006 cm->next_polling = _next_polling;
2007 }
2008 out:
2009 return;
2010 }
2011
2012 /**
2013 * cm_monitor_poller - The Monitor / Poller.
2014 * @work: work_struct of the function cm_monitor_poller
2015 *
2016 * During non-suspended state, cm_monitor_poller is used to
2017 * poll and monitor the batteries.
2018 */
cm_monitor_poller(struct work_struct * work)2019 static void cm_monitor_poller(struct work_struct *work)
2020 {
2021 struct charger_manager *cm = container_of(work,
2022 struct charger_manager,
2023 cm_monitor_work.work);
2024
2025 _cm_monitor(cm);
2026 _setup_polling(cm);
2027 }
2028
cm_jeita_poller(struct work_struct * work)2029 static void cm_jeita_poller(struct work_struct *work)
2030 {
2031 struct charger_manager *cm = container_of(work,
2032 struct charger_manager,
2033 cm_jeita_work.work);
2034 static int status = CM_JEITA_GOOD;
2035 int ret;
2036
2037 cm_update_jeita_charge_info(cm);
2038 ret = get_sw_charger_current_max(cm, &cm->fc_config->sw_charge_current_max);
2039 if (ret)
2040 return;
2041 if (cm->fc_config->jeita_status != status) {
2042 ret = set_sw_charger_voltage(cm, cm->fc_config->jeita_charge_voltage);
2043 if (ret)
2044 return;
2045 if ((cm->fc_config->jeita_status == CM_JEITA_COLD) ||
2046 (cm->fc_config->jeita_status == CM_JEITA_HOT)) {
2047 if (cm->fc_config->sw_charge_status) {
2048 ret = set_sw_charger_disable(cm);
2049 if (ret)
2050 return;
2051 }
2052 } else {
2053 cm->fc_config->sw_charge_current = min(cm->fc_config->jeita_charge_current,
2054 cm->fc_config->sw_charge_current_max);
2055 ret = set_sw_charger_current(cm, cm->fc_config->sw_charge_current);
2056 if (ret)
2057 return;
2058 if (!cm->fc_config->sw_charge_status) {
2059 ret = set_sw_charger_enable(cm);
2060 if (ret)
2061 return;
2062 }
2063 }
2064 status = cm->fc_config->jeita_status;
2065 } else {
2066 ret = set_sw_charger_voltage(cm, cm->fc_config->jeita_charge_voltage);
2067 if (ret)
2068 return;
2069 cm->fc_config->sw_charge_current = min(cm->fc_config->jeita_charge_current,
2070 cm->fc_config->sw_charge_current_max);
2071 ret = set_sw_charger_current(cm, cm->fc_config->sw_charge_current);
2072 if (ret)
2073 return;
2074
2075 if (!cm->fc_config->sw_charge_status && cm->fc_config->jeita_enable_charge) {
2076 ret = set_sw_charger_enable(cm);
2077 if (ret)
2078 return;
2079 }
2080 }
2081
2082 if (cm->attached)
2083 queue_delayed_work(cm->cm_wq,
2084 &cm->cm_jeita_work,
2085 msecs_to_jiffies(5 * 1000));
2086 else
2087 status = CM_JEITA_GOOD;
2088 }
2089
2090 /**
2091 * charger_extcon_work - enable/disable charger according to
2092 * the state of charger cable
2093 *
2094 * @work: work_struct of the function charger_extcon_work.
2095 */
charger_extcon_work(struct work_struct * work)2096 static void charger_extcon_work(struct work_struct *work)
2097 {
2098 struct charger_manager *cm = container_of(work,
2099 struct charger_manager,
2100 wq);
2101
2102 cancel_delayed_work(&cm->cm_monitor_work);
2103 queue_delayed_work(cm->cm_wq, &cm->cm_monitor_work, 0);
2104 }
2105
2106 /**
2107 * charger_extcon_notifier - receive the state of charger cable
2108 * when registered cable is attached or detached.
2109 *
2110 * @self: the notifier block of the charger_extcon_notifier.
2111 * @event: the cable state.
2112 * @ptr: the data pointer of notifier block.
2113 */
2114
charger_extcon_notifier(struct notifier_block * self,unsigned long event,void * ptr)2115 static int charger_extcon_notifier(struct notifier_block *self,
2116 unsigned long event,
2117 void *ptr)
2118 {
2119 struct charger_manager *cm =
2120 container_of(self, struct charger_manager, nb);
2121 struct charger_desc *desc = cm->desc;
2122 struct fastcharge_config *fc_config;
2123 union power_supply_propval val;
2124 int tcpm_wait = 0;
2125 int ret;
2126
2127 /*
2128 * The newly state of charger cable.
2129 * If cable is attached, cable->attached is true.
2130 */
2131 cm->attached = event;
2132 fc_config = cm->fc_config;
2133
2134 CM_DBG("%s, %d\n", __func__, cm->attached);
2135 if (event) {
2136 cm->is_charge = 1;
2137 pm_stay_awake(cm->dev);
2138
2139 if (extcon_get_state(desc->extcon_dev, EXTCON_CHG_USB_DCP) > 0) {
2140 CM_DBG("EXTCON_CHG_USB_DCP\n");
2141 ret = power_supply_get_property(desc->tcpm_psy,
2142 POWER_SUPPLY_PROP_ONLINE,
2143 &val);
2144 if (ret) {
2145 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
2146 return ret;
2147 }
2148 while (tcpm_wait++ < 30) {
2149 if (!val.intval)
2150 break;
2151 ret = power_supply_get_property(desc->tcpm_psy,
2152 POWER_SUPPLY_PROP_ONLINE,
2153 &val);
2154 if (ret) {
2155 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
2156 return ret;
2157 }
2158 if (!val.intval)
2159 break;
2160 mdelay(10);
2161 }
2162 }
2163
2164 ret = power_supply_get_property(desc->tcpm_psy,
2165 POWER_SUPPLY_PROP_USB_TYPE,
2166 &val);
2167 if (ret) {
2168 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
2169 return ret;
2170 }
2171 switch (val.intval) {
2172 case POWER_SUPPLY_USB_TYPE_PD:
2173 cm->is_fast_charge = 1;
2174 CM_DBG("POWER_SUPPLY_USB_TYPE_PD\n");
2175 fc_config->charge_type = CHARGE_TYPE_PD;
2176 ret = power_supply_get_property(desc->tcpm_psy,
2177 POWER_SUPPLY_PROP_VOLTAGE_MAX,
2178 &val);
2179 if (ret) {
2180 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
2181 return ret;
2182 }
2183 fc_config->adapter_volt_max_lmt = val.intval;
2184 ret = power_supply_get_property(desc->tcpm_psy,
2185 POWER_SUPPLY_PROP_CURRENT_MAX,
2186 &val);
2187 if (ret) {
2188 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAXn", __LINE__);
2189 return ret;
2190 }
2191 fc_config->adapter_curr_max_lmt = val.intval;
2192 CM_DBG("adapter_curr_max_lmt:%d\n", fc_config->adapter_curr_max_lmt);
2193 ret = set_sw_charger_input_limit_current(cm, fc_config->adapter_curr_max_lmt);
2194 if (ret)
2195 return NOTIFY_BAD;
2196 CM_DBG("USB-TYPE: POWER_SUPPLY_USB_TYPE_PD\n");
2197 break;
2198 case POWER_SUPPLY_USB_TYPE_PD_PPS:
2199 cm->is_fast_charge = 1;
2200 CM_DBG("POWER_SUPPLY_USB_TYPE_PD_PPS\n");
2201 fc_config->charge_type = CHARGE_TYPE_PPS;
2202 CM_DBG("charge_type: %d, %d\n", cm->fc_config->charge_type, __LINE__);
2203 cm->fc_charger_enabled = 1;
2204 cm_charge_pump_move_state(cm, PPS_PM_STATE_ENTRY);
2205 /*
2206 * Setup work for controlling charger
2207 * according to charger cable.
2208 */
2209 queue_work(cm->cm_wq, &cm->wq);
2210 break;
2211 default:
2212 fc_config->adaper_power_init_flag = 0;
2213 ret = power_supply_get_property(desc->tcpm_psy,
2214 POWER_SUPPLY_PROP_CURRENT_MAX,
2215 &val);
2216 if (ret) {
2217 dev_err(cm->dev, "[%d] failed to get POWER_SUPPLY_PROP_CURRENT_MAX\n", __LINE__);
2218 return ret;
2219 }
2220 if ((val.intval == 1500 * 1000) ||
2221 (val.intval == 3000 * 1000) ||
2222 (val.intval == 900 * 1000)) {
2223 CM_DBG("POWER_SUPPLY_USB_TYPE_C\n");
2224 fc_config->charge_type = CHARGE_TYPE_TYPE_C;
2225 fc_config->adapter_curr_max_lmt = val.intval;
2226 ret = set_sw_charger_input_limit_current(cm, USB_TYPE_C_INPUT_CURRENT);
2227 if (ret)
2228 return NOTIFY_BAD;
2229 CM_DBG("USB-TYPE: POWER_SUPPLY_USB_TYPE_C\n");
2230 } else {
2231 if (extcon_get_state(desc->extcon_dev, EXTCON_CHG_USB_SDP) > 0) {
2232 CM_DBG("EXTCON_CHG_USB_SDP\n");
2233 fc_config->charge_type = CHARGE_TYPE_NORMAL;
2234 ret = set_sw_charger_input_limit_current(cm, USB_SDP_INPUT_CURRENT);
2235 if (ret)
2236 return NOTIFY_BAD;
2237 } else if (extcon_get_state(desc->extcon_dev, EXTCON_CHG_USB_DCP) > 0) {
2238 CM_DBG("EXTCON_CHG_USB_DCP\n");
2239 fc_config->charge_type = CHARGE_TYPE_NORMAL;
2240 ret = set_sw_charger_input_limit_current(cm, USB_DCP_INPUT_CURRENT);
2241 if (ret)
2242 return NOTIFY_BAD;
2243 } else if (extcon_get_state(desc->extcon_dev, EXTCON_CHG_USB_CDP) > 0) {
2244 CM_DBG("EXTCON_CHG_USB_CDP\n");
2245 fc_config->charge_type = CHARGE_TYPE_NORMAL;
2246 ret = set_sw_charger_input_limit_current(cm, USB_CDP_INPUT_CURRENT);
2247 if (ret)
2248 return NOTIFY_BAD;
2249 }
2250 }
2251 break;
2252 }
2253
2254 if (val.intval != POWER_SUPPLY_USB_TYPE_PD_PPS) {
2255 if (cm->fc_config->jeita_charge_support) {
2256 cancel_delayed_work(&cm->cm_jeita_work);
2257 queue_delayed_work(cm->cm_wq, &cm->cm_jeita_work, 0);
2258 }
2259 }
2260 } else {
2261 cm->is_charge = 0;
2262 cm->is_fast_charge = 0;
2263 fc_config->charge_type = CHARGE_TYPE_DISCHARGE;
2264 set_sw_charger_input_limit_current(cm, USB_SDP_INPUT_CURRENT);
2265 cm_charge_limit_update(cm);
2266 set_sw_charger_disable(cm);
2267 set_sw_charger_voltage(cm, cm->fc_config->vbat_lmt);
2268 cm_charge_pump_move_state(cm, PPS_PM_STATE_ENTRY);
2269 if (cm->cp.charge_enabled)
2270 set_cp_disable(cm);
2271 pm_relax(cm->dev);
2272 cm->fc_charger_enabled = 0;
2273 cm->fc_config->sw_ovp_flag = 0;
2274 cm->fc_config->fc_charge_error = false;
2275 }
2276
2277 return NOTIFY_DONE;
2278 }
2279
cm_disable_charge(struct charger_manager * cm)2280 static void cm_disable_charge(struct charger_manager *cm)
2281 {
2282 cancel_delayed_work_sync(&cm->cm_monitor_work);
2283 cancel_delayed_work_sync(&cm->cm_jeita_work);
2284
2285 charger_extcon_notifier(&cm->nb, 0, NULL);
2286 }
2287
cm_enable_charge(struct charger_manager * cm)2288 static void cm_enable_charge(struct charger_manager *cm)
2289 {
2290 charger_extcon_notifier(&cm->nb, 1, NULL);
2291 }
2292
chg_en_show(struct device * dev,struct device_attribute * attr,char * buf)2293 static ssize_t chg_en_show(struct device *dev,
2294 struct device_attribute *attr,
2295 char *buf)
2296 {
2297 return 0;
2298 }
2299
chg_en_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)2300 static ssize_t chg_en_store(struct device *dev,
2301 struct device_attribute *attr,
2302 const char *buf, size_t count)
2303 {
2304 struct charger_manager *cm = dev_get_drvdata(dev);
2305 int ret = 0;
2306 bool en = 0;
2307
2308 ret = kstrtobool(buf, &en);
2309 if (ret) {
2310 pr_err("Unknown command\n");
2311 return ret;
2312 }
2313 if (en)
2314 cm_enable_charge(cm);
2315 else
2316 cm_disable_charge(cm);
2317
2318 return count;
2319 }
2320
2321
2322 static DEVICE_ATTR_RW(chg_en);
2323
chg_en_create_device_node(struct device * dev)2324 static void chg_en_create_device_node(struct device *dev)
2325 {
2326 device_create_file(dev, &dev_attr_chg_en);
2327 }
2328
2329 /**
2330 * charger_extcon_init - register external connector to use it
2331 * as the charger cable
2332 *
2333 * @cm: the Charger Manager representing the battery.
2334 * @cable: the Charger cable representing the external connector.
2335 */
charger_extcon_init(struct charger_manager * cm)2336 static int charger_extcon_init(struct charger_manager *cm)
2337 {
2338 struct charger_desc *desc = cm->desc;
2339 u64 extcon_type = EXTCON_NONE;
2340 unsigned long event;
2341 int ret, i;
2342
2343 /*
2344 * Charger manager use Extcon framework to identify
2345 * the charger cable among various external connector
2346 * cable (e.g., TA, USB, MHL, Dock).
2347 */
2348 INIT_WORK(&cm->wq, charger_extcon_work);
2349 cm->nb.notifier_call = charger_extcon_notifier;
2350
2351 if (IS_ERR_OR_NULL(desc->extcon_dev)) {
2352 pr_err("Cannot find extcon_dev\n");
2353 if (desc->extcon_dev == NULL)
2354 return -EPROBE_DEFER;
2355 else
2356 return PTR_ERR(desc->extcon_dev);
2357 }
2358
2359 for (i = 0; i < ARRAY_SIZE(extcon_mapping); i++) {
2360 extcon_type = extcon_mapping[i].extcon_type;
2361 if (extcon_type == EXTCON_NONE) {
2362 pr_err("Cannot find cable for type %s", extcon_mapping[i].name);
2363 return -EINVAL;
2364 }
2365
2366 ret = devm_extcon_register_notifier(cm->dev,
2367 desc->extcon_dev,
2368 extcon_type,
2369 &cm->nb);
2370 if (ret < 0) {
2371 pr_err("Cannot register extcon_dev for %s\n", extcon_mapping[i].name);
2372 return ret;
2373 }
2374 CM_DBG("%s: %s\n", desc->extcon_dev->name, extcon_mapping[i].name);
2375 event = extcon_get_state(desc->extcon_dev, extcon_type);
2376 if (event)
2377 charger_extcon_notifier(&cm->nb, event, NULL);
2378 }
2379
2380 return 0;
2381 }
2382
2383 static const struct of_device_id charger_manager_match[] = {
2384 {
2385 .compatible = "rockchip-charger-manager",
2386 },
2387 {},
2388 };
2389 MODULE_DEVICE_TABLE(of, charger_manager_match);
2390
of_cm_parse_desc(struct device * dev)2391 static struct charger_desc *of_cm_parse_desc(struct device *dev)
2392 {
2393 struct device_node *np = dev->of_node;
2394 u32 poll_mode = CM_POLL_DISABLE;
2395 struct charger_desc *desc;
2396 const __be32 *list;
2397 int size, count, i;
2398
2399 desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
2400 if (!desc)
2401 return ERR_PTR(-ENOMEM);
2402
2403 of_property_read_u32(np, "cm-poll-mode", &poll_mode);
2404 desc->polling_mode = poll_mode;
2405 of_property_read_u32(np, "cm-poll-interval", &desc->polling_interval_ms);
2406
2407 of_property_read_string(np, "cm-chargers", &desc->psy_charger_stat);
2408 of_property_read_string(np, "cm-charge-pump", &desc->psy_charger_pump_stat);
2409 of_property_read_string(np, "cm-fuel-gauge", &desc->psy_fuel_gauge);
2410
2411 CM_DBG("cm-chargers: %s\n", desc->psy_charger_stat);
2412 CM_DBG("cm-charge-pumps: %s\n", desc->psy_charger_pump_stat);
2413 CM_DBG("cm-fuel-gauge: %s\n", desc->psy_fuel_gauge);
2414
2415 desc->tcpm_psy = power_supply_get_by_phandle(np, "cm-chargers-phandle");
2416 if (IS_ERR_OR_NULL(desc->tcpm_psy)) {
2417 CM_DBG("cm-chargers-phandle is error\n");
2418 return ERR_PTR(-ENOMEM);
2419 }
2420
2421 CM_DBG("tcpm_psy name : %s\n", desc->tcpm_psy->desc->name);
2422
2423 desc->extcon_dev = extcon_get_edev_by_phandle(dev, 0);
2424 if (IS_ERR_OR_NULL(desc->extcon_dev)) {
2425 CM_DBG("CM: get extcon_edev error\n");
2426 return ERR_PTR(-ENOMEM);
2427 }
2428
2429 if (of_find_property(np, "cm-jeita-temp-charge-table", &size)) {
2430 list = of_get_property(np, "cm-jeita-temp-charge-table", &size);
2431 size /= sizeof(u32);
2432 if (!size || (size % 4)) {
2433 dev_err(dev, "invalid temperature_chrg_table: size=%d\n", size);
2434 return ERR_PTR(-ENOMEM);
2435 }
2436
2437 count = size / 4;
2438 desc->jeita_charge_table_count = count;
2439 if (count < 1) {
2440 desc->measure_battery_temp = false;
2441 goto out;
2442 }
2443 desc->jeita_charge_table = devm_kzalloc(dev,
2444 count * sizeof(*desc->jeita_charge_table),
2445 GFP_KERNEL);
2446 if (!desc->jeita_charge_table)
2447 return ERR_PTR(-ENOMEM);
2448
2449 for (i = 0; i < count; i++) {
2450 /* temperature */
2451 desc->jeita_charge_table[i].temp_down = be32_to_cpu(*list++);
2452 desc->jeita_charge_table[i].temp_up = be32_to_cpu(*list++);
2453 desc->jeita_charge_table[i].chrg_current = be32_to_cpu(*list++);
2454 desc->jeita_charge_table[i].chrg_voltage = be32_to_cpu(*list++);
2455
2456 CM_DBG("temp%d: [%d, %d], chrg_current=%d, chrg_voltage: %d\n",
2457 i, desc->jeita_charge_table[i].temp_down,
2458 desc->jeita_charge_table[i].temp_up,
2459 desc->jeita_charge_table[i].chrg_current,
2460 desc->jeita_charge_table[i].chrg_voltage);
2461 }
2462 /* the charge must be done externally to fully comply with
2463 * the JEITA safety guidelines if this flag is set!
2464 */
2465 desc->measure_battery_temp = true;
2466 }
2467 out:
2468 return desc;
2469 }
2470
cm_get_drv_data(struct platform_device * pdev)2471 static inline struct charger_desc *cm_get_drv_data(struct platform_device *pdev)
2472 {
2473 if (pdev->dev.of_node)
2474 return of_cm_parse_desc(&pdev->dev);
2475 return dev_get_platdata(&pdev->dev);
2476 }
2477
charger_manager_probe(struct platform_device * pdev)2478 static int charger_manager_probe(struct platform_device *pdev)
2479 {
2480 struct charger_desc *desc = cm_get_drv_data(pdev);
2481 struct power_supply_battery_info info;
2482 struct power_supply charger_psy;
2483 struct charger_manager *cm;
2484 int ret;
2485
2486 if (IS_ERR(desc)) {
2487 dev_err(&pdev->dev, "No platform data (desc) found\n");
2488 return PTR_ERR(desc);
2489 }
2490
2491 cm = devm_kzalloc(&pdev->dev, sizeof(*cm), GFP_KERNEL);
2492 if (!cm)
2493 return -ENOMEM;
2494
2495 /* Basic Values. Unspecified are Null or 0 */
2496 cm->dev = &pdev->dev;
2497 cm->desc = desc;
2498 if (!desc->psy_charger_stat) {
2499 dev_err(&pdev->dev, "No power supply defined\n");
2500 return -EINVAL;
2501 }
2502
2503 if (!desc->psy_fuel_gauge) {
2504 dev_err(&pdev->dev, "No fuel gauge power supply defined\n");
2505 return -EINVAL;
2506 }
2507
2508 if (!desc->psy_charger_pump_stat)
2509 dev_err(&pdev->dev, "Cannot find charge pump power supply\n");
2510
2511 if (cm->desc->polling_mode != CM_POLL_DISABLE &&
2512 (desc->polling_interval_ms == 0 ||
2513 msecs_to_jiffies(desc->polling_interval_ms) <= CM_JIFFIES_SMALL)) {
2514 dev_err(&pdev->dev, "polling_interval_ms is too small\n");
2515 return -EINVAL;
2516 }
2517
2518 platform_set_drvdata(pdev, cm);
2519 charger_psy.of_node = cm->dev->of_node;
2520 ret = power_supply_get_battery_info(&charger_psy, &(desc->info));
2521 if (ret) {
2522 info = bat_default_info;
2523 desc->info = bat_default_info;
2524 dev_err(&pdev->dev, "failed to get battery information\n");
2525 } else
2526 info = desc->info;
2527
2528 cm->fc_config = &fc_config_parameter;
2529 ret = get_sw_charger_current_max(cm, &cm->fc_config->sw_charge_current_max);
2530 if (ret)
2531 return -EINVAL;
2532
2533 if (desc->measure_battery_temp) {
2534 cm->fc_config->jeita_charge_support = true;
2535 cm->fc_config->jeita_enable_charge = true;
2536 }
2537
2538 CM_DBG("battery info:\n");
2539 CM_DBG("INFO: charge-full-design-microamp-hours: %d\n",
2540 info.charge_full_design_uah);
2541 CM_DBG("INFO:factory_internal_resistance_uohm: %d\n",
2542 info.factory_internal_resistance_uohm);
2543 CM_DBG("charge_term_current_ua: %d\n",
2544 info.charge_term_current_ua);
2545 CM_DBG("constant_charge_voltage_max_uv: %d\n",
2546 info.constant_charge_voltage_max_uv);
2547 CM_DBG("constant_charge_current_max_ua: %d\n",
2548 info.constant_charge_current_max_ua);
2549 CM_DBG("precharge_current_ua: %d\n",
2550 info.precharge_current_ua);
2551 CM_DBG("precharge-upper-limit-microvolt: %d\n",
2552 info.precharge_voltage_max_uv);
2553
2554 cm->cm_wq = alloc_ordered_workqueue("%s",
2555 WQ_MEM_RECLAIM | WQ_FREEZABLE,
2556 "cm-charger-wq");
2557 if (unlikely(!cm->cm_wq)) {
2558 dev_err(&pdev->dev, "failed to alloc ordered charger manager wq\n");
2559 return -ENOMEM;
2560 }
2561 INIT_DELAYED_WORK(&cm->cm_monitor_work,
2562 cm_monitor_poller);
2563 INIT_DELAYED_WORK(&cm->cm_jeita_work,
2564 cm_jeita_poller);
2565
2566 /* Register extcon device for charger cable */
2567 ret = charger_extcon_init(cm);
2568 if (ret < 0) {
2569 dev_err(&pdev->dev, "Cannot initialize extcon device\n");
2570 goto err_reg_extcon;
2571 }
2572
2573 /*
2574 * Charger-manager is capable of waking up the system
2575 * from sleep when event is happened through
2576 * cm_notify_event()
2577 */
2578 device_init_wakeup(&pdev->dev, true);
2579 device_set_wakeup_capable(&pdev->dev, false);
2580
2581 chg_en_create_device_node(&pdev->dev);
2582
2583 return 0;
2584 err_reg_extcon:
2585
2586 return ret;
2587 }
2588
charger_manager_remove(struct platform_device * pdev)2589 static int charger_manager_remove(struct platform_device *pdev)
2590 {
2591 struct charger_manager *cm = platform_get_drvdata(pdev);
2592
2593 cancel_delayed_work_sync(&cm->cm_monitor_work);
2594 cancel_delayed_work_sync(&cm->cm_jeita_work);
2595
2596 return 0;
2597 }
2598
charger_manager_shutdown(struct platform_device * pdev)2599 static void charger_manager_shutdown(struct platform_device *pdev)
2600 {
2601 struct charger_manager *cm = platform_get_drvdata(pdev);
2602 union power_supply_propval val;
2603 int ret;
2604
2605 cancel_delayed_work_sync(&cm->cm_monitor_work);
2606 cancel_delayed_work_sync(&cm->cm_jeita_work);
2607
2608 CM_DBG("charger manager shutdown\n");
2609 CM_DBG("now charge_type: %d, CHARGE_TYPE_PPS:%d\n",
2610 cm->fc_config->charge_type, CHARGE_TYPE_PPS);
2611 if (cm->fc_config->charge_type == CHARGE_TYPE_PPS) {
2612 CM_DBG("PPS_CHARGE_SHUT_DOWN:\n");
2613 set_cp_disable(cm);
2614 val.intval = 1;/* pps --> pd */
2615 ret = power_supply_set_property(cm->desc->tcpm_psy,
2616 POWER_SUPPLY_PROP_ONLINE,
2617 &val);
2618 if (ret)
2619 dev_err(cm->dev, "failed to switch form PPS MODE to PD mode\n");
2620 }
2621 }
2622
2623 static const struct platform_device_id charger_manager_id[] = {
2624 { "fast-charger-manager", 0 },
2625 { },
2626 };
2627 MODULE_DEVICE_TABLE(platform, charger_manager_id);
2628
2629 static struct platform_driver charger_manager_driver = {
2630 .driver = {
2631 .name = "fast-charger-manager",
2632 .of_match_table = charger_manager_match,
2633 },
2634 .probe = charger_manager_probe,
2635 .remove = charger_manager_remove,
2636 .shutdown = charger_manager_shutdown,
2637 .id_table = charger_manager_id,
2638 };
2639
charger_manager_init(void)2640 static int __init charger_manager_init(void)
2641 {
2642 return platform_driver_register(&charger_manager_driver);
2643 }
2644 late_initcall(charger_manager_init);
2645
charger_manager_cleanup(void)2646 static void __exit charger_manager_cleanup(void)
2647 {
2648 platform_driver_unregister(&charger_manager_driver);
2649 }
2650 module_exit(charger_manager_cleanup);
2651
2652 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
2653 MODULE_DESCRIPTION("Charger Manager");
2654 MODULE_LICENSE("GPL");
2655