projects / GitHub / exynos8895 / android_kernel_samsung_universal8895.git / blob
? search:


7ff91a9321eafb3c136c80003ce817d682914909
[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / drivers / battery_v2 / sec_battery.c
1 /*
2 * sec_battery.c
3 * Samsung Mobile Battery Driver
4 *
5 * Copyright (C) 2012 Samsung Electronics
6 *
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12 #include "include/sec_battery.h"
13 #include <linux/sec_ext.h>
14 #include <linux/sec_debug.h>
15
16 #if defined(CONFIG_SEC_ABC)
17 #include <linux/sti/abc_common.h>
18 #endif
19
20 bool sleep_mode = false;
21
22 static struct device_attribute sec_battery_attrs[] = {
23 SEC_BATTERY_ATTR(batt_reset_soc),
24 SEC_BATTERY_ATTR(batt_read_raw_soc),
25 SEC_BATTERY_ATTR(batt_read_adj_soc),
26 SEC_BATTERY_ATTR(batt_type),
27 SEC_BATTERY_ATTR(batt_vfocv),
28 SEC_BATTERY_ATTR(batt_vol_adc),
29 SEC_BATTERY_ATTR(batt_vol_adc_cal),
30 SEC_BATTERY_ATTR(batt_vol_aver),
31 SEC_BATTERY_ATTR(batt_vol_adc_aver),
32 SEC_BATTERY_ATTR(batt_current_ua_now),
33 SEC_BATTERY_ATTR(batt_current_ua_avg),
34 SEC_BATTERY_ATTR(batt_filter_cfg),
35 SEC_BATTERY_ATTR(batt_temp),
36 SEC_BATTERY_ATTR(batt_temp_adc),
37 SEC_BATTERY_ATTR(batt_temp_aver),
38 SEC_BATTERY_ATTR(batt_temp_adc_aver),
39 SEC_BATTERY_ATTR(usb_temp),
40 SEC_BATTERY_ATTR(usb_temp_adc),
41 SEC_BATTERY_ATTR(chg_temp),
42 SEC_BATTERY_ATTR(chg_temp_adc),
43 SEC_BATTERY_ATTR(slave_chg_temp),
44 SEC_BATTERY_ATTR(slave_chg_temp_adc),
45
46 SEC_BATTERY_ATTR(batt_vf_adc),
47 SEC_BATTERY_ATTR(batt_slate_mode),
48
49 SEC_BATTERY_ATTR(batt_lp_charging),
50 SEC_BATTERY_ATTR(siop_activated),
51 SEC_BATTERY_ATTR(siop_level),
52 SEC_BATTERY_ATTR(siop_event),
53 SEC_BATTERY_ATTR(batt_charging_source),
54 SEC_BATTERY_ATTR(fg_reg_dump),
55 SEC_BATTERY_ATTR(fg_reset_cap),
56 SEC_BATTERY_ATTR(fg_capacity),
57 SEC_BATTERY_ATTR(fg_asoc),
58 SEC_BATTERY_ATTR(auth),
59 SEC_BATTERY_ATTR(chg_current_adc),
60 SEC_BATTERY_ATTR(wc_adc),
61 SEC_BATTERY_ATTR(wc_status),
62 SEC_BATTERY_ATTR(wc_enable),
63 SEC_BATTERY_ATTR(wc_control),
64 SEC_BATTERY_ATTR(wc_control_cnt),
65 SEC_BATTERY_ATTR(led_cover),
66 SEC_BATTERY_ATTR(hv_charger_status),
67 SEC_BATTERY_ATTR(hv_wc_charger_status),
68 SEC_BATTERY_ATTR(hv_charger_set),
69 SEC_BATTERY_ATTR(factory_mode),
70 SEC_BATTERY_ATTR(store_mode),
71 SEC_BATTERY_ATTR(update),
72 SEC_BATTERY_ATTR(test_mode),
73
74 SEC_BATTERY_ATTR(call),
75 SEC_BATTERY_ATTR(2g_call),
76 SEC_BATTERY_ATTR(talk_gsm),
77 SEC_BATTERY_ATTR(3g_call),
78 SEC_BATTERY_ATTR(talk_wcdma),
79 SEC_BATTERY_ATTR(music),
80 SEC_BATTERY_ATTR(video),
81 SEC_BATTERY_ATTR(browser),
82 SEC_BATTERY_ATTR(hotspot),
83 SEC_BATTERY_ATTR(camera),
84 SEC_BATTERY_ATTR(camcorder),
85 SEC_BATTERY_ATTR(data_call),
86 SEC_BATTERY_ATTR(wifi),
87 SEC_BATTERY_ATTR(wibro),
88 SEC_BATTERY_ATTR(lte),
89 SEC_BATTERY_ATTR(lcd),
90 SEC_BATTERY_ATTR(gps),
91 SEC_BATTERY_ATTR(event),
92 SEC_BATTERY_ATTR(batt_temp_table),
93 SEC_BATTERY_ATTR(batt_high_current_usb),
94 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
95 SEC_BATTERY_ATTR(test_charge_current),
96 #endif
97 SEC_BATTERY_ATTR(set_stability_test),
98 SEC_BATTERY_ATTR(batt_capacity_max),
99 SEC_BATTERY_ATTR(batt_inbat_voltage),
100 SEC_BATTERY_ATTR(batt_inbat_voltage_ocv),
101 SEC_BATTERY_ATTR(check_slave_chg),
102 SEC_BATTERY_ATTR(batt_inbat_wireless_cs100),
103 SEC_BATTERY_ATTR(hmt_ta_connected),
104 SEC_BATTERY_ATTR(hmt_ta_charge),
105 #if defined(CONFIG_BATTERY_AGE_FORECAST)
106 SEC_BATTERY_ATTR(fg_cycle),
107 SEC_BATTERY_ATTR(fg_full_voltage),
108 SEC_BATTERY_ATTR(fg_fullcapnom),
109 SEC_BATTERY_ATTR(battery_cycle),
110 #endif
111 SEC_BATTERY_ATTR(batt_wpc_temp),
112 SEC_BATTERY_ATTR(batt_wpc_temp_adc),
113 SEC_BATTERY_ATTR(batt_coil_temp), /* Wireless Coil therm */
114 SEC_BATTERY_ATTR(batt_coil_temp_adc), /* Wireless Coil therm */
115 SEC_BATTERY_ATTR(mst_switch_test), /* MFC MST switch test */
116 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
117 SEC_BATTERY_ATTR(batt_wireless_firmware_update),
118 SEC_BATTERY_ATTR(otp_firmware_result),
119 SEC_BATTERY_ATTR(wc_ic_grade),
120 SEC_BATTERY_ATTR(otp_firmware_ver_bin),
121 SEC_BATTERY_ATTR(otp_firmware_ver),
122 SEC_BATTERY_ATTR(tx_firmware_result),
123 SEC_BATTERY_ATTR(tx_firmware_ver),
124 SEC_BATTERY_ATTR(batt_tx_status),
125 #endif
126 SEC_BATTERY_ATTR(wc_vout),
127 SEC_BATTERY_ATTR(wc_vrect),
128 SEC_BATTERY_ATTR(batt_hv_wireless_status),
129 SEC_BATTERY_ATTR(batt_hv_wireless_pad_ctrl),
130 SEC_BATTERY_ATTR(wc_op_freq),
131 SEC_BATTERY_ATTR(wc_cmd_info),
132 SEC_BATTERY_ATTR(batt_tune_float_voltage),
133 SEC_BATTERY_ATTR(batt_tune_input_charge_current),
134 SEC_BATTERY_ATTR(batt_tune_fast_charge_current),
135 SEC_BATTERY_ATTR(batt_tune_ui_term_cur_1st),
136 SEC_BATTERY_ATTR(batt_tune_ui_term_cur_2nd),
137 SEC_BATTERY_ATTR(batt_tune_temp_high_normal),
138 SEC_BATTERY_ATTR(batt_tune_temp_high_rec_normal),
139 SEC_BATTERY_ATTR(batt_tune_temp_low_normal),
140 SEC_BATTERY_ATTR(batt_tune_temp_low_rec_normal),
141 SEC_BATTERY_ATTR(batt_tune_chg_temp_high),
142 SEC_BATTERY_ATTR(batt_tune_chg_temp_rec),
143 SEC_BATTERY_ATTR(batt_tune_chg_limit_cur),
144 SEC_BATTERY_ATTR(batt_tune_coil_temp_high),
145 SEC_BATTERY_ATTR(batt_tune_coil_temp_rec),
146 SEC_BATTERY_ATTR(batt_tune_coil_limit_cur),
147 #if defined(CONFIG_UPDATE_BATTERY_DATA)
148 SEC_BATTERY_ATTR(batt_update_data),
149 #endif
150 SEC_BATTERY_ATTR(batt_misc_event),
151 SEC_BATTERY_ATTR(batt_ext_dev_chg),
152 SEC_BATTERY_ATTR(batt_wdt_control),
153 SEC_BATTERY_ATTR(mode),
154 SEC_BATTERY_ATTR(check_ps_ready),
155 SEC_BATTERY_ATTR(batt_chip_id),
156 SEC_BATTERY_ATTR(cisd_fullcaprep_max),
157 #if defined(CONFIG_BATTERY_CISD)
158 SEC_BATTERY_ATTR(cisd_data),
159 SEC_BATTERY_ATTR(cisd_data_json),
160 SEC_BATTERY_ATTR(cisd_data_d_json),
161 SEC_BATTERY_ATTR(cisd_wire_count),
162 SEC_BATTERY_ATTR(cisd_wc_data),
163 SEC_BATTERY_ATTR(cisd_wc_data_json),
164 SEC_BATTERY_ATTR(prev_battery_data),
165 SEC_BATTERY_ATTR(prev_battery_info),
166 #endif
167 #if defined(CONFIG_BATTERY_SBM_DATA)
168 SEC_BATTERY_ATTR(sbm_data),
169 #endif
170 SEC_BATTERY_ATTR(safety_timer_set),
171 SEC_BATTERY_ATTR(batt_swelling_control),
172 SEC_BATTERY_ATTR(safety_timer_info),
173 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
174 SEC_BATTERY_ATTR(batt_temp_test),
175 #endif
176 SEC_BATTERY_ATTR(batt_current_event),
177 SEC_BATTERY_ATTR(cc_info),
178 SEC_BATTERY_ATTR(ext_event),
179 };
180
181 static enum power_supply_property sec_battery_props[] = {
182 POWER_SUPPLY_PROP_STATUS,
183 POWER_SUPPLY_PROP_CHARGE_TYPE,
184 POWER_SUPPLY_PROP_HEALTH,
185 POWER_SUPPLY_PROP_PRESENT,
186 POWER_SUPPLY_PROP_ONLINE,
187 POWER_SUPPLY_PROP_TECHNOLOGY,
188 POWER_SUPPLY_PROP_VOLTAGE_NOW,
189 POWER_SUPPLY_PROP_VOLTAGE_AVG,
190 POWER_SUPPLY_PROP_CURRENT_NOW,
191 POWER_SUPPLY_PROP_CURRENT_AVG,
192 POWER_SUPPLY_PROP_CHARGE_FULL,
193 POWER_SUPPLY_PROP_CHARGE_NOW,
194 POWER_SUPPLY_PROP_CAPACITY,
195 POWER_SUPPLY_PROP_TEMP,
196 POWER_SUPPLY_PROP_TEMP_AMBIENT,
197 #if defined(CONFIG_CALC_TIME_TO_FULL)
198 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
199 #endif
200 POWER_SUPPLY_PROP_CHARGE_COUNTER_SHADOW,
201 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
202 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL,
203 POWER_SUPPLY_PROP_CHARGE_COUNTER,
204 };
205
206 static enum power_supply_property sec_power_props[] = {
207 POWER_SUPPLY_PROP_ONLINE,
208 POWER_SUPPLY_PROP_VOLTAGE_MAX,
209 POWER_SUPPLY_PROP_CURRENT_MAX,
210 };
211
212 static enum power_supply_property sec_wireless_props[] = {
213 POWER_SUPPLY_PROP_ONLINE,
214 POWER_SUPPLY_PROP_PRESENT,
215 POWER_SUPPLY_PROP_VOLTAGE_MAX,
216 POWER_SUPPLY_PROP_CURRENT_MAX,
217 };
218
219 static enum power_supply_property sec_ac_props[] = {
220 POWER_SUPPLY_PROP_ONLINE,
221 POWER_SUPPLY_PROP_TEMP,
222 POWER_SUPPLY_PROP_VOLTAGE_MAX,
223 POWER_SUPPLY_PROP_CURRENT_MAX,
224 };
225
226 static enum power_supply_property sec_ps_props[] = {
227 POWER_SUPPLY_PROP_STATUS,
228 POWER_SUPPLY_PROP_ONLINE,
229 };
230
231 static char *supply_list[] = {
232 "battery",
233 };
234
235 char *sec_cable_type[SEC_BATTERY_CABLE_MAX] = {
236 "UNKNOWN", /* 0 */
237 "NONE", /* 1 */
238 "PREAPARE_TA", /* 2 */
239 "TA", /* 3 */
240 "USB", /* 4 */
241 "USB_CDP", /* 5 */
242 "9V_TA", /* 6 */
243 "9V_ERR", /* 7 */
244 "9V_UNKNOWN", /* 8 */
245 "12V_TA", /* 9 */
246 "WIRELESS", /* 10 */
247 "HV_WIRELESS", /* 11 */
248 "PMA_WIRELESS", /* 12 */
249 "WIRELESS_PACK", /* 13 */
250 "WIRELESS_HV_PACK", /* 14 */
251 "WIRELESS_STAND", /* 15 */
252 "WIRELESS_HV_STAND", /* 16 */
253 "OC20", /* 17 */
254 "QC30", /* 18 */
255 "PDIC", /* 19 */
256 "UARTOFF", /* 20 */
257 "OTG", /* 21 */
258 "LAN_HUB", /* 22 */
259 "POWER_SHARGING", /* 23 */
260 "HMT_CONNECTED", /* 24 */
261 "HMT_CHARGE", /* 25 */
262 "HV_TA_CHG_LIMIT", /* 26 */
263 "WIRELESS_VEHICLE", /* 27 */
264 "WIRELESS_HV_VEHICLE", /* 28 */
265 "WIRELESS_HV_PREPARE", /* 29 */
266 "TIMEOUT", /* 30 */
267 "SMART_OTG", /* 31 */
268 "SMART_NOTG", /* 32 */
269 "WIRELESS_TX", /* 33 */
270 };
271
272 char *sec_bat_charging_mode_str[] = {
273 "None",
274 "Normal",
275 "Additional",
276 "Re-Charging",
277 "ABS"
278 };
279
280 char *sec_bat_status_str[] = {
281 "Unknown",
282 "Charging",
283 "Discharging",
284 "Not-charging",
285 "Full"
286 };
287
288 char *sec_bat_health_str[] = {
289 "Unknown",
290 "Good",
291 "Overheat",
292 "Warm",
293 "Dead",
294 "OverVoltage",
295 "UnspecFailure",
296 "Cold",
297 "Cool",
298 "WatchdogTimerExpire",
299 "SafetyTimerExpire",
300 "UnderVoltage",
301 "OverheatLimit",
302 "VsysOVP",
303 "VbatOVP",
304 };
305
306 char *sec_bat_charge_mode_str[] = {
307 "Charging-On",
308 "Charging-Off",
309 "Buck-Off",
310 };
311
312 extern int bootmode;
313
314 static void sec_bat_set_misc_event(struct sec_battery_info *battery,
315 const int misc_event_type, bool do_clear) {
316
317 mutex_lock(&battery->misclock);
318 pr_info("%s: %s misc event(now=0x%x, value=0x%x)\n",
319 __func__, ((do_clear) ? "clear" : "set"), battery->misc_event, misc_event_type);
320 if (do_clear) {
321 battery->misc_event &= ~misc_event_type;
322 } else {
323 battery->misc_event |= misc_event_type;
324 }
325 mutex_unlock(&battery->misclock);
326
327 if (battery->prev_misc_event != battery->misc_event) {
328 cancel_delayed_work(&battery->misc_event_work);
329 wake_lock(&battery->misc_event_wake_lock);
330 queue_delayed_work(battery->monitor_wqueue,
331 &battery->misc_event_work, 0);
332 }
333 }
334
335 static void sec_bat_set_current_event(struct sec_battery_info *battery,
336 unsigned int current_event_val, unsigned int current_event_mask)
337 {
338 unsigned int temp = battery->current_event;
339
340 mutex_lock(&battery->current_eventlock);
341
342 battery->current_event &= ~current_event_mask;
343 battery->current_event |= current_event_val;
344
345 pr_info("%s: current event before(0x%x), after(0x%x)\n",
346 __func__, temp, battery->current_event);
347
348 mutex_unlock(&battery->current_eventlock);
349 }
350
351 static void sec_bat_change_default_current(struct sec_battery_info *battery,
352 int cable_type, int input, int output)
353 {
354 battery->pdata->charging_current[cable_type].input_current_limit = input;
355 battery->pdata->charging_current[cable_type].fast_charging_current = output;
356 pr_info("%s: cable_type: %d input: %d output: %d\n",__func__, cable_type, input, output);
357 }
358
359 static int sec_bat_get_wireless_current(struct sec_battery_info *battery, int incurr)
360 {
361 /* 2. WPC_SLEEP_MODE */
362 if (is_hv_wireless_type(battery->cable_type) && sleep_mode) {
363 if(incurr > battery->pdata->sleep_mode_limit_current)
364 incurr = battery->pdata->sleep_mode_limit_current;
365 pr_info("%s sleep_mode =%d, chg_limit =%d, in_curr = %d \n", __func__,
366 sleep_mode, battery->chg_limit, incurr);
367 }
368
369 /* 3. WPC_TEMP_MODE */
370 if (is_wireless_type(battery->cable_type) && battery->chg_limit) {
371 if ((battery->siop_level >= 100) &&
372 (incurr > battery->pdata->wpc_charging_limit_current))
373 incurr = battery->pdata->wpc_charging_limit_current;
374 else if ((battery->siop_level < 100) &&
375 (incurr > battery->pdata->wpc_lcd_on_charging_limit_current))
376 incurr = battery->pdata->wpc_lcd_on_charging_limit_current;
377 }
378
379 /* 4. WPC_CV_MODE */
380 if (is_nv_wireless_type(battery->cable_type)) {
381 if (battery->pdata->set_cv_vout_in_low_capacity) {
382 union power_supply_propval value = {0,};
383
384 if (battery->capacity <= battery->pdata->set_cv_vout_in_low_capacity &&
385 !battery->wc_cv_mode) {
386 battery->wc_cv_mode = true;
387 value.intval = WIRELESS_VOUT_CC_CV_VOUT; // 5.5V
388 psy_do_property(battery->pdata->wireless_charger_name, set,
389 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
390 } else if (battery->capacity > battery->pdata->set_cv_vout_in_low_capacity &&
391 battery->capacity < battery->pdata->wireless_cc_cv &&
392 battery->wc_cv_mode) {
393 battery->wc_cv_mode = false;
394 value.intval = WIRELESS_VOUT_5V; // 5V
395 psy_do_property(battery->pdata->wireless_charger_name, set,
396 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
397 }
398 }
399
400 if (battery->wc_cv_mode) {
401 if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_PACK) {
402 if (incurr > battery->pdata->wc_cv_pack_current)
403 incurr = battery->pdata->wc_cv_pack_current;
404 } else if (incurr > battery->pdata->wc_cv_current) {
405 incurr = battery->pdata->wc_cv_current;
406 }
407 }
408 }
409
410 /* 5. Full-Additional state */
411 if (battery->status == POWER_SUPPLY_STATUS_FULL && battery->charging_mode == SEC_BATTERY_CHARGING_2ND) {
412 if (incurr > battery->pdata->siop_hv_wireless_input_limit_current)
413 incurr = battery->pdata->siop_hv_wireless_input_limit_current;
414 }
415
416 /* 6. Hero Stand Pad CV */
417 if (battery->capacity >= battery->pdata->wc_hero_stand_cc_cv) {
418 if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND) {
419 if (incurr > battery->pdata->wc_hero_stand_cv_current)
420 incurr = battery->pdata->wc_hero_stand_cv_current;
421 } else if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_STAND) {
422 if (battery->chg_limit &&
423 incurr > battery->pdata->wc_hero_stand_cv_current) {
424 incurr = battery->pdata->wc_hero_stand_cv_current;
425 } else if (!battery->chg_limit &&
426 incurr > battery->pdata->wc_hero_stand_hv_cv_current) {
427 incurr = battery->pdata->wc_hero_stand_hv_cv_current;
428 }
429 }
430 }
431
432 /* 7. Full-None state && SIOP_LEVEL 100 */
433 if (battery->siop_level == 100 &&
434 battery->status == POWER_SUPPLY_STATUS_FULL && battery->charging_mode == SEC_BATTERY_CHARGING_NONE) {
435 incurr = battery->pdata->wc_full_input_limit_current;
436 }
437
438 return incurr;
439 }
440
441 static void sec_bat_get_charging_current_by_siop(struct sec_battery_info *battery,
442 int *input_current, int *charging_current) {
443 int usb_charging_current = 500;
444
445 if (battery->siop_level < 100) {
446 int max_charging_current;
447
448 if (is_wireless_type(battery->cable_type)) {
449 /* decrease the charging current according to siop level */
450 *charging_current = *charging_current * battery->siop_level / 100;
451
452 /* do forced set charging current */
453 if (*charging_current > 0 && *charging_current < usb_charging_current)
454 *charging_current = usb_charging_current;
455 } else {
456 max_charging_current = 1800; /* 1 step(70) */
457
458 /* do forced set charging current */
459 if (*charging_current > max_charging_current)
460 *charging_current = max_charging_current;
461 }
462
463 if (is_nv_wireless_type(battery->cable_type)) {
464 if (*input_current > battery->pdata->siop_wireless_input_limit_current)
465 *input_current = battery->pdata->siop_wireless_input_limit_current;
466 if (*charging_current > battery->pdata->siop_wireless_charging_limit_current)
467 *charging_current = battery->pdata->siop_wireless_charging_limit_current;
468 } else if (is_hv_wireless_type(battery->cable_type)) {
469 if (*input_current > battery->pdata->siop_hv_wireless_input_limit_current)
470 *input_current = battery->pdata->siop_hv_wireless_input_limit_current;
471 if (*charging_current > battery->pdata->siop_hv_wireless_charging_limit_current)
472 *charging_current = battery->pdata->siop_hv_wireless_charging_limit_current;
473 } else if (is_hv_wire_type(battery->cable_type) && is_hv_wire_type(battery->wire_status)) {
474 if (is_hv_wire_12v_type(battery->cable_type)) {
475 if (*input_current > battery->pdata->siop_hv_12v_input_limit_current)
476 *input_current = battery->pdata->siop_hv_12v_input_limit_current;
477 } else {
478 if (*input_current > battery->pdata->siop_hv_input_limit_current)
479 *input_current = battery->pdata->siop_hv_input_limit_current;
480 }
481 #if defined(CONFIG_CCIC_NOTIFIER)
482 } else if (battery->cable_type == SEC_BATTERY_CABLE_PDIC) {
483 if (*input_current > (6000 / battery->input_voltage))
484 *input_current = 6000 / battery->input_voltage;
485 #endif
486 } else {
487 if (*input_current > battery->pdata->siop_input_limit_current)
488 *input_current = battery->pdata->siop_input_limit_current;
489 }
490 }
491
492 pr_info("%s: incurr(%d), chgcurr(%d)\n", __func__, *input_current, *charging_current);
493 }
494
495 #if defined(CONFIG_MUIC_HV) || defined(CONFIG_SUPPORT_QC30)
496 extern int muic_afc_set_voltage(int vol);
497 #endif
498 #if !defined(CONFIG_SEC_FACTORY)
499 static int sec_bat_get_temp_by_temp_control_source(struct sec_battery_info *battery,
500 enum sec_battery_temp_control_source tcs)
501 {
502 switch (tcs) {
503 case TEMP_CONTROL_SOURCE_CHG_THM:
504 return battery->chg_temp;
505 case TEMP_CONTROL_SOURCE_USB_THM:
506 return battery->usb_temp;
507 case TEMP_CONTROL_SOURCE_WPC_THM:
508 return battery->wpc_temp;
509 case TEMP_CONTROL_SOURCE_NONE:
510 case TEMP_CONTROL_SOURCE_BAT_THM:
511 default:
512 return battery->temperature;
513 }
514 }
515
516 static int sec_bat_check_mix_temp(struct sec_battery_info *battery, int input_current)
517 {
518 if (battery->pdata->chg_temp_check && battery->siop_level >= 100 && is_not_wireless_type(battery->cable_type)) {
519 if ((!battery->mix_limit &&
520 (battery->temperature >= battery->pdata->mix_high_temp) &&
521 (battery->chg_temp >= battery->pdata->mix_high_chg_temp)) ||
522 (battery->mix_limit &&
523 (battery->temperature > battery->pdata->mix_high_temp_recovery))) {
524 int max_input_current =
525 battery->pdata->full_check_current_1st + 50;
526
527 /* inpu current = float voltage * (topoff_current_1st + 50mA(margin)) / (vbus_level * 0.9) */
528 input_current = ((battery->pdata->chg_float_voltage / battery->pdata->chg_float_voltage_conv) * max_input_current) /
529 (battery->input_voltage * 90) / 10;
530 if (input_current > max_input_current)
531 input_current = max_input_current;
532
533 battery->mix_limit = true;
534 /* skip other heating control */
535 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL,
536 SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL);
537 } else if (battery->mix_limit) {
538 battery->mix_limit = false;
539 }
540
541 pr_info("%s: mix_limit(%d), temp(%d), chg_temp(%d), input_current(%d)\n",
542 __func__, battery->mix_limit, battery->temperature, battery->chg_temp, input_current);
543 } else {
544 battery->mix_limit = false;
545 }
546 return input_current;
547 }
548
549 static int sec_bat_check_wpc_temp(struct sec_battery_info *battery, int input_current)
550 {
551 if (is_wireless_type(battery->cable_type)) {
552 int wpc_vout_level = WIRELESS_VOUT_10V;
553
554 if (battery->siop_level >= 100) {
555 int temp_val = sec_bat_get_temp_by_temp_control_source(battery,
556 battery->pdata->wpc_temp_control_source);
557
558 if ((!battery->chg_limit && temp_val >= battery->pdata->wpc_high_temp) ||
559 (battery->chg_limit && temp_val > battery->pdata->wpc_high_temp_recovery)) {
560 battery->chg_limit = true;
561 input_current = battery->pdata->wpc_charging_limit_current;
562 wpc_vout_level = WIRELESS_VOUT_5V_STEP;
563 } else if (battery->chg_limit) {
564 battery->chg_limit = false;
565 }
566 } else {
567 if ((is_hv_wireless_type(battery->cable_type) &&
568 battery->cable_type != SEC_BATTERY_CABLE_WIRELESS_HV_VEHICLE) ||
569 battery->cable_type == SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV) {
570 int temp_val = sec_bat_get_temp_by_temp_control_source(battery,
571 battery->pdata->wpc_temp_lcd_on_control_source);
572
573 if ((!battery->chg_limit &&
574 temp_val >= battery->pdata->wpc_lcd_on_high_temp) ||
575 (battery->chg_limit &&
576 temp_val > battery->pdata->wpc_lcd_on_high_temp_rec)) {
577 input_current = battery->pdata->wpc_lcd_on_charging_limit_current;
578 battery->chg_limit = true;
579 wpc_vout_level = (battery->capacity < 95) ?
580 WIRELESS_VOUT_5V_STEP : WIRELESS_VOUT_10V;
581 } else if (battery->chg_limit) {
582 battery->chg_limit = false;
583 }
584 } else if (battery->chg_limit) {
585 battery->chg_limit = false;
586 }
587 }
588
589 if (is_hv_wireless_type(battery->cable_type)) {
590 if (battery->current_event & SEC_BAT_CURRENT_EVENT_SWELLING_MODE)
591 wpc_vout_level = WIRELESS_VOUT_5V_STEP;
592
593 if (wpc_vout_level != battery->wpc_vout_level) {
594 battery->wpc_vout_level = wpc_vout_level;
595 if (battery->current_event & SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK) {
596 pr_info("%s: block to set wpc vout level(%d) because otg on\n",
597 __func__, wpc_vout_level);
598 } else {
599 union power_supply_propval value = {0, };
600
601 value.intval = wpc_vout_level;
602 psy_do_property(battery->pdata->wireless_charger_name, set,
603 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
604 pr_info("%s: change vout level(%d)",
605 __func__, battery->wpc_vout_level);
606 battery->aicl_current = 0; /* reset aicl current */
607 }
608 } else if (battery->wpc_vout_level == WIRELESS_VOUT_10V && !battery->chg_limit)
609 /* reset aicl current to recover current for unexpected aicl during before vout boosting completion */
610 battery->aicl_current = 0;
611 }
612 pr_info("%s: change input_current(%d), vout_level(%d), chg_limit(%d)\n",
613 __func__, input_current, battery->wpc_vout_level, battery->chg_limit);
614 }
615
616 return input_current;
617 }
618
619 static void sec_bat_check_afc_temp(struct sec_battery_info *battery, int *input_current, int *charging_current)
620 {
621 #if defined(CONFIG_MUIC_HV) || defined(CONFIG_SUPPORT_QC30)
622 if (battery->siop_level >= 100) {
623 if (battery->current_event & SEC_BAT_CURRENT_EVENT_CHG_LIMIT) {
624 battery->chg_limit = battery->vbus_chg_by_siop = false;
625 *input_current = battery->pdata->pre_afc_input_current;
626 {
627 /* change input current */
628 union power_supply_propval value;
629 battery->charge_power = battery->input_voltage * (*input_current);
630 value.intval = *input_current;
631 psy_do_property(battery->pdata->charger_name, set,
632 POWER_SUPPLY_PROP_CURRENT_MAX, value);
633 battery->input_current = *input_current;
634 }
635 /* set current event */
636 cancel_delayed_work(&battery->afc_work);
637 wake_unlock(&battery->afc_wake_lock);
638 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_AFC,
639 (SEC_BAT_CURRENT_EVENT_CHG_LIMIT | SEC_BAT_CURRENT_EVENT_AFC));
640 /* vbus level : 5V --> 9V */
641 if (battery->chg_limit_recovery_cable == SEC_BATTERY_CABLE_12V_TA) {
642 muic_afc_set_voltage(SEC_INPUT_VOLTAGE_12V);
643 } else if (battery->chg_limit_recovery_cable == SEC_BATTERY_CABLE_9V_TA) {
644 muic_afc_set_voltage(SEC_INPUT_VOLTAGE_9V);
645 } else
646 pr_info("%s: cable_type(%d), chg_limit_recovery_cable(%d) vbus_by_siop(%d)\n", __func__,
647 battery->cable_type, battery->chg_limit_recovery_cable, battery->vbus_chg_by_siop);
648 } else if (!battery->chg_limit && is_hv_wire_type(battery->cable_type) && (battery->chg_temp > battery->pdata->chg_high_temp)) {
649 *input_current = battery->pdata->chg_input_limit_current;
650 *charging_current = battery->pdata->chg_charging_limit_current;
651 battery->chg_limit = true;
652 } else if (!battery->chg_limit && battery->max_charge_power >= (battery->pdata->pd_charging_charge_power - 500) && (battery->chg_temp > battery->pdata->chg_high_temp)) {
653 *input_current = battery->pdata->default_input_current;
654 *charging_current = battery->pdata->default_charging_current;
655 battery->chg_limit = true;
656 } else if (battery->chg_limit && is_hv_wire_type(battery->cable_type)) {
657 if (battery->chg_temp < battery->pdata->chg_high_temp_recovery) {
658 *input_current = battery->pdata->charging_current[battery->cable_type].input_current_limit;
659 *charging_current = battery->pdata->charging_current[battery->cable_type].fast_charging_current;
660 battery->chg_limit = false;
661 } else {
662 *input_current = battery->pdata->chg_input_limit_current;
663 *charging_current = battery->pdata->chg_charging_limit_current;
664 battery->chg_limit = true;
665 }
666 } else if (battery->chg_limit && battery->max_charge_power >= (battery->pdata->pd_charging_charge_power - 500)) {
667 if (battery->chg_temp < battery->pdata->chg_high_temp_recovery) {
668 *input_current = battery->pdata->charging_current[battery->cable_type].input_current_limit;
669 *charging_current = battery->pdata->charging_current[battery->cable_type].fast_charging_current;
670 battery->chg_limit = false;
671 } else {
672 *input_current = battery->pdata->chg_input_limit_current;
673 *charging_current = battery->pdata->chg_charging_limit_current;
674 battery->chg_limit = true;
675 }
676 }
677 pr_info("%s: cable_type(%d), chg_limit(%d) vbus_by_siop(%d)\n", __func__,
678 battery->cable_type, battery->chg_limit, battery->vbus_chg_by_siop);
679 } else if (is_hv_wire_type(battery->cable_type) && is_hv_wire_type(battery->wire_status) &&
680 !battery->store_mode && (battery->cable_type != SEC_BATTERY_CABLE_QC30) &&
681 (battery->status == POWER_SUPPLY_STATUS_CHARGING) && !battery->vbus_chg_by_siop) {
682 battery->chg_limit_recovery_cable = battery->cable_type;
683 battery->vbus_chg_by_siop = true;
684 battery->chg_limit = false;
685 /* vbus level : 9V --> 5V */
686 muic_afc_set_voltage(SEC_INPUT_VOLTAGE_5V);
687 pr_info("%s: vbus set 5V by siop(recovery cable: %d)\n", __func__,battery->chg_limit_recovery_cable);
688 }
689 #else
690 if (!battery->chg_limit && is_hv_wire_type(battery->cable_type) && (battery->chg_temp > battery->pdata->chg_high_temp)) {
691 *input_current = battery->pdata->chg_input_limit_current;
692 *charging_current = battery->pdata->chg_charging_limit_current;
693 battery->chg_limit = true;
694 } else if (battery->chg_limit && is_hv_wire_type(battery->cable_type) && (battery->chg_temp < battery->pdata->chg_high_temp_recovery)) {
695 *input_current = battery->pdata->charging_current[battery->cable_type].input_current_limit;
696 *charging_current = battery->pdata->charging_current[battery->cable_type].fast_charging_current;
697 battery->chg_limit = false;
698 }
699 #endif
700 }
701
702 #if defined(CONFIG_CCIC_NOTIFIER)
703 extern void select_pdo(int num);
704 static int sec_bat_check_pdic_temp(struct sec_battery_info *battery, int input_current)
705 {
706 if (battery->pdic_ps_rdy && battery->siop_level >= 100) {
707
708 struct sec_bat_pdic_list *pd_list = &battery->pd_list;
709 int pd_index = pd_list->now_pd_index;
710
711 if (!battery->chg_limit) {
712 if (battery->chg_temp >= battery->pdata->chg_high_temp) {
713 battery->chg_limit = true;
714 pd_index--;
715 } else
716 pd_index++;
717 } else {
718 if (battery->chg_temp <= battery->pdata->chg_high_temp_recovery)
719 battery->chg_limit = false;
720 else if (battery->chg_temp >= battery->pdata->chg_high_temp)
721 pd_index--;
722 }
723
724 if (pd_index < 0) {
725 if (battery->chg_limit) {
726 input_current = (input_current > (battery->pdata->nv_charge_power / (pd_list->pd_info[0].input_voltage / 1000))) ?
727 (battery->pdata->nv_charge_power / (pd_list->pd_info[0].input_voltage / 1000)) : input_current;
728 pd_index = -1;
729 } else {
730 pd_index = 0;
731 }
732 pd_list->now_pd_index = pd_index;
733 } else {
734 pd_index =
735 (pd_index >= pd_list->max_pd_count) ? (pd_list->max_pd_count - 1) : pd_index;
736
737 if (pd_list->now_pd_index != pd_index) {
738 /* change input current before request new pdo
739 * if new pdo's input current is less than now
740 */
741 if (pd_list->pd_info[pd_index].input_current < input_current) {
742 union power_supply_propval value = {0, };
743
744 input_current = pd_list->pd_info[pd_index].input_current;
745 value.intval = input_current;
746 battery->input_current = input_current;
747 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_SELECT_PDO,
748 SEC_BAT_CURRENT_EVENT_SELECT_PDO);
749 psy_do_property(battery->pdata->charger_name, set,
750 POWER_SUPPLY_PROP_CURRENT_MAX, value);
751 }
752 /* select next pdo */
753 battery->pdic_ps_rdy = false;
754 select_pdo(pd_list->pd_info[pd_index].pdo_index);
755 pr_info("%s: change pd_list - index: %d, pdo_index: %d\n",
756 __func__, pd_index, pd_list->pd_info[pd_index].pdo_index);
757 }
758 }
759 pr_info("%s: pd_index(%d), input_current(%d), chg_limit(%d)\n",
760 __func__, pd_index, input_current, battery->chg_limit);
761 }
762
763 return input_current;
764 }
765
766 static int sec_bat_check_pd_input_current(struct sec_battery_info *battery, int input_current)
767 {
768 if (battery->current_event & SEC_BAT_CURRENT_EVENT_SELECT_PDO) {
769 input_current = battery->input_current;
770 pr_info("%s: change input_current(%d), cable_type(%d)\n", __func__, input_current, battery->cable_type);
771 }
772
773 return input_current;
774 }
775 #endif
776 #endif
777
778 static int sec_bat_check_afc_input_current(struct sec_battery_info *battery, int input_current)
779 {
780 if (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC) {
781 int work_delay = 0;
782
783 if (!is_wireless_type(battery->cable_type)) {
784 input_current = battery->pdata->pre_afc_input_current; // 1000mA
785 work_delay = battery->pdata->pre_afc_work_delay;
786 } else {
787 input_current = battery->pdata->pre_wc_afc_input_current;
788 /* do not reduce this time, this is for noble pad */
789 work_delay = battery->pdata->pre_wc_afc_work_delay;
790 }
791
792 wake_lock(&battery->afc_wake_lock);
793 if (!delayed_work_pending(&battery->afc_work))
794 queue_delayed_work(battery->monitor_wqueue,
795 &battery->afc_work , msecs_to_jiffies(work_delay));
796
797 pr_info("%s: change input_current(%d), cable_type(%d)\n", __func__, input_current, battery->cable_type);
798 }
799
800 return input_current;
801 }
802
803 #if defined(CONFIG_CCIC_NOTIFIER)
804 static void sec_bat_get_input_current_in_power_list(struct sec_battery_info *battery)
805 {
806 int pdo_num = battery->pdic_info.sink_status.current_pdo_num;
807 int max_input_current = 0;
808
809 max_input_current = battery->pdata->charging_current[SEC_BATTERY_CABLE_PDIC].input_current_limit =
810 battery->pdic_info.sink_status.power_list[pdo_num].max_current;
811
812 pr_info("%s:max_input_current : %dmA\n", __func__, max_input_current);
813 }
814
815 static void sec_bat_get_charging_current_in_power_list(struct sec_battery_info *battery)
816 {
817 int max_charging_current = 0;
818 int pdo_num = battery->pdic_info.sink_status.current_pdo_num;
819 int pd_power = (battery->pdic_info.sink_status.power_list[pdo_num].max_voltage *
820 battery->pdic_info.sink_status.power_list[pdo_num].max_current);
821
822 /* We assume that output voltage to float voltage */
823 max_charging_current = pd_power / (battery->pdata->chg_float_voltage / battery->pdata->chg_float_voltage_conv);
824 max_charging_current = max_charging_current > battery->pdata->max_charging_current ?
825 battery->pdata->max_charging_current : max_charging_current;
826 battery->pdata->charging_current[SEC_BATTERY_CABLE_PDIC].fast_charging_current = max_charging_current;
827 battery->charge_power = pd_power;
828
829 pr_info("%s:pd_charge_power : %dmW, max_charging_current : %dmA\n", __func__,
830 battery->charge_power, max_charging_current);
831 }
832 #endif
833
834 static int sec_bat_set_charging_current(struct sec_battery_info *battery)
835 {
836 static int afc_init = false;
837 union power_supply_propval value = {0, };
838 int input_current = battery->pdata->charging_current[battery->cable_type].input_current_limit,
839 charging_current = battery->pdata->charging_current[battery->cable_type].fast_charging_current,
840 topoff_current = battery->pdata->full_check_current_1st;
841 #if !defined(CONFIG_SEC_FACTORY)
842 int temp = 0;
843 #endif
844
845 if (battery->aicl_current)
846 input_current = battery->aicl_current;
847 mutex_lock(&battery->iolock);
848 if (battery->cable_type == SEC_BATTERY_CABLE_NONE) {
849 } else {
850 #if !defined(CONFIG_SEC_FACTORY)
851 if (!(battery->current_event & SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL)) {
852 input_current = sec_bat_check_mix_temp(battery, input_current);
853 }
854 #endif
855
856 /* check input current */
857 #if !defined(CONFIG_SEC_FACTORY)
858 if (!(battery->current_event & SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL)) {
859 if (is_wireless_type(battery->cable_type) && battery->pdata->wpc_temp_check) {
860 temp = sec_bat_check_wpc_temp(battery, input_current);
861 if (input_current > temp)
862 input_current = temp;
863 }
864 #if defined(CONFIG_CCIC_NOTIFIER)
865 else if (battery->cable_type == SEC_BATTERY_CABLE_PDIC && battery->pdata->chg_temp_check) {
866 input_current = sec_bat_check_pdic_temp(battery, input_current);
867 input_current = sec_bat_check_pd_input_current(battery, input_current);
868 }
869 #endif
870 else if (battery->pdata->chg_temp_check)
871 sec_bat_check_afc_temp(battery, &input_current, &charging_current);
872 }
873 #endif
874
875 input_current = sec_bat_check_afc_input_current(battery, input_current);
876 /* Set limited max current with hv wire cable when store mode is set and LDU
877 Limited max current should be set with over 5% capacity since target could be turned off during boot up */
878 if (battery->store_mode && is_hv_wire_type(battery->wire_status) && (battery->capacity >= 5)) {
879 input_current = battery->pdata->store_mode_afc_input_current;
880 }
881
882 sec_bat_get_charging_current_by_siop(battery, &input_current, &charging_current);
883
884 /* Calculate wireless input current under the specific conditions (wpc_sleep_mode, chg_limit)*/
885 if (battery->wc_status != SEC_WIRELESS_PAD_NONE) {
886 input_current = sec_bat_get_wireless_current(battery, input_current);
887 }
888
889 /* check topoff current */
890 if (battery->charging_mode == SEC_BATTERY_CHARGING_2ND &&
891 battery->pdata->full_check_type_2nd == SEC_BATTERY_FULLCHARGED_CHGPSY) {
892 topoff_current =
893 battery->pdata->full_check_current_2nd;
894 }
895
896 /* check swelling state */
897 if (is_wireless_type(battery->cable_type)) {
898 if (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING) {
899 charging_current = (charging_current > battery->pdata->swelling_wc_low_temp_current) ?
900 battery->pdata->swelling_wc_low_temp_current : charging_current;
901 topoff_current = (topoff_current > battery->pdata->swelling_low_temp_topoff) ?
902 battery->pdata->swelling_low_temp_topoff : topoff_current;
903 } else if (battery->current_event & SEC_BAT_CURRENT_EVENT_HIGH_TEMP_SWELLING) {
904 charging_current = (charging_current > battery->pdata->swelling_wc_high_temp_current) ?
905 battery->pdata->swelling_wc_high_temp_current : charging_current;
906 topoff_current = (topoff_current > battery->pdata->swelling_high_temp_topoff) ?
907 battery->pdata->swelling_high_temp_topoff : topoff_current;
908 } else if (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP) {
909 charging_current = (charging_current > battery->pdata->swelling_wc_low_temp_current) ?
910 battery->pdata->swelling_wc_low_temp_current : charging_current;
911 }
912 } else {
913 if (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING) {
914 charging_current = (charging_current > battery->pdata->swelling_low_temp_current) ?
915 battery->pdata->swelling_low_temp_current : charging_current;
916 topoff_current = (topoff_current > battery->pdata->swelling_low_temp_topoff) ?
917 battery->pdata->swelling_low_temp_topoff : topoff_current;
918 } else if (battery->current_event & SEC_BAT_CURRENT_EVENT_HIGH_TEMP_SWELLING) {
919 charging_current = (charging_current > battery->pdata->swelling_high_temp_current) ?
920 battery->pdata->swelling_high_temp_current : charging_current;
921 topoff_current = (topoff_current > battery->pdata->swelling_high_temp_topoff) ?
922 battery->pdata->swelling_high_temp_topoff : topoff_current;
923 } else if (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP) {
924 charging_current = (charging_current > battery->pdata->swelling_low_temp_current) ?
925 battery->pdata->swelling_low_temp_current : charging_current;
926 }
927
928 /* usb unconfigured or suspend*/
929 if ((battery->cable_type == SEC_BATTERY_CABLE_USB) && !lpcharge &&
930 (battery->pdic_info.sink_status.rp_currentlvl == RP_CURRENT_LEVEL_DEFAULT)) {
931 if (battery->current_event & SEC_BAT_CURRENT_EVENT_USB_100MA) {
932 pr_info("%s: usb unconfigured\n", __func__);
933 input_current = USB_CURRENT_UNCONFIGURED;
934 charging_current = USB_CURRENT_UNCONFIGURED;
935 }
936 }
937 }
938 }
939
940 /* In wireless charging, must be set charging current before input current. */
941 if (is_wireless_type(battery->cable_type) &&
942 battery->charging_current != charging_current) {
943 value.intval = charging_current;
944 psy_do_property(battery->pdata->charger_name, set,
945 POWER_SUPPLY_PROP_CURRENT_AVG, value);
946 battery->charging_current = charging_current;
947 }
948 /* set input current, charging current */
949 if ((battery->input_current != input_current) ||
950 (battery->charging_current != charging_current)) {
951 /* update charge power */
952 battery->charge_power = battery->input_voltage * input_current;
953 if (battery->charge_power > battery->max_charge_power)
954 battery->max_charge_power = battery->charge_power;
955
956 value.intval = input_current;
957 psy_do_property(battery->pdata->charger_name, set,
958 POWER_SUPPLY_PROP_CURRENT_MAX, value);
959 battery->input_current = input_current;
960
961 value.intval = charging_current;
962 psy_do_property(battery->pdata->charger_name, set,
963 POWER_SUPPLY_PROP_CURRENT_NOW, value);
964
965 if (charging_current <= 100)
966 battery->charging_current = 100;
967 else
968 battery->charging_current = charging_current;
969 pr_info("%s: power(%d), input(%d), charge(%d)\n", __func__,
970 battery->charge_power, battery->input_current, battery->charging_current);
971 }
972
973 /* set topoff current */
974 if (battery->topoff_current != topoff_current) {
975 value.intval = topoff_current;
976 psy_do_property(battery->pdata->charger_name, set,
977 POWER_SUPPLY_PROP_CURRENT_FULL, value);
978 battery->topoff_current = topoff_current;
979 }
980 if (!afc_init) {
981 afc_init = true;
982 #if defined(CONFIG_AFC_CHARGER_MODE)
983 value.intval = 1;
984 psy_do_property(battery->pdata->charger_name, set,
985 POWER_SUPPLY_PROP_AFC_CHARGER_MODE,
986 value);
987 #endif
988 }
989 mutex_unlock(&battery->iolock);
990 return 0;
991 }
992
993 static int sec_bat_set_charge(
994 struct sec_battery_info *battery,
995 int chg_mode)
996 {
997 union power_supply_propval val = {0, };
998 ktime_t current_time = {0, };
999 struct timespec ts = {0, };
1000
1001 if (battery->cable_type == SEC_BATTERY_CABLE_HMT_CONNECTED)
1002 return 0;
1003
1004 if ((battery->current_event & SEC_BAT_CURRENT_EVENT_CHARGE_DISABLE) &&
1005 (chg_mode == SEC_BAT_CHG_MODE_CHARGING)) {
1006 dev_info(battery->dev, "%s: charge disable by HMT\n", __func__);
1007 chg_mode = SEC_BAT_CHG_MODE_CHARGING_OFF;
1008 }
1009
1010 battery->charger_mode = chg_mode;
1011 pr_info("%s set %s mode\n", __func__, sec_bat_charge_mode_str[chg_mode]);
1012
1013 val.intval = battery->status;
1014 psy_do_property(battery->pdata->charger_name, set,
1015 POWER_SUPPLY_PROP_STATUS, val);
1016 current_time = ktime_get_boottime();
1017 ts = ktime_to_timespec(current_time);
1018
1019 if (chg_mode == SEC_BAT_CHG_MODE_CHARGING) {
1020 /*Reset charging start time only in initial charging start */
1021 if (battery->charging_start_time == 0) {
1022 if (ts.tv_sec < 1)
1023 ts.tv_sec = 1;
1024 battery->charging_start_time = ts.tv_sec;
1025 battery->charging_next_time =
1026 battery->pdata->charging_reset_time;
1027 }
1028 battery->charging_block = false;
1029
1030 #if defined(CONFIG_BATTERY_SBM_DATA)
1031 sec_bat_add_sbm_data(battery, SBM_DATA_SET_CHARGE);
1032 #endif
1033 } else {
1034 battery->charging_start_time = 0;
1035 battery->charging_passed_time = 0;
1036 battery->charging_next_time = 0;
1037 battery->charging_fullcharged_time = 0;
1038 battery->full_check_cnt = 0;
1039 battery->charging_block = true;
1040 #if defined(CONFIG_STEP_CHARGING)
1041 sec_bat_reset_step_charging(battery);
1042 #endif
1043 #if defined(CONFIG_BATTERY_CISD)
1044 battery->usb_overheat_check = false;
1045 battery->cisd.ab_vbat_check_count = 0;
1046 if (chg_mode == SEC_BAT_CHG_MODE_BUCK_OFF) {
1047 battery->cisd.data[CISD_DATA_BUCK_OFF]++;
1048 battery->cisd.data[CISD_DATA_BUCK_OFF_PER_DAY]++;
1049 }
1050 #endif
1051 }
1052
1053 battery->temp_highlimit_cnt = 0;
1054 battery->temp_high_cnt = 0;
1055 battery->temp_low_cnt = 0;
1056 battery->temp_recover_cnt = 0;
1057
1058 val.intval = chg_mode;
1059 psy_do_property(battery->pdata->charger_name, set,
1060 POWER_SUPPLY_PROP_CHARGING_ENABLED, val);
1061
1062 return 0;
1063 }
1064
1065 static bool sec_bat_check_by_psy(struct sec_battery_info *battery)
1066 {
1067 char *psy_name = NULL;
1068 union power_supply_propval value = {0, };
1069 bool ret = true;
1070
1071 switch (battery->pdata->battery_check_type) {
1072 case SEC_BATTERY_CHECK_PMIC:
1073 psy_name = battery->pdata->pmic_name;
1074 break;
1075 case SEC_BATTERY_CHECK_FUELGAUGE:
1076 psy_name = battery->pdata->fuelgauge_name;
1077 break;
1078 case SEC_BATTERY_CHECK_CHARGER:
1079 psy_name = battery->pdata->charger_name;
1080 break;
1081 default:
1082 dev_err(battery->dev,
1083 "%s: Invalid Battery Check Type\n", __func__);
1084 ret = false;
1085 goto battery_check_error;
1086 break;
1087 }
1088
1089 psy_do_property(psy_name, get,
1090 POWER_SUPPLY_PROP_PRESENT, value);
1091 ret = (bool)value.intval;
1092
1093 battery_check_error:
1094 return ret;
1095 }
1096
1097 static bool sec_bat_check(struct sec_battery_info *battery)
1098 {
1099 bool ret = true;
1100
1101 if (battery->factory_mode || battery->is_jig_on) {
1102 dev_dbg(battery->dev, "%s: No need to check in factory mode\n",
1103 __func__);
1104 return ret;
1105 }
1106
1107 if (battery->health != POWER_SUPPLY_HEALTH_GOOD &&
1108 battery->health != POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
1109 dev_dbg(battery->dev, "%s: No need to check\n", __func__);
1110 return ret;
1111 }
1112
1113 switch (battery->pdata->battery_check_type) {
1114 case SEC_BATTERY_CHECK_ADC:
1115 if(battery->cable_type == SEC_BATTERY_CABLE_NONE)
1116 ret = battery->present;
1117 else
1118 ret = sec_bat_check_vf_adc(battery);
1119 break;
1120 case SEC_BATTERY_CHECK_INT:
1121 case SEC_BATTERY_CHECK_CALLBACK:
1122 if(battery->cable_type == SEC_BATTERY_CABLE_NONE) {
1123 ret = battery->present;
1124 } else {
1125 if (battery->pdata->check_battery_callback)
1126 ret = battery->pdata->check_battery_callback();
1127 }
1128 break;
1129 case SEC_BATTERY_CHECK_PMIC:
1130 case SEC_BATTERY_CHECK_FUELGAUGE:
1131 case SEC_BATTERY_CHECK_CHARGER:
1132 ret = sec_bat_check_by_psy(battery);
1133 break;
1134 case SEC_BATTERY_CHECK_NONE:
1135 dev_dbg(battery->dev, "%s: No Check\n", __func__);
1136 default:
1137 break;
1138 }
1139
1140 return ret;
1141 }
1142
1143 static bool sec_bat_get_cable_type(
1144 struct sec_battery_info *battery,
1145 int cable_source_type)
1146 {
1147 bool ret = false;
1148 int cable_type = battery->cable_type;
1149
1150 if (cable_source_type & SEC_BATTERY_CABLE_SOURCE_CALLBACK) {
1151 if (battery->pdata->check_cable_callback)
1152 cable_type =
1153 battery->pdata->check_cable_callback();
1154 }
1155
1156 if (cable_source_type & SEC_BATTERY_CABLE_SOURCE_ADC) {
1157 if (gpio_get_value_cansleep(
1158 battery->pdata->bat_gpio_ta_nconnected) ^
1159 battery->pdata->bat_polarity_ta_nconnected)
1160 cable_type = SEC_BATTERY_CABLE_NONE;
1161 else
1162 cable_type =
1163 sec_bat_get_charger_type_adc(battery);
1164 }
1165
1166 if (battery->cable_type == cable_type) {
1167 dev_dbg(battery->dev,
1168 "%s: No need to change cable status\n", __func__);
1169 } else {
1170 if (cable_type < SEC_BATTERY_CABLE_NONE ||
1171 cable_type >= SEC_BATTERY_CABLE_MAX) {
1172 dev_err(battery->dev,
1173 "%s: Invalid cable type\n", __func__);
1174 } else {
1175 battery->cable_type = cable_type;
1176 if (battery->pdata->check_cable_result_callback)
1177 battery->pdata->check_cable_result_callback(
1178 battery->cable_type);
1179
1180 ret = true;
1181
1182 dev_dbg(battery->dev, "%s: Cable Changed (%d)\n",
1183 __func__, battery->cable_type);
1184 }
1185 }
1186
1187 return ret;
1188 }
1189
1190 static void sec_bat_set_charging_status(struct sec_battery_info *battery,
1191 int status) {
1192 union power_supply_propval value = {0, };
1193
1194 switch (status) {
1195 case POWER_SUPPLY_STATUS_CHARGING:
1196 if (battery->siop_level != 100)
1197 battery->stop_timer = true;
1198 break;
1199 case POWER_SUPPLY_STATUS_NOT_CHARGING:
1200 case POWER_SUPPLY_STATUS_DISCHARGING:
1201 if ((battery->status == POWER_SUPPLY_STATUS_FULL ||
1202 (battery->capacity == 100 && !battery->slate_mode)) &&
1203 !battery->store_mode) {
1204 value.intval = 100;
1205 psy_do_property(battery->pdata->fuelgauge_name, set,
1206 POWER_SUPPLY_PROP_CHARGE_FULL, value);
1207 /* To get SOC value (NOT raw SOC), need to reset value */
1208 value.intval = 0;
1209 psy_do_property(battery->pdata->fuelgauge_name, get,
1210 POWER_SUPPLY_PROP_CAPACITY, value);
1211 battery->capacity = value.intval;
1212 }
1213 battery->expired_time = battery->pdata->expired_time;
1214 battery->prev_safety_time = 0;
1215 break;
1216 case POWER_SUPPLY_STATUS_FULL:
1217 if (is_wireless_type(battery->cable_type)) {
1218 bool send_cs100_cmd = true;
1219
1220 #ifdef CONFIG_CS100_JPNCONCEPT
1221 psy_do_property(battery->pdata->wireless_charger_name, get,
1222 POWER_SUPPLY_EXT_PROP_WIRELESS_TX_ID, value);
1223
1224 /* In case of the JPN PAD, this pad blocks the charge after give the cs100 command. */
1225 send_cs100_cmd = (battery->charging_mode == SEC_BATTERY_CHARGING_2ND || value.intval);
1226 #endif
1227 if (send_cs100_cmd) {
1228 value.intval = POWER_SUPPLY_STATUS_FULL;
1229 psy_do_property(battery->pdata->wireless_charger_name, set,
1230 POWER_SUPPLY_PROP_STATUS, value);
1231 }
1232 }
1233 break;
1234 default:
1235 break;
1236 }
1237 battery->status = status;
1238 }
1239
1240 static bool sec_bat_battery_cable_check(struct sec_battery_info *battery)
1241 {
1242 if (!sec_bat_check(battery)) {
1243 if (battery->check_count < battery->pdata->check_count)
1244 battery->check_count++;
1245 else {
1246 dev_err(battery->dev,
1247 "%s: Battery Disconnected\n", __func__);
1248 battery->present = false;
1249 battery->health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1250
1251 if (battery->status !=
1252 POWER_SUPPLY_STATUS_DISCHARGING) {
1253 sec_bat_set_charging_status(battery,
1254 POWER_SUPPLY_STATUS_NOT_CHARGING);
1255 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
1256 }
1257
1258 if (battery->pdata->check_battery_result_callback)
1259 battery->pdata->
1260 check_battery_result_callback();
1261 return false;
1262 }
1263 } else
1264 battery->check_count = 0;
1265
1266 battery->present = true;
1267
1268 if (battery->health == POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
1269 battery->health = POWER_SUPPLY_HEALTH_GOOD;
1270
1271 if (battery->status == POWER_SUPPLY_STATUS_NOT_CHARGING) {
1272 sec_bat_set_charging_status(battery,
1273 POWER_SUPPLY_STATUS_CHARGING);
1274 #if defined(CONFIG_BATTERY_SWELLING)
1275 if (!battery->swelling_mode)
1276 #endif
1277 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
1278 }
1279 }
1280
1281 dev_dbg(battery->dev, "%s: Battery Connected\n", __func__);
1282
1283 if (battery->pdata->cable_check_type &
1284 SEC_BATTERY_CABLE_CHECK_POLLING) {
1285 if (sec_bat_get_cable_type(battery,
1286 battery->pdata->cable_source_type)) {
1287 wake_lock(&battery->cable_wake_lock);
1288 queue_delayed_work(battery->monitor_wqueue,
1289 &battery->cable_work, 0);
1290 }
1291 }
1292 return true;
1293 }
1294
1295 static int sec_bat_ovp_uvlo_by_psy(struct sec_battery_info *battery)
1296 {
1297 char *psy_name = NULL;
1298 union power_supply_propval value = {0, };
1299
1300 value.intval = POWER_SUPPLY_HEALTH_GOOD;
1301
1302 switch (battery->pdata->ovp_uvlo_check_type) {
1303 case SEC_BATTERY_OVP_UVLO_PMICPOLLING:
1304 psy_name = battery->pdata->pmic_name;
1305 break;
1306 case SEC_BATTERY_OVP_UVLO_CHGPOLLING:
1307 psy_name = battery->pdata->charger_name;
1308 break;
1309 default:
1310 dev_err(battery->dev,
1311 "%s: Invalid OVP/UVLO Check Type\n", __func__);
1312 goto ovp_uvlo_check_error;
1313 break;
1314 }
1315
1316 psy_do_property(psy_name, get,
1317 POWER_SUPPLY_PROP_HEALTH, value);
1318
1319 ovp_uvlo_check_error:
1320 return value.intval;
1321 }
1322
1323 static bool sec_bat_ovp_uvlo_result(
1324 struct sec_battery_info *battery, int health)
1325 {
1326 if (battery->health != health) {
1327 battery->health = health;
1328 switch (health) {
1329 case POWER_SUPPLY_HEALTH_GOOD:
1330 dev_info(battery->dev, "%s: Safe voltage\n", __func__);
1331 dev_info(battery->dev, "%s: is_recharging : %d\n", __func__, battery->is_recharging);
1332 sec_bat_set_charging_status(battery,
1333 POWER_SUPPLY_STATUS_CHARGING);
1334 battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
1335 #if defined(CONFIG_BATTERY_SWELLING)
1336 if (!battery->swelling_mode)
1337 #endif
1338 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
1339 battery->health_check_count = 0;
1340 break;
1341 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1342 case POWER_SUPPLY_HEALTH_UNDERVOLTAGE:
1343 dev_info(battery->dev,
1344 "%s: Unsafe voltage (%d)\n",
1345 __func__, health);
1346 sec_bat_set_charging_status(battery,
1347 POWER_SUPPLY_STATUS_NOT_CHARGING);
1348 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
1349 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1350 battery->is_recharging = false;
1351 battery->health_check_count = DEFAULT_HEALTH_CHECK_COUNT;
1352 #if defined(CONFIG_BATTERY_CISD)
1353 battery->cisd.data[CISD_DATA_UNSAFETY_VOLTAGE]++;
1354 battery->cisd.data[CISD_DATA_UNSAFE_VOLTAGE_PER_DAY]++;
1355 #endif
1356 /* Take the wakelock during 10 seconds
1357 when over-voltage status is detected */
1358 wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
1359 break;
1360 }
1361 power_supply_changed(battery->psy_bat);
1362 return true;
1363 }
1364
1365 return false;
1366 }
1367
1368 static bool sec_bat_ovp_uvlo(struct sec_battery_info *battery)
1369 {
1370 int health = POWER_SUPPLY_HEALTH_GOOD;
1371
1372 if (battery->wdt_kick_disable) {
1373 dev_dbg(battery->dev,
1374 "%s: No need to check in wdt test\n",
1375 __func__);
1376 return false;
1377 } else if ((battery->status == POWER_SUPPLY_STATUS_FULL) &&
1378 (battery->charging_mode == SEC_BATTERY_CHARGING_NONE)) {
1379 dev_dbg(battery->dev, "%s: No need to check in Full status", __func__);
1380 return false;
1381 }
1382
1383 if (battery->health != POWER_SUPPLY_HEALTH_GOOD &&
1384 battery->health != POWER_SUPPLY_HEALTH_OVERVOLTAGE &&
1385 battery->health != POWER_SUPPLY_HEALTH_UNDERVOLTAGE) {
1386 dev_dbg(battery->dev, "%s: No need to check\n", __func__);
1387 return false;
1388 }
1389
1390 health = battery->health;
1391
1392 switch (battery->pdata->ovp_uvlo_check_type) {
1393 case SEC_BATTERY_OVP_UVLO_CALLBACK:
1394 if (battery->pdata->ovp_uvlo_callback)
1395 health = battery->pdata->ovp_uvlo_callback();
1396 break;
1397 case SEC_BATTERY_OVP_UVLO_PMICPOLLING:
1398 case SEC_BATTERY_OVP_UVLO_CHGPOLLING:
1399 health = sec_bat_ovp_uvlo_by_psy(battery);
1400 break;
1401 case SEC_BATTERY_OVP_UVLO_PMICINT:
1402 case SEC_BATTERY_OVP_UVLO_CHGINT:
1403 /* nothing for interrupt check */
1404 default:
1405 break;
1406 }
1407
1408 /* Move the location for calling the get_health
1409 in case of attaching the jig */
1410 if (battery->factory_mode || battery->is_jig_on) {
1411 dev_dbg(battery->dev,
1412 "%s: No need to check in factory mode\n",
1413 __func__);
1414 return false;
1415 }
1416
1417 return sec_bat_ovp_uvlo_result(battery, health);
1418 }
1419
1420 static bool sec_bat_check_recharge(struct sec_battery_info *battery)
1421 {
1422 #if defined(CONFIG_BATTERY_SWELLING)
1423 if (battery->swelling_mode == SWELLING_MODE_CHARGING ||
1424 battery->swelling_mode == SWELLING_MODE_FULL) {
1425 pr_info("%s: Skip normal recharge check routine for swelling mode\n",
1426 __func__);
1427 return false;
1428 }
1429 #endif
1430 if ((battery->status == POWER_SUPPLY_STATUS_CHARGING) &&
1431 (battery->pdata->full_condition_type &
1432 SEC_BATTERY_FULL_CONDITION_NOTIMEFULL) &&
1433 (battery->charging_mode == SEC_BATTERY_CHARGING_NONE)) {
1434 dev_info(battery->dev,
1435 "%s: Re-charging by NOTIMEFULL (%d)\n",
1436 __func__, battery->capacity);
1437 goto check_recharge_check_count;
1438 }
1439
1440 if (battery->status == POWER_SUPPLY_STATUS_FULL &&
1441 battery->charging_mode == SEC_BATTERY_CHARGING_NONE) {
1442 int recharging_voltage = battery->pdata->recharge_condition_vcell;
1443 if (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP) {
1444 /* float voltage - 150mV */
1445 recharging_voltage =\
1446 (battery->pdata->chg_float_voltage /\
1447 battery->pdata->chg_float_voltage_conv) - 150;
1448 dev_info(battery->dev, "%s: recharging voltage changed by low temp(%d)\n",
1449 __func__, recharging_voltage);
1450 }
1451 dev_info(battery->dev, "%s: recharging voltage (%d)\n",
1452 __func__, recharging_voltage);
1453
1454 if ((battery->pdata->recharge_condition_type &
1455 SEC_BATTERY_RECHARGE_CONDITION_SOC) &&
1456 (battery->capacity <=
1457 battery->pdata->recharge_condition_soc)) {
1458 battery->expired_time = battery->pdata->recharging_expired_time;
1459 battery->prev_safety_time = 0;
1460 dev_info(battery->dev,
1461 "%s: Re-charging by SOC (%d)\n",
1462 __func__, battery->capacity);
1463 goto check_recharge_check_count;
1464 }
1465
1466 if ((battery->pdata->recharge_condition_type &
1467 SEC_BATTERY_RECHARGE_CONDITION_AVGVCELL) &&
1468 (battery->voltage_avg <= recharging_voltage)) {
1469 battery->expired_time = battery->pdata->recharging_expired_time;
1470 battery->prev_safety_time = 0;
1471 dev_info(battery->dev,
1472 "%s: Re-charging by average VCELL (%d)\n",
1473 __func__, battery->voltage_avg);
1474 goto check_recharge_check_count;
1475 }
1476
1477 if ((battery->pdata->recharge_condition_type &
1478 SEC_BATTERY_RECHARGE_CONDITION_VCELL) &&
1479 (battery->voltage_now <= recharging_voltage)) {
1480 battery->expired_time = battery->pdata->recharging_expired_time;
1481 battery->prev_safety_time = 0;
1482 dev_info(battery->dev,
1483 "%s: Re-charging by VCELL (%d)\n",
1484 __func__, battery->voltage_now);
1485 goto check_recharge_check_count;
1486 }
1487 }
1488
1489 battery->recharge_check_cnt = 0;
1490 return false;
1491
1492 check_recharge_check_count:
1493 if (battery->recharge_check_cnt <
1494 battery->pdata->recharge_check_count)
1495 battery->recharge_check_cnt++;
1496 dev_dbg(battery->dev,
1497 "%s: recharge count = %d\n",
1498 __func__, battery->recharge_check_cnt);
1499
1500 if (battery->recharge_check_cnt >=
1501 battery->pdata->recharge_check_count)
1502 return true;
1503 else
1504 return false;
1505 }
1506
1507 static bool sec_bat_voltage_check(struct sec_battery_info *battery)
1508 {
1509 union power_supply_propval value = {0, };
1510
1511 if (battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
1512 dev_dbg(battery->dev,
1513 "%s: Charging Disabled\n", __func__);
1514 return true;
1515 }
1516
1517 /* OVP/UVLO check */
1518 if (sec_bat_ovp_uvlo(battery)) {
1519 if (battery->pdata->ovp_uvlo_result_callback)
1520 battery->pdata->
1521 ovp_uvlo_result_callback(battery->health);
1522 return false;
1523 }
1524
1525 if ((battery->status == POWER_SUPPLY_STATUS_FULL) &&
1526 #if defined(CONFIG_BATTERY_SWELLING)
1527 (battery->charging_mode == SEC_BATTERY_CHARGING_2ND ||
1528 battery->is_recharging || battery->swelling_mode)) {
1529 #else
1530 (battery->charging_mode == SEC_BATTERY_CHARGING_2ND ||
1531 battery->is_recharging)) {
1532 #endif
1533 value.intval = 0;
1534 psy_do_property(battery->pdata->fuelgauge_name, get,
1535 POWER_SUPPLY_PROP_CAPACITY, value);
1536 if (value.intval <
1537 battery->pdata->full_condition_soc &&
1538 battery->voltage_now <
1539 (battery->pdata->recharge_condition_vcell - 50)) {
1540 sec_bat_set_charging_status(battery,
1541 POWER_SUPPLY_STATUS_CHARGING);
1542 dev_info(battery->dev,
1543 "%s: battery status full -> charging, RepSOC(%d)\n", __func__, value.intval);
1544 return false;
1545 }
1546 }
1547
1548 /* Re-Charging check */
1549 if (sec_bat_check_recharge(battery)) {
1550 if (battery->pdata->full_check_type !=
1551 SEC_BATTERY_FULLCHARGED_NONE)
1552 battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
1553 else
1554 battery->charging_mode = SEC_BATTERY_CHARGING_2ND;
1555 battery->is_recharging = true;
1556 #if defined(CONFIG_BATTERY_CISD)
1557 battery->cisd.recharge_count++;
1558 battery->cisd.recharge_count_2++;
1559 battery->cisd.data[CISD_DATA_RECHARGING_COUNT]++;
1560 battery->cisd.data[CISD_DATA_RECHARGING_COUNT_PER_DAY]++;
1561 #endif
1562 #if defined(CONFIG_BATTERY_SWELLING)
1563 if (!battery->swelling_mode)
1564 #endif
1565 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
1566 return false;
1567 }
1568
1569 return true;
1570 }
1571
1572 #if defined(CONFIG_BATTERY_SWELLING)
1573 static void sec_bat_swelling_check(struct sec_battery_info *battery)
1574 {
1575 union power_supply_propval val = {0, };
1576 int swelling_rechg_voltage = battery->pdata->swelling_high_rechg_voltage;
1577 bool en_swelling = false, en_rechg = false;
1578 int swelling_high_recovery = battery->pdata->swelling_high_temp_recov;
1579
1580 if (is_wireless_type(battery->cable_type)) {
1581 swelling_high_recovery = battery->pdata->swelling_wc_high_temp_recov;
1582 }
1583 pr_info("%s: swelling highblock(%d), highrecov(%d)\n", __func__, battery->pdata->swelling_high_temp_block, swelling_high_recovery);
1584
1585 psy_do_property(battery->pdata->charger_name, get,
1586 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1587
1588 pr_info("%s: status(%d), swell_mode(%d:%d:%d), cv(%d)mV, temp(%d)\n",
1589 __func__, battery->status, battery->swelling_mode,
1590 battery->charging_block, (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP),
1591 val.intval, battery->temperature);
1592
1593 /* swelling_mode
1594 under voltage over voltage, battery missing */
1595 if ((battery->status == POWER_SUPPLY_STATUS_DISCHARGING) ||\
1596 (battery->status == POWER_SUPPLY_STATUS_NOT_CHARGING) ||
1597 battery->skip_swelling) {
1598 pr_debug("%s: DISCHARGING or NOT-CHARGING or 15 test mode. stop swelling mode\n", __func__);
1599 battery->swelling_mode = SWELLING_MODE_NONE;
1600 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1601 goto skip_swelling_check;
1602 }
1603
1604 if (!battery->swelling_mode) {
1605 if (((battery->temperature >= battery->pdata->swelling_high_temp_block) ||
1606 (battery->temperature <= battery->pdata->swelling_low_temp_block_2nd)) &&
1607 battery->pdata->temp_check_type) {
1608 pr_info("%s: swelling mode start. stop charging\n", __func__);
1609 battery->swelling_mode = SWELLING_MODE_CHARGING;
1610 battery->swelling_full_check_cnt = 0;
1611 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
1612
1613 if (battery->temperature >= battery->pdata->swelling_high_temp_block) {
1614 #if defined(CONFIG_BATTERY_CISD)
1615 battery->cisd.data[CISD_DATA_HIGH_TEMP_SWELLING]++;
1616 battery->cisd.data[CISD_DATA_HIGH_TEMP_SWELLING_PER_DAY]++;
1617 #endif
1618 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_HIGH_TEMP_SWELLING,
1619 SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1620 } else if (battery->temperature <= battery->pdata->swelling_low_temp_block_2nd) {
1621 #if defined(CONFIG_BATTERY_CISD)
1622 battery->cisd.data[CISD_DATA_LOW_TEMP_SWELLING]++;
1623 battery->cisd.data[CISD_DATA_LOW_TEMP_SWELLING_PER_DAY]++;
1624 #endif
1625 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING,
1626 SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1627 }
1628 en_swelling = true;
1629 } else if ((battery->temperature <= battery->pdata->swelling_low_temp_block_1st) &&
1630 !(battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP)) {
1631 pr_info("%s: low temperature reduce current\n", __func__);
1632 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_LOW_TEMP,
1633 SEC_BAT_CURRENT_EVENT_LOW_TEMP);
1634 } else if ((battery->temperature >= battery->pdata->swelling_low_temp_recov_1st) &&
1635 (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP)) {
1636 pr_info("%s: normal temperature temperature recover current\n", __func__);
1637 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_LOW_TEMP);
1638 }
1639 }
1640
1641 if (!battery->voltage_now)
1642 return;
1643
1644 if (battery->swelling_mode) {
1645 if (battery->temperature <= battery->pdata->swelling_low_temp_recov_2nd) {
1646 swelling_rechg_voltage = battery->pdata->swelling_low_rechg_voltage;
1647 }
1648
1649 if ((battery->temperature <= swelling_high_recovery) &&
1650 (battery->temperature >= battery->pdata->swelling_low_temp_recov_2nd)) {
1651 pr_info("%s: swelling mode end. restart charging\n", __func__);
1652 battery->swelling_mode = SWELLING_MODE_NONE;
1653 battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
1654 if ((battery->temperature <= battery->pdata->swelling_low_temp_block_1st) ||
1655 ((battery->temperature < battery->pdata->swelling_low_temp_recov_1st) &&
1656 (battery->current_event & SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING))) {
1657 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_LOW_TEMP,
1658 SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1659 } else {
1660 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1661 }
1662 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
1663 /* restore 4.4V float voltage */
1664 val.intval = battery->pdata->swelling_normal_float_voltage;
1665 psy_do_property(battery->pdata->charger_name, set,
1666 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1667 #if defined(CONFIG_BATTERY_CISD)
1668 battery->cisd.data[CISD_DATA_SWELLING_RECOVERY_CNT]++;
1669 battery->cisd.data[CISD_DATA_SWELLING_RECOVERY_CNT_PER_DAY]++;
1670 #endif
1671 } else if (battery->voltage_now < swelling_rechg_voltage &&
1672 battery->charging_block) {
1673 pr_info("%s: swelling mode recharging start. Vbatt(%d)\n",
1674 __func__, battery->voltage_now);
1675 battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
1676 en_rechg = true;
1677 /* change drop float voltage */
1678 val.intval = battery->pdata->swelling_drop_float_voltage;
1679 psy_do_property(battery->pdata->charger_name, set,
1680 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1681 /* set charging enable */
1682 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
1683 if (battery->temperature < battery->pdata->swelling_low_temp_recov_2nd) {
1684 pr_info("%s: swelling mode reduce charging current(LOW-temp:%d)\n",
1685 __func__, battery->temperature);
1686 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING,
1687 SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1688 } else if (battery->temperature > swelling_high_recovery) {
1689 pr_info("%s: swelling mode reduce charging current(HIGH-temp:%d)\n",
1690 __func__, battery->temperature);
1691 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_HIGH_TEMP_SWELLING,
1692 SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
1693 }
1694 #if defined(CONFIG_BATTERY_CISD)
1695 battery->cisd.data[CISD_DATA_SWELLING_CHARGING_COUNT]++;
1696 battery->cisd.data[CISD_DATA_SWELLING_CHARGING_COUNT_PER_DAY]++;
1697 #endif
1698 }
1699 }
1700
1701 if (en_swelling && !en_rechg) {
1702 pr_info("%s : SAFETY TIME RESET (SWELLING MODE CHARING STOP!)\n", __func__);
1703 battery->expired_time = battery->pdata->expired_time;
1704 battery->prev_safety_time = 0;
1705 }
1706
1707 skip_swelling_check:
1708 dev_dbg(battery->dev, "%s end\n", __func__);
1709 }
1710 #endif
1711
1712 #if defined(CONFIG_BATTERY_AGE_FORECAST)
1713 static bool sec_bat_set_aging_step(struct sec_battery_info *battery, int step)
1714 {
1715 union power_supply_propval value = {0, };
1716
1717 if (battery->pdata->num_age_step <= 0 || step < 0 || step >= battery->pdata->num_age_step) {
1718 pr_info("%s: [AGE] abnormal age step : %d/%d\n",
1719 __func__, step, battery->pdata->num_age_step-1);
1720 return false;
1721 }
1722
1723 battery->pdata->age_step = step;
1724
1725 /* float voltage */
1726 battery->pdata->chg_float_voltage =
1727 battery->pdata->age_data[battery->pdata->age_step].float_voltage;
1728 battery->pdata->swelling_normal_float_voltage =
1729 battery->pdata->chg_float_voltage;
1730 if (!battery->swelling_mode) {
1731 value.intval = battery->pdata->chg_float_voltage;
1732 psy_do_property(battery->pdata->charger_name, set,
1733 POWER_SUPPLY_PROP_VOLTAGE_MAX, value);
1734 }
1735
1736 /* full/recharge condition */
1737 battery->pdata->recharge_condition_vcell =
1738 battery->pdata->age_data[battery->pdata->age_step].recharge_condition_vcell;
1739 battery->pdata->full_condition_soc =
1740 battery->pdata->age_data[battery->pdata->age_step].full_condition_soc;
1741 battery->pdata->full_condition_vcell =
1742 battery->pdata->age_data[battery->pdata->age_step].full_condition_vcell;
1743
1744 value.intval = battery->pdata->full_condition_soc;
1745 psy_do_property(battery->pdata->fuelgauge_name, set,
1746 POWER_SUPPLY_PROP_CAPACITY_LEVEL, value);
1747
1748 dev_info(battery->dev,
1749 "%s: Step(%d/%d), Cycle(%d), float_v(%d), r_v(%d), f_s(%d), f_vl(%d)\n",
1750 __func__,
1751 battery->pdata->age_step, battery->pdata->num_age_step-1, battery->batt_cycle,
1752 battery->pdata->chg_float_voltage,
1753 battery->pdata->recharge_condition_vcell,
1754 battery->pdata->full_condition_soc,
1755 battery->pdata->full_condition_vcell);
1756
1757 return true;
1758 }
1759
1760 static void sec_bat_aging_check(struct sec_battery_info *battery)
1761 {
1762 int prev_step = battery->pdata->age_step;
1763 int calc_step = -1;
1764 bool ret = 0;
1765
1766 if (battery->pdata->num_age_step <= 0 || battery->batt_cycle < 0)
1767 return;
1768
1769 if (battery->temperature < 50) {
1770 pr_info("%s: [AGE] skip (temperature:%d)\n", __func__, battery->temperature);
1771 return;
1772 }
1773
1774 for (calc_step = battery->pdata->num_age_step - 1; calc_step >= 0; calc_step--) {
1775 if (battery->pdata->age_data[calc_step].cycle <= battery->batt_cycle)
1776 break;
1777 }
1778
1779 if (calc_step == prev_step)
1780 return;
1781
1782 ret = sec_bat_set_aging_step(battery, calc_step);
1783 dev_info(battery->dev,
1784 "%s: %s change step (%d->%d), Cycle(%d)\n",
1785 __func__, ret ? "Succeed in" : "Fail to",
1786 prev_step, battery->pdata->age_step, battery->batt_cycle);
1787 }
1788 #endif
1789
1790 static bool sec_bat_temperature(
1791 struct sec_battery_info *battery)
1792 {
1793 bool ret;
1794 ret = true;
1795
1796 if (is_wireless_type(battery->cable_type)) {
1797 battery->temp_highlimit_threshold =
1798 battery->pdata->temp_highlimit_threshold_normal;
1799 battery->temp_highlimit_recovery =
1800 battery->pdata->temp_highlimit_recovery_normal;
1801 battery->temp_high_threshold =
1802 battery->pdata->wpc_high_threshold_normal;
1803 battery->temp_high_recovery =
1804 battery->pdata->wpc_high_recovery_normal;
1805 battery->temp_low_recovery =
1806 battery->pdata->wpc_low_recovery_normal;
1807 battery->temp_low_threshold =
1808 battery->pdata->wpc_low_threshold_normal;
1809 } else {
1810 if (lpcharge) {
1811 battery->temp_highlimit_threshold =
1812 battery->pdata->temp_highlimit_threshold_lpm;
1813 battery->temp_highlimit_recovery =
1814 battery->pdata->temp_highlimit_recovery_lpm;
1815 battery->temp_high_threshold =
1816 battery->pdata->temp_high_threshold_lpm;
1817 battery->temp_high_recovery =
1818 battery->pdata->temp_high_recovery_lpm;
1819 battery->temp_low_recovery =
1820 battery->pdata->temp_low_recovery_lpm;
1821 battery->temp_low_threshold =
1822 battery->pdata->temp_low_threshold_lpm;
1823 } else {
1824 battery->temp_highlimit_threshold =
1825 battery->pdata->temp_highlimit_threshold_normal;
1826 battery->temp_highlimit_recovery =
1827 battery->pdata->temp_highlimit_recovery_normal;
1828 battery->temp_high_threshold =
1829 battery->pdata->temp_high_threshold_normal;
1830 battery->temp_high_recovery =
1831 battery->pdata->temp_high_recovery_normal;
1832 battery->temp_low_recovery =
1833 battery->pdata->temp_low_recovery_normal;
1834 battery->temp_low_threshold =
1835 battery->pdata->temp_low_threshold_normal;
1836 }
1837 }
1838 dev_info(battery->dev,
1839 "%s: HLT(%d) HLR(%d) HT(%d), HR(%d), LT(%d), LR(%d)\n",
1840 __func__, battery->temp_highlimit_threshold,
1841 battery->temp_highlimit_recovery,
1842 battery->temp_high_threshold,
1843 battery->temp_high_recovery,
1844 battery->temp_low_threshold,
1845 battery->temp_low_recovery);
1846 return ret;
1847 }
1848
1849 static bool sec_bat_temperature_check(
1850 struct sec_battery_info *battery)
1851 {
1852 int temp_value = 0;
1853 int pre_health = POWER_SUPPLY_HEALTH_GOOD;
1854
1855 if (battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
1856 battery->health_change = false;
1857 dev_dbg(battery->dev,
1858 "%s: Charging Disabled\n", __func__);
1859 return true;
1860 }
1861
1862 if (battery->health != POWER_SUPPLY_HEALTH_GOOD &&
1863 battery->health != POWER_SUPPLY_HEALTH_OVERHEAT &&
1864 battery->health != POWER_SUPPLY_HEALTH_COLD &&
1865 battery->health != POWER_SUPPLY_HEALTH_OVERHEATLIMIT) {
1866 dev_dbg(battery->dev, "%s: No need to check\n", __func__);
1867 return false;
1868 }
1869
1870 #if defined(CONFIG_ENG_BATTERY_CONCEPT) || defined(CONFIG_SEC_FACTORY)
1871 if (!battery->cooldown_mode) {
1872 dev_err(battery->dev, "%s: Forced temp check block\n", __func__);
1873 return true;
1874 }
1875 #endif
1876
1877 sec_bat_temperature(battery);
1878
1879 switch (battery->pdata->temp_check_type) {
1880 case SEC_BATTERY_TEMP_CHECK_ADC:
1881 temp_value = battery->temp_adc;
1882 break;
1883 case SEC_BATTERY_TEMP_CHECK_TEMP:
1884 temp_value = battery->temperature;
1885 break;
1886 default:
1887 dev_err(battery->dev,
1888 "%s: Invalid Temp Check Type\n", __func__);
1889 return true;
1890 }
1891 pre_health = battery->health;
1892
1893 if (battery->pdata->usb_thermal_source && (battery->usb_temp >= battery->temp_highlimit_threshold)) {
1894 if (battery->health != POWER_SUPPLY_HEALTH_OVERHEATLIMIT) {
1895 if (battery->temp_highlimit_cnt <
1896 battery->pdata->temp_check_count) {
1897 battery->temp_highlimit_cnt++;
1898 battery->temp_high_cnt = 0;
1899 battery->temp_low_cnt = 0;
1900 battery->temp_recover_cnt = 0;
1901 }
1902 dev_err(battery->dev,
1903 "%s: usb therm highlimit count = %d\n",
1904 __func__, battery->temp_highlimit_cnt);
1905 }
1906 } else if (battery->pdata->usb_thermal_source && (battery->usb_temp > battery->temp_highlimit_recovery)
1907 && (battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT)) {
1908 dev_err(battery->dev,
1909 "%s: usb therm highlimit \n",__func__);
1910 } else if (temp_value >= battery->temp_highlimit_threshold && !battery->pdata->usb_thermal_source) {
1911 if (battery->health != POWER_SUPPLY_HEALTH_OVERHEATLIMIT) {
1912 if (battery->temp_highlimit_cnt <
1913 battery->pdata->temp_check_count) {
1914 battery->temp_highlimit_cnt++;
1915 battery->temp_high_cnt = 0;
1916 battery->temp_low_cnt = 0;
1917 battery->temp_recover_cnt = 0;
1918 }
1919 dev_err(battery->dev,
1920 "%s: highlimit count = %d\n",
1921 __func__, battery->temp_highlimit_cnt);
1922 }
1923 } else if (temp_value >= battery->temp_high_threshold) {
1924 if (battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT && !battery->pdata->usb_thermal_source) {
1925 if (temp_value <= battery->temp_highlimit_recovery) {
1926 if (battery->temp_recover_cnt <
1927 battery->pdata->temp_check_count) {
1928 battery->temp_recover_cnt++;
1929 battery->temp_highlimit_cnt = 0;
1930 battery->temp_high_cnt = 0;
1931 battery->temp_low_cnt = 0;
1932 }
1933 dev_err(battery->dev,
1934 "%s: recovery count = %d\n",
1935 __func__, battery->temp_recover_cnt);
1936 }
1937 } else if (battery->health != POWER_SUPPLY_HEALTH_OVERHEAT) {
1938 if (battery->temp_high_cnt <
1939 battery->pdata->temp_check_count) {
1940 battery->temp_high_cnt++;
1941 battery->temp_highlimit_cnt = 0;
1942 battery->temp_low_cnt = 0;
1943 battery->temp_recover_cnt = 0;
1944 }
1945 dev_err(battery->dev,
1946 "%s: high count = %d\n",
1947 __func__, battery->temp_high_cnt);
1948 }
1949 } else if ((temp_value <= battery->temp_high_recovery) &&
1950 (temp_value >= battery->temp_low_recovery)) {
1951 if (battery->health == POWER_SUPPLY_HEALTH_OVERHEAT ||
1952 battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT ||
1953 battery->health == POWER_SUPPLY_HEALTH_COLD) {
1954 if (battery->temp_recover_cnt <
1955 battery->pdata->temp_check_count) {
1956 battery->temp_recover_cnt++;
1957 battery->temp_highlimit_cnt = 0;
1958 battery->temp_high_cnt = 0;
1959 battery->temp_low_cnt = 0;
1960 }
1961 dev_err(battery->dev,
1962 "%s: recovery count = %d\n",
1963 __func__, battery->temp_recover_cnt);
1964 }
1965 } else if (temp_value <= battery->temp_low_threshold) {
1966 if (battery->health != POWER_SUPPLY_HEALTH_COLD) {
1967 if (battery->temp_low_cnt <
1968 battery->pdata->temp_check_count) {
1969 battery->temp_low_cnt++;
1970 battery->temp_highlimit_cnt = 0;
1971 battery->temp_high_cnt = 0;
1972 battery->temp_recover_cnt = 0;
1973 }
1974 dev_err(battery->dev,
1975 "%s: low count = %d\n",
1976 __func__, battery->temp_low_cnt);
1977 }
1978 } else {
1979 battery->temp_highlimit_cnt = 0;
1980 battery->temp_high_cnt = 0;
1981 battery->temp_low_cnt = 0;
1982 battery->temp_recover_cnt = 0;
1983 }
1984
1985 if (battery->temp_highlimit_cnt >=
1986 battery->pdata->temp_check_count) {
1987 battery->health = POWER_SUPPLY_HEALTH_OVERHEATLIMIT;
1988 battery->temp_highlimit_cnt = 0;
1989 } else if (battery->temp_high_cnt >=
1990 battery->pdata->temp_check_count) {
1991 battery->health = POWER_SUPPLY_HEALTH_OVERHEAT;
1992 battery->temp_high_cnt = 0;
1993 } else if (battery->temp_low_cnt >=
1994 battery->pdata->temp_check_count) {
1995 battery->health = POWER_SUPPLY_HEALTH_COLD;
1996 battery->temp_low_cnt = 0;
1997 } else if (battery->temp_recover_cnt >=
1998 battery->pdata->temp_check_count) {
1999 if (battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT &&
2000 temp_value > battery->temp_high_recovery) {
2001 battery->health = POWER_SUPPLY_HEALTH_OVERHEAT;
2002 } else {
2003 battery->health = POWER_SUPPLY_HEALTH_GOOD;
2004 }
2005 battery->temp_recover_cnt = 0;
2006 }
2007 if (pre_health != battery->health) {
2008 battery->health_change = true;
2009 dev_info(battery->dev, "%s, health_change true\n", __func__);
2010 #if defined(CONFIG_BATTERY_SBM_DATA)
2011 sec_bat_add_sbm_data(battery, SBM_DATA_TEMP);
2012 #endif
2013 } else {
2014 battery->health_change = false;
2015 }
2016
2017 if ((battery->health == POWER_SUPPLY_HEALTH_OVERHEAT) ||
2018 (battery->health == POWER_SUPPLY_HEALTH_COLD) ||
2019 (battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT)) {
2020 union power_supply_propval val = {0, };
2021 if (battery->health_change) {
2022 battery->is_abnormal_temp = true;
2023 if (is_wireless_type(battery->cable_type)) {
2024 val.intval = battery->health;
2025 psy_do_property(battery->pdata->wireless_charger_name, set,
2026 POWER_SUPPLY_PROP_HEALTH, val);
2027 }
2028 dev_info(battery->dev,
2029 "%s: Unsafe Temperature\n", __func__);
2030 sec_bat_set_charging_status(battery,
2031 POWER_SUPPLY_STATUS_NOT_CHARGING);
2032 #if defined(CONFIG_BATTERY_CISD)
2033 battery->cisd.data[CISD_DATA_UNSAFETY_TEMPERATURE]++;
2034 battery->cisd.data[CISD_DATA_UNSAFE_TEMPERATURE_PER_DAY]++;
2035 #endif
2036
2037 if (battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT) {
2038 /* change charging current to battery (default 0mA) */
2039 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
2040 if (is_hv_afc_wire_type(battery->cable_type) && !battery->vbus_limit) {
2041 #if defined(CONFIG_MUIC_HV) || defined(CONFIG_SUPPORT_QC30)
2042 muic_afc_set_voltage(SEC_INPUT_VOLTAGE_0V);
2043 #endif
2044 battery->vbus_limit = true;
2045 pr_info("%s: Set AFC TA to 0V\n", __func__);
2046 }
2047 } else if (battery->health == POWER_SUPPLY_HEALTH_OVERHEAT) {
2048 /* to discharge battery */
2049 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
2050 } else {
2051 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
2052 }
2053
2054 return false;
2055 }
2056 /* dose not need buck control at low temperature */
2057 if (battery->health == POWER_SUPPLY_HEALTH_OVERHEATLIMIT ||
2058 battery->health == POWER_SUPPLY_HEALTH_OVERHEAT) {
2059 if((battery->charger_mode == SEC_BAT_CHG_MODE_BUCK_OFF) &&
2060 (battery->voltage_now < (battery->pdata->swelling_drop_float_voltage / battery->pdata->chg_float_voltage_conv))) {
2061 pr_info("%s: Vnow(%dmV) < %dmV has dropped enough to get buck on mode \n", __func__,
2062 battery->voltage_now,
2063 (battery->pdata->swelling_drop_float_voltage / battery->pdata->chg_float_voltage_conv));
2064 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
2065 }
2066 }
2067 } else {
2068 /* if recovered from not charging */
2069 if ((battery->health == POWER_SUPPLY_HEALTH_GOOD) &&
2070 (battery->status ==
2071 POWER_SUPPLY_STATUS_NOT_CHARGING)) {
2072 battery->is_abnormal_temp = false;
2073 dev_info(battery->dev,
2074 "%s: Safe Temperature\n", __func__);
2075 if (battery->capacity >= 100)
2076 sec_bat_set_charging_status(battery,
2077 POWER_SUPPLY_STATUS_FULL);
2078 else /* Normal Charging */
2079 sec_bat_set_charging_status(battery,
2080 POWER_SUPPLY_STATUS_CHARGING);
2081 #if defined(CONFIG_BATTERY_SWELLING)
2082 if ((temp_value > battery->pdata->swelling_high_temp_recov) ||
2083 (temp_value < battery->pdata->swelling_low_temp_recov_2nd)) {
2084 pr_info("%s: swelling mode start. stop charging\n", __func__);
2085 battery->swelling_mode = SWELLING_MODE_CHARGING;
2086 battery->swelling_full_check_cnt = 0;
2087 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
2088 if (battery->temperature > battery->pdata->swelling_high_temp_recov) {
2089 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_HIGH_TEMP_SWELLING,
2090 SEC_BAT_CURRENT_EVENT_HIGH_TEMP_SWELLING);
2091 } else if (battery->temperature < battery->pdata->swelling_low_temp_recov_2nd) {
2092 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING,
2093 SEC_BAT_CURRENT_EVENT_LOW_TEMP_SWELLING);
2094 }
2095 } else {
2096 union power_supply_propval val = {0, };
2097 /* restore 4.4V float voltage */
2098 val.intval = battery->pdata->swelling_normal_float_voltage;
2099 psy_do_property(battery->pdata->charger_name, set,
2100 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
2101 /* turn on charger by cable type */
2102 if((battery->status == POWER_SUPPLY_STATUS_FULL) &&
2103 (battery->charging_mode == SEC_BATTERY_CHARGING_NONE)) {
2104 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
2105 } else {
2106 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
2107 }
2108
2109 if (temp_value <= battery->pdata->swelling_low_temp_block_1st ||
2110 ((temp_value < battery->pdata->swelling_low_temp_recov_1st) &&
2111 (pre_health == POWER_SUPPLY_HEALTH_COLD))) {
2112 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_LOW_TEMP,
2113 SEC_BAT_CURRENT_EVENT_SWELLING_MODE);
2114 }
2115 }
2116 #else
2117 /* turn on charger by cable type */
2118 if((battery->status == POWER_SUPPLY_STATUS_FULL) &&
2119 (battery->charging_mode == SEC_BATTERY_CHARGING_NONE)) {
2120 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
2121 } else {
2122 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
2123 }
2124 #endif
2125 return false;
2126 }
2127 }
2128 return true;
2129 }
2130
2131 static bool sec_bat_check_fullcharged_condition(
2132 struct sec_battery_info *battery)
2133 {
2134 int full_check_type = SEC_BATTERY_FULLCHARGED_NONE;
2135
2136 if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST)
2137 full_check_type = battery->pdata->full_check_type;
2138 else
2139 full_check_type = battery->pdata->full_check_type_2nd;
2140
2141 switch (full_check_type) {
2142 case SEC_BATTERY_FULLCHARGED_ADC:
2143 case SEC_BATTERY_FULLCHARGED_FG_CURRENT:
2144 case SEC_BATTERY_FULLCHARGED_SOC:
2145 case SEC_BATTERY_FULLCHARGED_CHGGPIO:
2146 case SEC_BATTERY_FULLCHARGED_CHGPSY:
2147 break;
2148
2149 /* If these is NOT full check type or NONE full check type,
2150 * it is full-charged
2151 */
2152 case SEC_BATTERY_FULLCHARGED_CHGINT:
2153 case SEC_BATTERY_FULLCHARGED_TIME:
2154 case SEC_BATTERY_FULLCHARGED_NONE:
2155 default:
2156 return true;
2157 break;
2158 }
2159
2160 if (battery->pdata->full_condition_type &
2161 SEC_BATTERY_FULL_CONDITION_SOC) {
2162 if (battery->capacity <
2163 battery->pdata->full_condition_soc) {
2164 dev_dbg(battery->dev,
2165 "%s: Not enough SOC (%d%%)\n",
2166 __func__, battery->capacity);
2167 return false;
2168 }
2169 }
2170
2171 if (battery->pdata->full_condition_type &
2172 SEC_BATTERY_FULL_CONDITION_VCELL) {
2173 if (battery->voltage_now <
2174 battery->pdata->full_condition_vcell) {
2175 dev_dbg(battery->dev,
2176 "%s: Not enough VCELL (%dmV)\n",
2177 __func__, battery->voltage_now);
2178 return false;
2179 }
2180 }
2181
2182 if (battery->pdata->full_condition_type &
2183 SEC_BATTERY_FULL_CONDITION_AVGVCELL) {
2184 if (battery->voltage_avg <
2185 battery->pdata->full_condition_avgvcell) {
2186 dev_dbg(battery->dev,
2187 "%s: Not enough AVGVCELL (%dmV)\n",
2188 __func__, battery->voltage_avg);
2189 return false;
2190 }
2191 }
2192
2193 if (battery->pdata->full_condition_type &
2194 SEC_BATTERY_FULL_CONDITION_OCV) {
2195 if (battery->voltage_ocv <
2196 battery->pdata->full_condition_ocv) {
2197 dev_dbg(battery->dev,
2198 "%s: Not enough OCV (%dmV)\n",
2199 __func__, battery->voltage_ocv);
2200 return false;
2201 }
2202 }
2203
2204 return true;
2205 }
2206
2207 static void sec_bat_do_test_function(
2208 struct sec_battery_info *battery)
2209 {
2210 union power_supply_propval value = {0, };
2211
2212 switch (battery->test_mode) {
2213 case 1:
2214 if (battery->status == POWER_SUPPLY_STATUS_CHARGING) {
2215 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
2216 sec_bat_set_charging_status(battery,
2217 POWER_SUPPLY_STATUS_DISCHARGING);
2218 }
2219 break;
2220 case 2:
2221 if(battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
2222 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
2223 psy_do_property(battery->pdata->charger_name, get,
2224 POWER_SUPPLY_PROP_STATUS, value);
2225 sec_bat_set_charging_status(battery, value.intval);
2226 }
2227 battery->test_mode = 0;
2228 break;
2229 case 3: // clear temp block
2230 battery->health = POWER_SUPPLY_HEALTH_GOOD;
2231 sec_bat_set_charging_status(battery,
2232 POWER_SUPPLY_STATUS_DISCHARGING);
2233 break;
2234 case 4:
2235 if(battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
2236 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
2237 psy_do_property(battery->pdata->charger_name, get,
2238 POWER_SUPPLY_PROP_STATUS, value);
2239 sec_bat_set_charging_status(battery, value.intval);
2240 }
2241 break;
2242 default:
2243 pr_info("%s: error test: unknown state\n", __func__);
2244 break;
2245 }
2246 }
2247
2248 static bool sec_bat_time_management(
2249 struct sec_battery_info *battery)
2250 {
2251 struct timespec ts = {0, };
2252 unsigned long charging_time;
2253
2254 if (battery->charging_start_time == 0 || !battery->safety_timer_set) {
2255 dev_dbg(battery->dev,
2256 "%s: Charging Disabled\n", __func__);
2257 return true;
2258 }
2259
2260 get_monotonic_boottime(&ts);
2261
2262 if (ts.tv_sec >= battery->charging_start_time) {
2263 charging_time = ts.tv_sec - battery->charging_start_time;
2264 } else {
2265 charging_time = 0xFFFFFFFF - battery->charging_start_time
2266 + ts.tv_sec;
2267 }
2268
2269 battery->charging_passed_time = charging_time;
2270
2271 switch (battery->status) {
2272 case POWER_SUPPLY_STATUS_FULL:
2273 if (battery->expired_time == 0) {
2274 dev_info(battery->dev,
2275 "%s: Recharging Timer Expired\n", __func__);
2276 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
2277 battery->health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
2278 sec_bat_set_charging_status(battery, POWER_SUPPLY_STATUS_NOT_CHARGING);
2279 battery->is_recharging = false;
2280 if (sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF)) {
2281 dev_err(battery->dev,
2282 "%s: Fail to Set Charger\n", __func__);
2283 return true;
2284 }
2285
2286 return false;
2287 }
2288 break;
2289 case POWER_SUPPLY_STATUS_CHARGING:
2290 if ((battery->pdata->full_condition_type &
2291 SEC_BATTERY_FULL_CONDITION_NOTIMEFULL) &&
2292 (battery->is_recharging && (battery->expired_time == 0))) {
2293 dev_info(battery->dev,
2294 "%s: Recharging Timer Expired\n", __func__);
2295 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
2296 battery->health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
2297 sec_bat_set_charging_status(battery, POWER_SUPPLY_STATUS_NOT_CHARGING);
2298 battery->is_recharging = false;
2299 if (sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF)) {
2300 dev_err(battery->dev,
2301 "%s: Fail to Set Charger\n", __func__);
2302 return true;
2303 }
2304 return false;
2305 } else if (!battery->is_recharging &&
2306 (battery->expired_time == 0)) {
2307 dev_info(battery->dev,
2308 "%s: Charging Timer Expired\n", __func__);
2309 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
2310 battery->health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
2311 sec_bat_set_charging_status(battery, POWER_SUPPLY_STATUS_NOT_CHARGING);
2312 #if defined(CONFIG_BATTERY_CISD)
2313 battery->cisd.data[CISD_DATA_SAFETY_TIMER]++;
2314 battery->cisd.data[CISD_DATA_SAFETY_TIMER_PER_DAY]++;
2315 #endif
2316 #if defined(CONFIG_SEC_ABC)
2317 sec_abc_send_event("MODULE=battery@ERROR=safety_timer");
2318 #endif
2319 if (sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF)) {
2320 dev_err(battery->dev,
2321 "%s: Fail to Set Charger\n", __func__);
2322 return true;
2323 }
2324 return false;
2325 }
2326 break;
2327 default:
2328 dev_err(battery->dev,
2329 "%s: Undefine Battery Status\n", __func__);
2330 return true;
2331 }
2332
2333 return true;
2334 }
2335
2336 static bool sec_bat_check_fullcharged(
2337 struct sec_battery_info *battery)
2338 {
2339 union power_supply_propval value = {0, };
2340 int current_adc = 0;
2341 int full_check_type = SEC_BATTERY_FULLCHARGED_NONE;
2342 bool ret = false;
2343 int err = 0;
2344
2345 if (!sec_bat_check_fullcharged_condition(battery))
2346 goto not_full_charged;
2347
2348 if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST)
2349 full_check_type = battery->pdata->full_check_type;
2350 else
2351 full_check_type = battery->pdata->full_check_type_2nd;
2352
2353 switch (full_check_type) {
2354 case SEC_BATTERY_FULLCHARGED_ADC:
2355 current_adc =
2356 sec_bat_get_adc_data(battery,
2357 SEC_BAT_ADC_CHANNEL_FULL_CHECK,
2358 battery->pdata->adc_check_count);
2359
2360 dev_dbg(battery->dev,
2361 "%s: Current ADC (%d)\n",
2362 __func__, current_adc);
2363
2364 if (current_adc < 0)
2365 break;
2366 battery->current_adc = current_adc;
2367
2368 if (battery->current_adc <
2369 (battery->charging_mode ==
2370 SEC_BATTERY_CHARGING_1ST ?
2371 battery->pdata->full_check_current_1st :
2372 battery->pdata->full_check_current_2nd)) {
2373 battery->full_check_cnt++;
2374 dev_dbg(battery->dev,
2375 "%s: Full Check ADC (%d)\n",
2376 __func__,
2377 battery->full_check_cnt);
2378 } else
2379 battery->full_check_cnt = 0;
2380 break;
2381
2382 case SEC_BATTERY_FULLCHARGED_FG_CURRENT:
2383 if ((battery->current_now > 0 && battery->current_now <
2384 battery->pdata->full_check_current_1st) &&
2385 (battery->current_avg > 0 && battery->current_avg <
2386 (battery->charging_mode ==
2387 SEC_BATTERY_CHARGING_1ST ?
2388 battery->pdata->full_check_current_1st :
2389 battery->pdata->full_check_current_2nd))) {
2390 battery->full_check_cnt++;
2391 dev_dbg(battery->dev,
2392 "%s: Full Check Current (%d)\n",
2393 __func__,
2394 battery->full_check_cnt);
2395 } else
2396 battery->full_check_cnt = 0;
2397 break;
2398
2399 case SEC_BATTERY_FULLCHARGED_TIME:
2400 if ((battery->charging_mode ==
2401 SEC_BATTERY_CHARGING_2ND ?
2402 (battery->charging_passed_time -
2403 battery->charging_fullcharged_time) :
2404 battery->charging_passed_time) >
2405 (battery->charging_mode ==
2406 SEC_BATTERY_CHARGING_1ST ?
2407 battery->pdata->full_check_current_1st :
2408 battery->pdata->full_check_current_2nd)) {
2409 battery->full_check_cnt++;
2410 dev_dbg(battery->dev,
2411 "%s: Full Check Time (%d)\n",
2412 __func__,
2413 battery->full_check_cnt);
2414 } else
2415 battery->full_check_cnt = 0;
2416 break;
2417
2418 case SEC_BATTERY_FULLCHARGED_SOC:
2419 if (battery->capacity <=
2420 (battery->charging_mode ==
2421 SEC_BATTERY_CHARGING_1ST ?
2422 battery->pdata->full_check_current_1st :
2423 battery->pdata->full_check_current_2nd)) {
2424 battery->full_check_cnt++;
2425 dev_dbg(battery->dev,
2426 "%s: Full Check SOC (%d)\n",
2427 __func__,
2428 battery->full_check_cnt);
2429 } else
2430 battery->full_check_cnt = 0;
2431 break;
2432
2433 case SEC_BATTERY_FULLCHARGED_CHGGPIO:
2434 err = gpio_request(
2435 battery->pdata->chg_gpio_full_check,
2436 "GPIO_CHG_FULL");
2437 if (err) {
2438 dev_err(battery->dev,
2439 "%s: Error in Request of GPIO\n", __func__);
2440 break;
2441 }
2442 if (!(gpio_get_value_cansleep(
2443 battery->pdata->chg_gpio_full_check) ^
2444 !battery->pdata->chg_polarity_full_check)) {
2445 battery->full_check_cnt++;
2446 dev_dbg(battery->dev,
2447 "%s: Full Check GPIO (%d)\n",
2448 __func__, battery->full_check_cnt);
2449 } else
2450 battery->full_check_cnt = 0;
2451 gpio_free(battery->pdata->chg_gpio_full_check);
2452 break;
2453
2454 case SEC_BATTERY_FULLCHARGED_CHGINT:
2455 case SEC_BATTERY_FULLCHARGED_CHGPSY:
2456 psy_do_property(battery->pdata->charger_name, get,
2457 POWER_SUPPLY_PROP_STATUS, value);
2458
2459 if (value.intval == POWER_SUPPLY_STATUS_FULL) {
2460 battery->full_check_cnt++;
2461 dev_info(battery->dev,
2462 "%s: Full Check Charger (%d)\n",
2463 __func__, battery->full_check_cnt);
2464 } else
2465 battery->full_check_cnt = 0;
2466 break;
2467
2468 /* If these is NOT full check type or NONE full check type,
2469 * it is full-charged
2470 */
2471 case SEC_BATTERY_FULLCHARGED_NONE:
2472 battery->full_check_cnt = 0;
2473 ret = true;
2474 break;
2475 default:
2476 dev_err(battery->dev,
2477 "%s: Invalid Full Check\n", __func__);
2478 break;
2479 }
2480
2481 if (battery->full_check_cnt >=
2482 battery->pdata->full_check_count) {
2483 battery->full_check_cnt = 0;
2484 ret = true;
2485 }
2486
2487 not_full_charged:
2488 return ret;
2489 }
2490
2491 static void sec_bat_do_fullcharged(
2492 struct sec_battery_info *battery)
2493 {
2494 union power_supply_propval value = {0, };
2495
2496 /* To let charger/fuel gauge know the full status,
2497 * set status before calling sec_bat_set_charge()
2498 */
2499 #if defined(CONFIG_BATTERY_CISD)
2500 struct timespec now_ts;
2501
2502 if (battery->status != POWER_SUPPLY_STATUS_FULL) {
2503 battery->cisd.data[CISD_DATA_FULL_COUNT]++;
2504 battery->cisd.data[CISD_DATA_FULL_COUNT_PER_DAY]++;
2505 }
2506 #endif
2507 sec_bat_set_charging_status(battery,
2508 POWER_SUPPLY_STATUS_FULL);
2509
2510 if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST &&
2511 battery->pdata->full_check_type_2nd != SEC_BATTERY_FULLCHARGED_NONE) {
2512 battery->charging_mode = SEC_BATTERY_CHARGING_2ND;
2513 battery->charging_fullcharged_time = battery->charging_passed_time;
2514 value.intval = SEC_BAT_CHG_MODE_CHARGING_OFF;
2515 psy_do_property(battery->pdata->charger_name, set,
2516 POWER_SUPPLY_PROP_CHARGING_ENABLED, value);
2517 sec_bat_set_charging_current(battery);
2518 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
2519 #if defined(CONFIG_BATTERY_SBM_DATA)
2520 sec_bat_add_sbm_data(battery, SBM_DATA_FULL_1ST);
2521 #endif
2522 } else {
2523 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
2524 #if defined(CONFIG_BATTERY_CISD)
2525 now_ts = ktime_to_timespec(ktime_get_boottime());
2526 if (!battery->is_recharging) {
2527 battery->cisd.charging_end_time = now_ts.tv_sec;
2528 }
2529 if (battery->siop_level == 100) {
2530 dev_info(battery->dev, "%s: cisd - leakage EFGH start(%ld)\n", __func__, ((unsigned long)now_ts.tv_sec));
2531 battery->cisd.state &= ~(CISD_STATE_LEAK_E|CISD_STATE_LEAK_F|CISD_STATE_LEAK_G);
2532 battery->cisd.charging_end_time_2 = now_ts.tv_sec;
2533 battery->cisd.recharge_count_2 = 0;
2534 } else {
2535 battery->cisd.state &= ~(CISD_STATE_LEAK_E|CISD_STATE_LEAK_F|CISD_STATE_LEAK_G);
2536 battery->cisd.recharge_count_2 = 0;
2537 battery->cisd.charging_end_time_2 = 0;
2538 }
2539 #endif
2540 battery->is_recharging = false;
2541
2542 if (!battery->wdt_kick_disable) {
2543 pr_info("%s: wdt kick enable -> Charger Off, %d\n",
2544 __func__, battery->wdt_kick_disable);
2545 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
2546 } else {
2547 pr_info("%s: wdt kick disabled -> skip charger off, %d\n",
2548 __func__, battery->wdt_kick_disable);
2549 }
2550
2551 #if defined(CONFIG_BATTERY_AGE_FORECAST)
2552 sec_bat_aging_check(battery);
2553 #endif
2554
2555 value.intval = POWER_SUPPLY_STATUS_FULL;
2556 psy_do_property(battery->pdata->fuelgauge_name, set,
2557 POWER_SUPPLY_PROP_STATUS, value);
2558 #if defined(CONFIG_BATTERY_SBM_DATA)
2559 sec_bat_add_sbm_data(battery, SBM_DATA_FULL_2ND);
2560 #endif
2561 }
2562
2563 /* platform can NOT get information of battery
2564 * because wakeup time is too short to check uevent
2565 * To make sure that target is wakeup if full-charged,
2566 * activated wake lock in a few seconds
2567 */
2568 if (battery->pdata->polling_type == SEC_BATTERY_MONITOR_ALARM)
2569 wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
2570 }
2571
2572 static bool sec_bat_fullcharged_check(
2573 struct sec_battery_info *battery)
2574 {
2575 if ((battery->charging_mode == SEC_BATTERY_CHARGING_NONE) ||
2576 (battery->status == POWER_SUPPLY_STATUS_NOT_CHARGING)) {
2577 dev_dbg(battery->dev,
2578 "%s: No Need to Check Full-Charged\n", __func__);
2579 return true;
2580 }
2581
2582 if (sec_bat_check_fullcharged(battery)) {
2583 union power_supply_propval value = {0, };
2584 if (battery->capacity < 100) {
2585 battery->full_check_cnt = battery->pdata->full_check_count;
2586 } else {
2587 sec_bat_do_fullcharged(battery);
2588 }
2589
2590 /* update capacity max */
2591 value.intval = battery->capacity;
2592 psy_do_property(battery->pdata->fuelgauge_name, set,
2593 POWER_SUPPLY_PROP_CHARGE_FULL, value);
2594 pr_info("%s : forced full-charged sequence for the capacity(%d)\n",
2595 __func__, battery->capacity);
2596 }
2597
2598 dev_info(battery->dev,
2599 "%s: Charging Mode : %s\n", __func__,
2600 battery->is_recharging ?
2601 sec_bat_charging_mode_str[SEC_BATTERY_CHARGING_RECHARGING] :
2602 sec_bat_charging_mode_str[battery->charging_mode]);
2603
2604 return true;
2605 }
2606
2607 static void sec_bat_get_temperature_info(
2608 struct sec_battery_info *battery)
2609 {
2610 union power_supply_propval value = {0, };
2611
2612 switch (battery->pdata->thermal_source) {
2613 case SEC_BATTERY_THERMAL_SOURCE_FG:
2614 psy_do_property(battery->pdata->fuelgauge_name, get,
2615 POWER_SUPPLY_PROP_TEMP, value);
2616 battery->temperature = value.intval;
2617
2618 psy_do_property(battery->pdata->fuelgauge_name, get,
2619 POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
2620 battery->temper_amb = value.intval;
2621 break;
2622 case SEC_BATTERY_THERMAL_SOURCE_CALLBACK:
2623 if (battery->pdata->get_temperature_callback) {
2624 battery->pdata->get_temperature_callback(
2625 POWER_SUPPLY_PROP_TEMP, &value);
2626 battery->temperature = value.intval;
2627 psy_do_property(battery->pdata->fuelgauge_name, set,
2628 POWER_SUPPLY_PROP_TEMP, value);
2629
2630 battery->pdata->get_temperature_callback(
2631 POWER_SUPPLY_PROP_TEMP_AMBIENT, &value);
2632 battery->temper_amb = value.intval;
2633 psy_do_property(battery->pdata->fuelgauge_name, set,
2634 POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
2635 }
2636 break;
2637 case SEC_BATTERY_THERMAL_SOURCE_ADC:
2638 sec_bat_get_value_by_adc(battery,
2639 SEC_BAT_ADC_CHANNEL_TEMP, &value);
2640 battery->temperature = value.intval;
2641
2642 sec_bat_get_value_by_adc(battery,
2643 SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT, &value);
2644 battery->temper_amb = value.intval;
2645
2646 if (battery->pdata->usb_thermal_source) {
2647 sec_bat_get_value_by_adc(battery,
2648 SEC_BAT_ADC_CHANNEL_USB_TEMP, &value);
2649 battery->usb_temp = value.intval;
2650 if (battery->vbus_limit && battery->usb_temp <= battery->temp_highlimit_recovery)
2651 battery->vbus_limit = false;
2652 }
2653
2654 if (battery->pdata->chg_thermal_source) {
2655 sec_bat_get_value_by_adc(battery,
2656 SEC_BAT_ADC_CHANNEL_CHG_TEMP, &value);
2657 battery->chg_temp = value.intval;
2658 }
2659
2660 if (battery->pdata->wpc_thermal_source) {
2661 sec_bat_get_value_by_adc(battery,
2662 SEC_BAT_ADC_CHANNEL_WPC_TEMP, &value);
2663 battery->wpc_temp = value.intval;
2664 battery->coil_temp = value.intval;
2665 }
2666
2667 if (battery->pdata->slave_thermal_source) {
2668 sec_bat_get_value_by_adc(battery,
2669 SEC_BAT_ADC_CHANNEL_SLAVE_CHG_TEMP, &value);
2670 battery->slave_chg_temp = value.intval;
2671
2672 /* set temperature */
2673 value.intval = ((battery->slave_chg_temp) << 16) | (battery->chg_temp);
2674 psy_do_property(battery->pdata->charger_name, set,
2675 POWER_SUPPLY_PROP_TEMP, value);
2676 }
2677
2678 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
2679 if (battery->temperature_test_battery > -300 && battery->temperature_test_battery < 3000) {
2680 pr_info("%s : battery temperature test %d\n", __func__, battery->temperature_test_battery);
2681 battery->temperature = battery->temperature_test_battery;
2682 }
2683 if (battery->temperature_test_usb > -300 && battery->temperature_test_usb < 3000) {
2684 pr_info("%s : usb temperature test %d\n", __func__, battery->temperature_test_usb);
2685 battery->usb_temp = battery->temperature_test_usb;
2686 }
2687 if (battery->temperature_test_wpc > -300 && battery->temperature_test_wpc < 3000) {
2688 pr_info("%s : wpc temperature test %d\n", __func__, battery->temperature_test_wpc);
2689 battery->wpc_temp = battery->temperature_test_wpc;
2690 battery->coil_temp = battery->temperature_test_wpc;
2691 }
2692 if (battery->temperature_test_chg > -300 && battery->temperature_test_chg < 3000) {
2693 pr_info("%s : chg temperature test %d\n", __func__, battery->temperature_test_chg);
2694 battery->chg_temp = battery->temperature_test_chg;
2695 }
2696 #endif
2697
2698 #if defined(CONFIG_SEC_FACTORY)
2699 if (battery->temperature <= (-200)) {
2700 value.intval = battery->usb_temp;
2701 } else {
2702 value.intval = battery->temperature;
2703 }
2704 #else
2705 value.intval = battery->temperature;
2706 #endif
2707 psy_do_property(battery->pdata->fuelgauge_name, set,
2708 POWER_SUPPLY_PROP_TEMP, value);
2709
2710 psy_do_property(battery->pdata->fuelgauge_name, set,
2711 POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
2712
2713 break;
2714 default:
2715 break;
2716 }
2717 }
2718
2719 static void sec_bat_get_battery_info(
2720 struct sec_battery_info *battery)
2721 {
2722 union power_supply_propval value = {0, };
2723
2724 psy_do_property(battery->pdata->fuelgauge_name, get,
2725 POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
2726 battery->voltage_now = value.intval;
2727
2728 value.intval = SEC_BATTERY_VOLTAGE_AVERAGE;
2729 psy_do_property(battery->pdata->fuelgauge_name, get,
2730 POWER_SUPPLY_PROP_VOLTAGE_AVG, value);
2731 battery->voltage_avg = value.intval;
2732
2733 /* Do not call it to reduce time after cable_work, this funtion call FG full log*/
2734 if (!(battery->current_event & SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL)) {
2735 value.intval = SEC_BATTERY_VOLTAGE_OCV;
2736 psy_do_property(battery->pdata->fuelgauge_name, get,
2737 POWER_SUPPLY_PROP_VOLTAGE_AVG, value);
2738 battery->voltage_ocv = value.intval;
2739 }
2740
2741 value.intval = SEC_BATTERY_CURRENT_MA;
2742 psy_do_property(battery->pdata->fuelgauge_name, get,
2743 POWER_SUPPLY_PROP_CURRENT_NOW, value);
2744 battery->current_now = value.intval;
2745
2746 value.intval = SEC_BATTERY_CURRENT_MA;
2747 psy_do_property(battery->pdata->fuelgauge_name, get,
2748 POWER_SUPPLY_PROP_CURRENT_AVG, value);
2749 battery->current_avg = value.intval;
2750
2751 /* input current limit in charger */
2752 psy_do_property(battery->pdata->charger_name, get,
2753 POWER_SUPPLY_PROP_CURRENT_MAX, value);
2754 battery->current_max = value.intval;
2755
2756 psy_do_property(battery->pdata->fuelgauge_name, get,
2757 POWER_SUPPLY_PROP_CHARGE_COUNTER, value);
2758 battery->charge_counter = value.intval;
2759
2760 /* check abnormal status for wireless charging */
2761 if (!(battery->current_event & SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL) &&
2762 is_wireless_type(battery->cable_type)) {
2763 value.intval = (battery->status == POWER_SUPPLY_STATUS_FULL) ?
2764 100 : battery->capacity;
2765 psy_do_property(battery->pdata->wireless_charger_name, set,
2766 POWER_SUPPLY_PROP_ENERGY_NOW, value);
2767 }
2768
2769 sec_bat_get_temperature_info(battery);
2770
2771 /* To get SOC value (NOT raw SOC), need to reset value */
2772 value.intval = 0;
2773 psy_do_property(battery->pdata->fuelgauge_name, get,
2774 POWER_SUPPLY_PROP_CAPACITY, value);
2775 /* if the battery status was full, and SOC wasn't 100% yet,
2776 then ignore FG SOC, and report (previous SOC +1)% */
2777 battery->capacity = value.intval;
2778
2779 dev_info(battery->dev,
2780 "%s:Vnow(%dmV),Vavg(%dmV),Inow(%dmA),Imax(%dmA),Ichg(%dmA),SOC(%d%%),"
2781 "Tbat(%d),Tusb(%d),Tchg(%d),Twpc(%d)\n", __func__,
2782 battery->voltage_now, battery->voltage_avg, battery->current_now,
2783 battery->current_max, battery->charging_current,
2784 battery->capacity, battery->temperature,
2785 battery->usb_temp,battery->chg_temp, battery->wpc_temp
2786 );
2787 dev_dbg(battery->dev,
2788 "%s,Vavg(%dmV),Vocv(%dmV),Tamb(%d),"
2789 "Iavg(%dmA),Iadc(%d)\n",
2790 battery->present ? "Connected" : "Disconnected",
2791 battery->voltage_avg, battery->voltage_ocv,
2792 battery->temper_amb,
2793 battery->current_avg, battery->current_adc);
2794
2795 sec_debug_set_extra_info_batt(battery->capacity, battery->voltage_avg, battery->temperature, battery->current_avg);
2796 }
2797
2798 static void sec_bat_polling_work(struct work_struct *work)
2799 {
2800 struct sec_battery_info *battery = container_of(
2801 work, struct sec_battery_info, polling_work.work);
2802
2803 wake_lock(&battery->monitor_wake_lock);
2804 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
2805 dev_dbg(battery->dev, "%s: Activated\n", __func__);
2806 }
2807
2808 static void sec_bat_program_alarm(
2809 struct sec_battery_info *battery, int seconds)
2810 {
2811 alarm_start(&battery->polling_alarm,
2812 ktime_add(battery->last_poll_time, ktime_set(seconds, 0)));
2813 }
2814
2815 static unsigned int sec_bat_get_polling_time(
2816 struct sec_battery_info *battery)
2817 {
2818 if (battery->status ==
2819 POWER_SUPPLY_STATUS_FULL)
2820 battery->polling_time =
2821 battery->pdata->polling_time[
2822 POWER_SUPPLY_STATUS_CHARGING];
2823 else
2824 battery->polling_time =
2825 battery->pdata->polling_time[
2826 battery->status];
2827
2828 battery->polling_short = true;
2829
2830 switch (battery->status) {
2831 case POWER_SUPPLY_STATUS_CHARGING:
2832 if (battery->polling_in_sleep)
2833 battery->polling_short = false;
2834 break;
2835 case POWER_SUPPLY_STATUS_DISCHARGING:
2836 if (battery->polling_in_sleep && (battery->ps_enable != true)) {
2837 battery->polling_time =
2838 battery->pdata->polling_time[
2839 SEC_BATTERY_POLLING_TIME_SLEEP];
2840 } else
2841 battery->polling_time =
2842 battery->pdata->polling_time[
2843 battery->status];
2844 if (!battery->wc_enable) {
2845 battery->polling_time = battery->pdata->polling_time[
2846 SEC_BATTERY_POLLING_TIME_CHARGING];
2847 pr_info("%s: wc_enable is false, polling time is 30sec\n", __func__);
2848 }
2849 battery->polling_short = false;
2850 break;
2851 case POWER_SUPPLY_STATUS_FULL:
2852 if (battery->polling_in_sleep) {
2853 if (!(battery->pdata->full_condition_type &
2854 SEC_BATTERY_FULL_CONDITION_NOSLEEPINFULL) &&
2855 battery->charging_mode ==
2856 SEC_BATTERY_CHARGING_NONE) {
2857 battery->polling_time =
2858 battery->pdata->polling_time[
2859 SEC_BATTERY_POLLING_TIME_SLEEP];
2860 }
2861 battery->polling_short = false;
2862 } else {
2863 if (battery->charging_mode ==
2864 SEC_BATTERY_CHARGING_NONE)
2865 battery->polling_short = false;
2866 }
2867 break;
2868 case POWER_SUPPLY_STATUS_NOT_CHARGING:
2869 if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE ||
2870 (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) &&
2871 (battery->health_check_count > 0)) {
2872 battery->health_check_count--;
2873 battery->polling_time = 1;
2874 battery->polling_short = false;
2875 }
2876 break;
2877 }
2878
2879 if (battery->polling_short)
2880 return battery->pdata->polling_time[
2881 SEC_BATTERY_POLLING_TIME_BASIC];
2882 /* set polling time to 46s to reduce current noise on wc */
2883 else if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS &&
2884 battery->status == POWER_SUPPLY_STATUS_CHARGING)
2885 battery->polling_time = 46;
2886
2887 return battery->polling_time;
2888 }
2889
2890 static bool sec_bat_is_short_polling(
2891 struct sec_battery_info *battery)
2892 {
2893 /* Change the full and short monitoring sequence
2894 * Originally, full monitoring was the last time of polling_count
2895 * But change full monitoring to first time
2896 * because temperature check is too late
2897 */
2898 if (!battery->polling_short || battery->polling_count == 1)
2899 return false;
2900 else
2901 return true;
2902 }
2903
2904 static void sec_bat_update_polling_count(
2905 struct sec_battery_info *battery)
2906 {
2907 /* do NOT change polling count in sleep
2908 * even though it is short polling
2909 * to keep polling count along sleep/wakeup
2910 */
2911 if (battery->polling_short && battery->polling_in_sleep)
2912 return;
2913
2914 if (battery->polling_short &&
2915 ((battery->polling_time /
2916 battery->pdata->polling_time[
2917 SEC_BATTERY_POLLING_TIME_BASIC])
2918 > battery->polling_count))
2919 battery->polling_count++;
2920 else
2921 battery->polling_count = 1; /* initial value = 1 */
2922 }
2923
2924 static void sec_bat_set_polling(
2925 struct sec_battery_info *battery)
2926 {
2927 unsigned int polling_time_temp = 0;
2928
2929 dev_dbg(battery->dev, "%s: Start\n", __func__);
2930
2931 polling_time_temp = sec_bat_get_polling_time(battery);
2932
2933 dev_info(battery->dev,
2934 "%s: Status:%s, Sleep:%s, Charging:%s, Short Poll:%s\n",
2935 __func__, sec_bat_status_str[battery->status],
2936 battery->polling_in_sleep ? "Yes" : "No",
2937 (battery->charging_mode ==
2938 SEC_BATTERY_CHARGING_NONE) ? "No" : "Yes",
2939 battery->polling_short ? "Yes" : "No");
2940 dev_info(battery->dev,
2941 "%s: Polling time %d/%d sec.\n", __func__,
2942 battery->polling_short ?
2943 (polling_time_temp * battery->polling_count) :
2944 polling_time_temp, battery->polling_time);
2945
2946 /* To sync with log above,
2947 * change polling count after log is displayed
2948 * Do NOT update polling count in initial monitor
2949 */
2950 if (!battery->pdata->monitor_initial_count)
2951 sec_bat_update_polling_count(battery);
2952 else
2953 dev_dbg(battery->dev,
2954 "%s: Initial monitor %d times left.\n", __func__,
2955 battery->pdata->monitor_initial_count);
2956
2957 switch (battery->pdata->polling_type) {
2958 case SEC_BATTERY_MONITOR_WORKQUEUE:
2959 if (battery->pdata->monitor_initial_count) {
2960 battery->pdata->monitor_initial_count--;
2961 schedule_delayed_work(&battery->polling_work, HZ);
2962 } else
2963 schedule_delayed_work(&battery->polling_work,
2964 polling_time_temp * HZ);
2965 break;
2966 case SEC_BATTERY_MONITOR_ALARM:
2967 battery->last_poll_time = ktime_get_boottime();
2968
2969 if (battery->pdata->monitor_initial_count) {
2970 battery->pdata->monitor_initial_count--;
2971 sec_bat_program_alarm(battery, 1);
2972 } else
2973 sec_bat_program_alarm(battery, polling_time_temp);
2974 break;
2975 case SEC_BATTERY_MONITOR_TIMER:
2976 break;
2977 default:
2978 break;
2979 }
2980 dev_dbg(battery->dev, "%s: End\n", __func__);
2981 }
2982
2983 /* OTG during HV wireless charging or sleep mode have 4.5W normal wireless charging UI */
2984 static bool sec_bat_hv_wc_normal_mode_check(struct sec_battery_info *battery)
2985 {
2986 union power_supply_propval value = {0, };
2987
2988 psy_do_property(battery->pdata->charger_name, get,
2989 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
2990 if (value.intval || sleep_mode) {
2991 pr_info("%s: otg(%d), sleep_mode(%d)\n", __func__, value.intval, sleep_mode);
2992 return true;
2993 }
2994 return false;
2995 }
2996
2997 #if defined(CONFIG_BATTERY_SWELLING)
2998 static void sec_bat_swelling_fullcharged_check(struct sec_battery_info *battery)
2999 {
3000 union power_supply_propval value = {0, };
3001
3002 psy_do_property(battery->pdata->charger_name, get,
3003 POWER_SUPPLY_PROP_STATUS, value);
3004
3005 if (value.intval == POWER_SUPPLY_STATUS_FULL) {
3006 battery->swelling_full_check_cnt++;
3007 pr_info("%s: Swelling mode full-charged check (%d)\n",
3008 __func__, battery->swelling_full_check_cnt);
3009 } else
3010 battery->swelling_full_check_cnt = 0;
3011
3012 if (battery->swelling_full_check_cnt >=
3013 battery->pdata->full_check_count) {
3014 battery->swelling_full_check_cnt = 0;
3015 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
3016 battery->is_recharging = false;
3017 battery->swelling_mode = SWELLING_MODE_FULL;
3018 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
3019 battery->expired_time = battery->pdata->expired_time;
3020 battery->prev_safety_time = 0;
3021 #if defined(CONFIG_BATTERY_CISD)
3022 battery->cisd.data[CISD_DATA_SWELLING_FULL_CNT]++;
3023 battery->cisd.data[CISD_DATA_SWELLING_FULL_CNT_PER_DAY]++;
3024 #endif
3025 }
3026 }
3027 #endif
3028
3029 #if defined(CONFIG_CALC_TIME_TO_FULL)
3030 static void sec_bat_calc_time_to_full(struct sec_battery_info * battery)
3031 {
3032 if (delayed_work_pending(&battery->timetofull_work)) {
3033 pr_info("%s: keep time_to_full(%5d sec)\n", __func__, battery->timetofull);
3034 } else if (battery->status == POWER_SUPPLY_STATUS_CHARGING ||
3035 (battery->status == POWER_SUPPLY_STATUS_FULL && battery->capacity != 100)) {
3036 union power_supply_propval value = {0, };
3037 int charge = 0;
3038
3039 if (is_hv_wire_12v_type(battery->cable_type) ||
3040 battery->max_charge_power >= (battery->pdata->pd_charging_charge_power + 5000)) { /* 20000mW */
3041 charge = battery->pdata->ttf_hv_12v_charge_current;
3042 } else if (is_hv_wire_type(battery->cable_type) ||
3043 /* if max_charge_power could support over than max_charging_current, calculate based on ttf_hv_charge_current */
3044 battery->max_charge_power >= (battery->pdata->max_charging_current * 5)) {
3045 charge = battery->pdata->ttf_hv_charge_current;
3046 } else if (is_hv_wireless_type(battery->cable_type) ||
3047 battery->cable_type == SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV) {
3048 if (sec_bat_hv_wc_normal_mode_check(battery))
3049 charge = battery->pdata->ttf_wireless_charge_current;
3050 else
3051 charge = battery->pdata->ttf_hv_wireless_charge_current;
3052 } else if (is_nv_wireless_type(battery->cable_type)) {
3053 charge = battery->pdata->ttf_wireless_charge_current;
3054 } else {
3055 charge = battery->max_charge_power / 5;
3056 }
3057 value.intval = charge;
3058 psy_do_property(battery->pdata->fuelgauge_name, get,
3059 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, value);
3060 dev_info(battery->dev, "%s: T: %5d sec, passed time: %5ld, current: %d\n",
3061 __func__, value.intval, battery->charging_passed_time, charge);
3062 battery->timetofull = value.intval;
3063 } else {
3064 battery->timetofull = -1;
3065 }
3066 }
3067
3068 static void sec_bat_time_to_full_work(struct work_struct *work)
3069 {
3070 struct sec_battery_info *battery = container_of(work,
3071 struct sec_battery_info, timetofull_work.work);
3072 union power_supply_propval value = {0, };
3073
3074 psy_do_property(battery->pdata->charger_name, get,
3075 POWER_SUPPLY_PROP_CURRENT_MAX, value);
3076 battery->current_max = value.intval;
3077
3078 value.intval = SEC_BATTERY_CURRENT_MA;
3079 psy_do_property(battery->pdata->fuelgauge_name, get,
3080 POWER_SUPPLY_PROP_CURRENT_NOW, value);
3081 battery->current_now = value.intval;
3082
3083 value.intval = SEC_BATTERY_CURRENT_MA;
3084 psy_do_property(battery->pdata->fuelgauge_name, get,
3085 POWER_SUPPLY_PROP_CURRENT_AVG, value);
3086 battery->current_avg = value.intval;
3087
3088 sec_bat_calc_time_to_full(battery);
3089 dev_info(battery->dev, "%s: \n",__func__);
3090 if (battery->voltage_now > 0)
3091 battery->voltage_now--;
3092
3093 power_supply_changed(battery->psy_bat);
3094 }
3095 #endif
3096
3097 extern bool get_usb_enumeration_state(void);
3098 /* To disaply slow charging when usb charging 100MA*/
3099 static void sec_bat_check_slowcharging_work(struct work_struct *work)
3100 {
3101 struct sec_battery_info *battery = container_of(work,
3102 struct sec_battery_info, slowcharging_work.work);
3103
3104 if (battery->pdic_info.sink_status.rp_currentlvl == RP_CURRENT_LEVEL_DEFAULT &&
3105 battery->cable_type == SEC_BATTERY_CABLE_USB) {
3106 if (!get_usb_enumeration_state() &&
3107 (battery->current_event & SEC_BAT_CURRENT_EVENT_USB_100MA)) {
3108 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_TIMEOUT_OPEN_TYPE, 0);
3109 battery->max_charge_power = battery->input_voltage * battery->current_max;
3110 }
3111 }
3112 dev_info(battery->dev, "%s: \n",__func__);
3113 }
3114
3115 static void sec_bat_wc_cv_mode_check(struct sec_battery_info *battery)
3116 {
3117 union power_supply_propval value = {0, };
3118
3119 pr_info("%s: battery->wc_cv_mode = %d \n", __func__, battery->wc_cv_mode);
3120
3121 if (battery->capacity >= battery->pdata->wireless_cc_cv) {
3122 pr_info("%s: 4.5W WC Changed Vout input current limit\n", __func__);
3123 battery->wc_cv_mode = true;
3124 sec_bat_set_charging_current(battery);
3125 value.intval = WIRELESS_VOUT_CC_CV_VOUT; // 5.5V
3126 psy_do_property(battery->pdata->wireless_charger_name, set,
3127 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
3128 value.intval = WIRELESS_VRECT_ADJ_ROOM_5; // 80mv
3129 psy_do_property(battery->pdata->wireless_charger_name, set,
3130 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
3131 if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS ||
3132 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND ||
3133 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) {
3134 value.intval = WIRELESS_CLAMP_ENABLE;
3135 psy_do_property(battery->pdata->wireless_charger_name, set,
3136 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
3137 }
3138 /* Change FOD values for CV mode */
3139 value.intval = POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE;
3140 psy_do_property(battery->pdata->wireless_charger_name, set,
3141 POWER_SUPPLY_PROP_STATUS, value);
3142 }
3143 }
3144
3145 static void sec_bat_siop_level_work(struct work_struct *work)
3146 {
3147 struct sec_battery_info *battery = container_of(work,
3148 struct sec_battery_info, siop_level_work.work);
3149
3150 pr_info("%s : set current by siop level(%d)\n",__func__, battery->siop_level);
3151 sec_bat_set_charging_current(battery);
3152 wake_unlock(&battery->siop_level_wake_lock);
3153 }
3154
3155 static void sec_bat_wc_headroom_work(struct work_struct *work)
3156 {
3157 struct sec_battery_info *battery = container_of(work,
3158 struct sec_battery_info, wc_headroom_work.work);
3159 union power_supply_propval value = {0, };
3160
3161 /* The default headroom is high, because initial wireless charging state is unstable.
3162 After 10sec wireless charging, however, recover headroom level to avoid chipset damage */
3163 if (battery->wc_status != SEC_WIRELESS_PAD_NONE) {
3164 /* When the capacity is higher than 99, and the device is in 5V wireless charging state,
3165 then Vrect headroom has to be headroom_2.
3166 Refer to the sec_bat_siop_work function. */
3167 if (battery->capacity < 99 && battery->status != POWER_SUPPLY_STATUS_FULL) {
3168 if (is_nv_wireless_type(battery->cable_type)) {
3169 if (battery->capacity < battery->pdata->wireless_cc_cv)
3170 value.intval = WIRELESS_VRECT_ADJ_ROOM_4; /* WPC 4.5W, Vrect Room 30mV */
3171 else
3172 value.intval = WIRELESS_VRECT_ADJ_ROOM_5; /* WPC 4.5W, Vrect Room 80mV */
3173 } else if (is_hv_wireless_type(battery->cable_type)) {
3174 value.intval = WIRELESS_VRECT_ADJ_ROOM_5;
3175 } else {
3176 value.intval = WIRELESS_VRECT_ADJ_OFF;
3177 }
3178 psy_do_property(battery->pdata->wireless_charger_name, set,
3179 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
3180 pr_info("%s: Changed Vrect adjustment from Rx activation(10seconds)", __func__);
3181 }
3182 if (is_nv_wireless_type(battery->cable_type))
3183 sec_bat_wc_cv_mode_check(battery);
3184 }
3185 wake_unlock(&battery->wc_headroom_wake_lock);
3186 }
3187
3188 static void sec_bat_ext_event_work(struct work_struct *work)
3189 {
3190 struct sec_battery_info *battery = container_of(work,
3191 struct sec_battery_info, ext_event_work.work);
3192
3193 union power_supply_propval value = {0, };
3194
3195 /* TX OFF state, it has only call scenario */
3196 if (battery->ext_event & BATT_EXT_EVENT_CALL) {
3197 pr_info("%s: Call ON\n", __func__);
3198
3199 value.intval = BATT_EXT_EVENT_CALL;
3200 psy_do_property(battery->pdata->wireless_charger_name, set,
3201 POWER_SUPPLY_EXT_PROP_CALL_EVENT, value);
3202
3203 if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_PACK ||
3204 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_PACK ||
3205 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) {
3206 pr_info("%s : Call is on during Wireless Pack or TX\n",__func__);
3207 battery->wc_rx_phm_mode = true;
3208 }
3209 } else if (!(battery->ext_event & BATT_EXT_EVENT_CALL)) {
3210 pr_info("%s: Call OFF\n", __func__);
3211
3212 value.intval = BATT_EXT_EVENT_NONE;
3213 psy_do_property(battery->pdata->wireless_charger_name, set,
3214 POWER_SUPPLY_EXT_PROP_CALL_EVENT, value);
3215
3216 if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_PACK ||
3217 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_PACK ||
3218 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) {
3219 pr_info("%s : Call is off during Wireless Pack or TX\n",__func__);
3220 }
3221
3222 /* process phm */
3223 if(battery->wc_rx_phm_mode) {
3224 pr_info("%s: ESCAPE PHM STEP 1 - WC CONTROL: Enable", __func__);
3225 gpio_direction_output(battery->pdata->wpc_en, 0);
3226 msleep(100);
3227 pr_info("%s: ESCAPE PHM STEP 2 - WC CONTROL: Disable", __func__);
3228 gpio_direction_output(battery->pdata->wpc_en, 1);
3229 msleep(510);
3230 pr_info("%s: ESCAPE PHM STEP 3 - WC CONTROL: Enable", __func__);
3231 gpio_direction_output(battery->pdata->wpc_en, 0);
3232 }
3233 battery->wc_rx_phm_mode = false;
3234 }
3235 wake_unlock(&battery->ext_event_wake_lock);
3236 }
3237
3238 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
3239 static void sec_bat_fw_update_work(struct sec_battery_info *battery, int mode)
3240 {
3241 union power_supply_propval value = {0, };
3242
3243 dev_info(battery->dev, "%s \n", __func__);
3244
3245 wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
3246
3247 switch (mode) {
3248 case SEC_WIRELESS_RX_SDCARD_MODE:
3249 case SEC_WIRELESS_RX_BUILT_IN_MODE:
3250 value.intval = mode;
3251 psy_do_property(battery->pdata->wireless_charger_name, set,
3252 POWER_SUPPLY_PROP_CHARGE_POWERED_OTG_CONTROL, value);
3253 break;
3254 case SEC_WIRELESS_TX_ON_MODE:
3255 value.intval = true;
3256 psy_do_property(battery->pdata->charger_name, set,
3257 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL, value);
3258
3259 value.intval = mode;
3260 psy_do_property(battery->pdata->wireless_charger_name, set,
3261 POWER_SUPPLY_PROP_CHARGE_POWERED_OTG_CONTROL, value);
3262
3263 break;
3264 case SEC_WIRELESS_TX_OFF_MODE:
3265 value.intval = false;
3266 psy_do_property(battery->pdata->charger_name, set,
3267 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL, value);
3268 break;
3269 default:
3270 break;
3271 }
3272 }
3273
3274 static void sec_bat_fw_init_work(struct work_struct *work)
3275 {
3276 struct sec_battery_info *battery = container_of(work,
3277 struct sec_battery_info, fw_init_work.work);
3278
3279 union power_supply_propval value = {0, };
3280 int uno_status = 0, wpc_det = 0;
3281
3282 dev_info(battery->dev, "%s \n", __func__);
3283
3284 wpc_det = gpio_get_value(battery->pdata->wpc_det);
3285
3286 pr_info("%s wpc_det = %d \n", __func__, wpc_det);
3287
3288 psy_do_property(battery->pdata->charger_name, get,
3289 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL, value);
3290 uno_status = value.intval;
3291 pr_info("%s uno = %d \n", __func__, uno_status);
3292
3293 if (!uno_status && !wpc_det) {
3294 pr_info("%s uno on \n", __func__);
3295 value.intval = true;
3296 psy_do_property(battery->pdata->charger_name, set,
3297 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL, value);
3298 }
3299
3300 value.intval = SEC_WIRELESS_RX_INIT;
3301 psy_do_property(battery->pdata->wireless_charger_name, set,
3302 POWER_SUPPLY_PROP_CHARGE_POWERED_OTG_CONTROL, value);
3303
3304 if (!uno_status && !wpc_det) {
3305 pr_info("%s uno off \n", __func__);
3306 value.intval = false;
3307 psy_do_property(battery->pdata->charger_name, set,
3308 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL, value);
3309 }
3310 }
3311 #endif
3312 #if defined(CONFIG_UPDATE_BATTERY_DATA)
3313 static int sec_bat_parse_dt(struct device *dev, struct sec_battery_info *battery);
3314 static void sec_bat_update_data_work(struct work_struct *work)
3315 {
3316 struct sec_battery_info *battery = container_of(work,
3317 struct sec_battery_info, batt_data_work.work);
3318
3319 sec_battery_update_data(battery->data_path);
3320 wake_unlock(&battery->batt_data_wake_lock);
3321 }
3322 #endif
3323
3324 static void sec_bat_misc_event_work(struct work_struct *work)
3325 {
3326 struct sec_battery_info *battery = container_of(work,
3327 struct sec_battery_info, misc_event_work.work);
3328 int xor_misc_event = battery->prev_misc_event ^ battery->misc_event;
3329
3330 if ((xor_misc_event & BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE) &&
3331 (battery->cable_type == SEC_BATTERY_CABLE_NONE)) {
3332 if (battery->misc_event & BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE) {
3333 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
3334 } else if (battery->prev_misc_event & BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE) {
3335 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
3336 }
3337 }
3338
3339 pr_info("%s: change misc event(0x%x --> 0x%x)\n",
3340 __func__, battery->prev_misc_event, battery->misc_event);
3341 battery->prev_misc_event = battery->misc_event;
3342 wake_unlock(&battery->misc_event_wake_lock);
3343
3344 wake_lock(&battery->monitor_wake_lock);
3345 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3346 }
3347
3348 static void sec_bat_calculate_safety_time(struct sec_battery_info *battery)
3349 {
3350 unsigned long long expired_time = battery->expired_time;
3351 struct timespec ts = {0, };
3352 int curr = 0;
3353 int input_power = battery->current_max * battery->input_voltage * 1000;
3354 int charging_power = battery->charging_current * (battery->pdata->chg_float_voltage / battery->pdata->chg_float_voltage_conv);
3355 static int discharging_cnt = 0;
3356
3357 if (battery->current_avg < 0) {
3358 discharging_cnt++;
3359 } else {
3360 discharging_cnt = 0;
3361 }
3362
3363 if (discharging_cnt >= 5) {
3364 battery->expired_time = battery->pdata->expired_time;
3365 battery->prev_safety_time = 0;
3366 pr_info("%s : SAFETY TIME RESET! DISCHARGING CNT(%d)\n",
3367 __func__, discharging_cnt);
3368 discharging_cnt = 0;
3369 return;
3370 } else if (battery->lcd_status && battery->stop_timer) {
3371 battery->prev_safety_time = 0;
3372 return;
3373 }
3374
3375 get_monotonic_boottime(&ts);
3376
3377 if (battery->prev_safety_time == 0) {
3378 battery->prev_safety_time = ts.tv_sec;
3379 }
3380
3381 if (input_power > charging_power) {
3382 curr = battery->charging_current;
3383 } else {
3384 curr = input_power / (battery->pdata->chg_float_voltage / battery->pdata->chg_float_voltage_conv);
3385 curr = (curr * 9) / 10;
3386 }
3387
3388 if (battery->lcd_status && !battery->stop_timer) {
3389 battery->stop_timer = true;
3390 } else if (!battery->lcd_status && battery->stop_timer) {
3391 battery->stop_timer = false;
3392 }
3393
3394 pr_info("%s : EXPIRED_TIME(%llu), IP(%d), CP(%d), CURR(%d), STANDARD(%d)\n",
3395 __func__, expired_time, input_power, charging_power, curr, battery->pdata->standard_curr);
3396
3397 if (curr == 0)
3398 return;
3399
3400 expired_time = (expired_time * battery->pdata->standard_curr) / curr;
3401
3402 pr_info("%s : CAL_EXPIRED_TIME(%llu) TIME NOW(%ld) TIME PREV(%ld)\n", __func__, expired_time, ts.tv_sec, battery->prev_safety_time);
3403
3404 if (expired_time <= ((ts.tv_sec - battery->prev_safety_time) * 1000))
3405 expired_time = 0;
3406 else
3407 expired_time -= ((ts.tv_sec - battery->prev_safety_time) * 1000);
3408
3409 battery->cal_safety_time = expired_time;
3410 expired_time = (expired_time * curr) / battery->pdata->standard_curr;
3411
3412 battery->expired_time = expired_time;
3413 battery->prev_safety_time = ts.tv_sec;
3414 pr_info("%s : REMAIN_TIME(%ld) CAL_REMAIN_TIME(%ld)\n", __func__, battery->expired_time, battery->cal_safety_time);
3415 }
3416
3417 static void sec_bat_monitor_work(
3418 struct work_struct *work)
3419 {
3420 struct sec_battery_info *battery =
3421 container_of(work, struct sec_battery_info,
3422 monitor_work.work);
3423 static struct timespec old_ts = {0, };
3424 struct timespec c_ts = {0, };
3425
3426 dev_dbg(battery->dev, "%s: Start\n", __func__);
3427 c_ts = ktime_to_timespec(ktime_get_boottime());
3428
3429 mutex_lock(&battery->wclock);
3430 if (!battery->wc_enable) {
3431 pr_info("%s: wc_enable(%d), cnt(%d)\n",
3432 __func__, battery->wc_enable, battery->wc_enable_cnt);
3433 if (battery->wc_enable_cnt > battery->wc_enable_cnt_value) {
3434 battery->wc_enable = true;
3435 battery->wc_enable_cnt = 0;
3436 if (battery->pdata->wpc_en) {
3437 gpio_direction_output(battery->pdata->wpc_en, 0);
3438 pr_info("%s: WC CONTROL: Enable", __func__);
3439 }
3440 pr_info("%s: wpc_en(%d)\n",
3441 __func__, gpio_get_value(battery->pdata->wpc_en));
3442 }
3443 battery->wc_enable_cnt++;
3444 }
3445 mutex_unlock(&battery->wclock);
3446
3447 /* monitor once after wakeup */
3448 if (battery->polling_in_sleep) {
3449 battery->polling_in_sleep = false;
3450 if ((battery->status == POWER_SUPPLY_STATUS_DISCHARGING) &&
3451 (battery->ps_enable != true)) {
3452 if ((unsigned long)(c_ts.tv_sec - old_ts.tv_sec) < 10 * 60) {
3453 union power_supply_propval value = {0, };
3454
3455 psy_do_property(battery->pdata->fuelgauge_name, get,
3456 POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
3457 battery->voltage_now = value.intval;
3458
3459 value.intval = 0;
3460 psy_do_property(battery->pdata->fuelgauge_name, get,
3461 POWER_SUPPLY_PROP_CAPACITY, value);
3462 battery->capacity = value.intval;
3463
3464 sec_bat_get_temperature_info(battery);
3465 #if defined(CONFIG_BATTERY_CISD)
3466 sec_bat_cisd_check(battery);
3467 #endif
3468 power_supply_changed(battery->psy_bat);
3469 pr_info("Skip monitor work(%ld, Vnow:%d(mV), SoC:%d(%%), Tbat:%d(0.1'C))\n",
3470 c_ts.tv_sec - old_ts.tv_sec, battery->voltage_now, battery->capacity, battery->temperature);
3471
3472 goto skip_monitor;
3473 }
3474 }
3475 }
3476 /* update last monitor time */
3477 old_ts = c_ts;
3478
3479 sec_bat_get_battery_info(battery);
3480 #if defined(CONFIG_BATTERY_CISD)
3481 sec_bat_cisd_check(battery);
3482 #endif
3483
3484 #if defined(CONFIG_STEP_CHARGING)
3485 sec_bat_check_step_charging(battery);
3486 #endif
3487 #if defined(CONFIG_CALC_TIME_TO_FULL)
3488 /* time to full check */
3489 sec_bat_calc_time_to_full(battery);
3490 #endif
3491
3492 /* 0. test mode */
3493 if (battery->test_mode) {
3494 dev_err(battery->dev, "%s: Test Mode\n", __func__);
3495 sec_bat_do_test_function(battery);
3496 if (battery->test_mode != 0)
3497 goto continue_monitor;
3498 }
3499
3500 /* 1. battery check */
3501 if (!sec_bat_battery_cable_check(battery))
3502 goto continue_monitor;
3503
3504 /* 2. voltage check */
3505 if (!sec_bat_voltage_check(battery))
3506 goto continue_monitor;
3507
3508 /* monitor short routine in initial monitor */
3509 if (battery->pdata->monitor_initial_count || sec_bat_is_short_polling(battery))
3510 goto skip_current_monitor;
3511
3512 /* 3. time management */
3513 if (!sec_bat_time_management(battery))
3514 goto continue_monitor;
3515
3516 /* 4. temperature check */
3517 if (!sec_bat_temperature_check(battery))
3518 goto continue_monitor;
3519
3520 #if defined(CONFIG_BATTERY_SWELLING)
3521 sec_bat_swelling_check(battery);
3522
3523 if ((battery->swelling_mode == SWELLING_MODE_CHARGING || battery->swelling_mode == SWELLING_MODE_FULL) &&
3524 (!battery->charging_block))
3525 sec_bat_swelling_fullcharged_check(battery);
3526 else
3527 sec_bat_fullcharged_check(battery);
3528 #else
3529 /* 5. full charging check */
3530 sec_bat_fullcharged_check(battery);
3531 #endif /* CONFIG_BATTERY_SWELLING */
3532
3533 /* 6. additional check */
3534 if (battery->pdata->monitor_additional_check)
3535 battery->pdata->monitor_additional_check();
3536
3537 #if defined(CONFIG_BATTERY_SBM_DATA)
3538 sec_bat_add_sbm_data(battery, SBM_DATA_COMMON_INFO);
3539 #endif
3540
3541 if ((battery->cable_type == SEC_BATTERY_CABLE_WIRELESS ||
3542 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND ||
3543 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) &&
3544 !battery->wc_cv_mode && battery->charging_passed_time > 10)
3545 sec_bat_wc_cv_mode_check(battery);
3546
3547 continue_monitor:
3548 /* clear HEATING_CONTROL*/
3549 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL);
3550
3551 /* calculate safety time */
3552 if (!battery->charging_block)
3553 sec_bat_calculate_safety_time(battery);
3554
3555 /* set charging current */
3556 sec_bat_set_charging_current(battery);
3557
3558 skip_current_monitor:
3559 dev_info(battery->dev,
3560 "%s: HLT(%d) HLR(%d) HT(%d), HR(%d), LT(%d), LR(%d), lpcharge(%d)\n",
3561 __func__, battery->temp_highlimit_threshold, battery->temp_highlimit_recovery,
3562 battery->temp_high_threshold, battery->temp_high_recovery,
3563 battery->temp_low_threshold, battery->temp_low_recovery, lpcharge);
3564
3565 dev_info(battery->dev,
3566 "%s: Status(%s), mode(%s), Health(%s), Cable(%s, %s, %d, %d), level(%d%%), slate_mode(%d), store_mode(%d)"
3567 #if defined(CONFIG_AFC_CHARGER_MODE)
3568 ", HV(%s), sleep_mode(%d)"
3569 #endif
3570 #if defined(CONFIG_BATTERY_AGE_FORECAST)
3571 ", Cycle(%d)"
3572 #endif
3573 "\n", __func__,
3574 sec_bat_status_str[battery->status],
3575 sec_bat_charging_mode_str[battery->charging_mode],
3576 sec_bat_health_str[battery->health],
3577 sec_cable_type[battery->cable_type],
3578 sec_cable_type[battery->wire_status],
3579 battery->muic_cable_type,
3580 battery->pd_usb_attached,
3581 battery->siop_level,
3582 battery->slate_mode,
3583 battery->store_mode
3584 #if defined(CONFIG_AFC_CHARGER_MODE)
3585 , battery->hv_chg_name, sleep_mode
3586 #endif
3587 #if defined(CONFIG_BATTERY_AGE_FORECAST)
3588 , battery->batt_cycle
3589 #endif
3590 );
3591 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
3592 dev_info(battery->dev,
3593 "%s: battery->stability_test(%d), battery->eng_not_full_status(%d)\n",
3594 __func__, battery->stability_test, battery->eng_not_full_status);
3595 #endif
3596 #if defined(CONFIG_SEC_FACTORY)
3597 if ((battery->cable_type != SEC_BATTERY_CABLE_NONE) && (battery->cable_type != SEC_BATTERY_CABLE_OTG)) {
3598 #else
3599 if ((battery->cable_type != SEC_BATTERY_CABLE_NONE) && (battery->cable_type != SEC_BATTERY_CABLE_OTG) && battery->store_mode) {
3600 #endif
3601 dev_info(battery->dev,
3602 "%s: @battery->capacity = (%d), battery->status= (%d), battery->store_mode=(%d)\n",
3603 __func__, battery->capacity, battery->status, battery->store_mode);
3604
3605 if (battery->capacity >= STORE_MODE_CHARGING_MAX) {
3606 int chg_mode = battery->misc_event & BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE ?
3607 SEC_BAT_CHG_MODE_BUCK_OFF : SEC_BAT_CHG_MODE_CHARGING_OFF;
3608 /* to discharge the battery, off buck */
3609 if (battery->capacity > STORE_MODE_CHARGING_MAX)
3610 chg_mode = SEC_BAT_CHG_MODE_BUCK_OFF;
3611
3612 sec_bat_set_charging_status(battery,
3613 POWER_SUPPLY_STATUS_DISCHARGING);
3614 sec_bat_set_charge(battery, chg_mode);
3615 }
3616
3617 if ((battery->capacity <= STORE_MODE_CHARGING_MIN) && (battery->status == POWER_SUPPLY_STATUS_DISCHARGING)) {
3618 sec_bat_set_charging_status(battery,
3619 POWER_SUPPLY_STATUS_CHARGING);
3620 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
3621 }
3622 }
3623 power_supply_changed(battery->psy_bat);
3624
3625 skip_monitor:
3626 sec_bat_set_polling(battery);
3627
3628 if (battery->capacity <= 0 || battery->health_change)
3629 wake_lock_timeout(&battery->monitor_wake_lock, HZ * 5);
3630 else
3631 wake_unlock(&battery->monitor_wake_lock);
3632
3633 dev_dbg(battery->dev, "%s: End\n", __func__);
3634
3635 return;
3636 }
3637
3638 static enum alarmtimer_restart sec_bat_alarm(
3639 struct alarm *alarm, ktime_t now)
3640 {
3641 struct sec_battery_info *battery = container_of(alarm,
3642 struct sec_battery_info, polling_alarm);
3643
3644 dev_dbg(battery->dev,
3645 "%s\n", __func__);
3646
3647 /* In wake up, monitor work will be queued in complete function
3648 * To avoid duplicated queuing of monitor work,
3649 * do NOT queue monitor work in wake up by polling alarm
3650 */
3651 if (!battery->polling_in_sleep) {
3652 wake_lock(&battery->monitor_wake_lock);
3653 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3654 dev_dbg(battery->dev, "%s: Activated\n", __func__);
3655 }
3656
3657 return ALARMTIMER_NORESTART;
3658 }
3659
3660 static void sec_bat_check_input_voltage(struct sec_battery_info *battery)
3661 {
3662 unsigned int voltage = 0;
3663 int input_current = battery->pdata->charging_current[battery->cable_type].input_current_limit;
3664
3665 if (battery->cable_type == SEC_BATTERY_CABLE_PDIC) {
3666 battery->max_charge_power = battery->pd_max_charge_power;
3667 return;
3668 }
3669 else if (is_hv_wire_12v_type(battery->cable_type))
3670 voltage = SEC_INPUT_VOLTAGE_12V;
3671 else if (is_hv_wire_9v_type(battery->cable_type))
3672 voltage = SEC_INPUT_VOLTAGE_9V;
3673 else if (is_hv_wireless_type(battery->cable_type) ||
3674 battery->cable_type == SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV)
3675 voltage = SEC_INPUT_VOLTAGE_10V;
3676 else
3677 voltage = SEC_INPUT_VOLTAGE_5V;
3678
3679 battery->input_voltage = voltage;
3680 battery->charge_power = voltage * input_current;
3681 #if !defined(CONFIG_SEC_FACTORY)
3682 if (battery->charge_power > battery->max_charge_power)
3683 #endif
3684 battery->max_charge_power = battery->charge_power;
3685
3686 pr_info("%s: battery->input_voltage : %dV, %dmW, %dmW)\n", __func__,
3687 battery->input_voltage, battery->charge_power, battery->max_charge_power);
3688 }
3689
3690 static void sec_bat_cable_work(struct work_struct *work)
3691 {
3692 struct sec_battery_info *battery = container_of(work,
3693 struct sec_battery_info, cable_work.work);
3694 union power_supply_propval val = {0, };
3695 int current_cable_type = SEC_BATTERY_CABLE_NONE;
3696
3697 dev_info(battery->dev, "%s: Start\n", __func__);
3698 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL,
3699 SEC_BAT_CURRENT_EVENT_SKIP_HEATING_CONTROL);
3700 #if defined(CONFIG_CCIC_NOTIFIER)
3701 if (battery->wire_status == SEC_BATTERY_CABLE_PDIC) {
3702 if (battery->pdic_info.sink_status.selected_pdo_num ==
3703 battery->pdic_info.sink_status.current_pdo_num)
3704 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_SELECT_PDO);
3705 sec_bat_get_input_current_in_power_list(battery);
3706 sec_bat_get_charging_current_in_power_list(battery);
3707 }
3708 #endif
3709
3710 if (battery->wc_status && battery->wc_enable) {
3711 int wireless_current, wire_current;
3712 int temp_current_type;
3713
3714 if (battery->wc_status == SEC_WIRELESS_PAD_WPC)
3715 current_cable_type = SEC_BATTERY_CABLE_WIRELESS;
3716 else if (battery->wc_status == SEC_WIRELESS_PAD_WPC_HV)
3717 current_cable_type = SEC_BATTERY_CABLE_HV_WIRELESS;
3718 else if (battery->wc_status == SEC_WIRELESS_PAD_WPC_PACK)
3719 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_PACK;
3720 else if (battery->wc_status == SEC_WIRELESS_PAD_WPC_PACK_HV)
3721 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_HV_PACK;
3722 else if (battery->wc_status == SEC_WIRELESS_PAD_WPC_STAND)
3723 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_STAND;
3724 else if (battery->wc_status == SEC_WIRELESS_PAD_WPC_STAND_HV)
3725 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_HV_STAND;
3726 else if (battery->wc_status == SEC_WIRELESS_PAD_VEHICLE)
3727 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_VEHICLE;
3728 else if (battery->wc_status == SEC_WIRELESS_PAD_VEHICLE_HV)
3729 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_HV_VEHICLE;
3730 else if (battery->wc_status == SEC_WIRELESS_PAD_PREPARE_HV)
3731 current_cable_type = SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV;
3732 else if (battery->wc_status == SEC_WIRELESS_PAD_TX)
3733 current_cable_type = SEC_BATTERY_CABLE_WIRELESS_TX;
3734 else
3735 current_cable_type = SEC_BATTERY_CABLE_PMA_WIRELESS;
3736
3737 if (current_cable_type == SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV)
3738 temp_current_type = SEC_BATTERY_CABLE_HV_WIRELESS;
3739 else
3740 temp_current_type = current_cable_type;
3741
3742 if (battery->wire_status != SEC_BATTERY_CABLE_NONE) {
3743 wireless_current = battery->pdata->charging_current[temp_current_type].input_current_limit;
3744 wireless_current = wireless_current * (is_hv_wireless_type(temp_current_type) ?
3745 SEC_INPUT_VOLTAGE_9V : SEC_INPUT_VOLTAGE_5V);
3746 if (battery->wire_status == SEC_BATTERY_CABLE_PDIC) {
3747 if (wireless_current < battery->pd_max_charge_power)
3748 current_cable_type = battery->wire_status;
3749 } else {
3750 wire_current = (battery->wire_status == SEC_BATTERY_CABLE_PREPARE_TA ?
3751 battery->pdata->charging_current[SEC_BATTERY_CABLE_TA].input_current_limit :
3752 battery->pdata->charging_current[battery->wire_status].input_current_limit);
3753
3754 wire_current = wire_current * (is_hv_wire_type(battery->wire_status) ?
3755 (battery->wire_status == SEC_BATTERY_CABLE_12V_TA ? SEC_INPUT_VOLTAGE_12V : SEC_INPUT_VOLTAGE_9V)
3756 : SEC_INPUT_VOLTAGE_5V);
3757 pr_info("%s: wl_cur(%d), wr_cur(%d), wc_cable_type(%d), wire_cable_type(%d)\n",
3758 __func__, wireless_current, wire_current, current_cable_type, battery->wire_status);
3759
3760 if (wireless_current < wire_current)
3761 current_cable_type = battery->wire_status;
3762 }
3763 }
3764 } else
3765 current_cable_type = battery->wire_status;
3766
3767 if (battery->wc_status) {
3768 /* wired charger has priority, but wireless charger exist. */
3769 val.intval = is_wired_type(current_cable_type) ?
3770 MFC_LDO_OFF : MFC_LDO_ON;
3771 psy_do_property(battery->pdata->wireless_charger_name, set,
3772 POWER_SUPPLY_PROP_CHARGE_EMPTY, val);
3773 }
3774
3775 if (current_cable_type == SEC_BATTERY_CABLE_PDIC &&
3776 battery->cable_type == SEC_BATTERY_CABLE_PDIC &&
3777 !battery->slate_mode) {
3778 cancel_delayed_work(&battery->afc_work);
3779 wake_unlock(&battery->afc_wake_lock);
3780 sec_bat_set_current_event(battery, 0,
3781 SEC_BAT_CURRENT_EVENT_AFC | SEC_BAT_CURRENT_EVENT_AICL);
3782 battery->aicl_current = 0;
3783 sec_bat_set_charging_current(battery);
3784 power_supply_changed(battery->psy_bat);
3785 goto end_of_cable_work;
3786 }
3787
3788 /* to clear this value when cable type switched without dettach */
3789 if ((is_wired_type(battery->cable_type) && is_wireless_type(current_cable_type)) ||
3790 (is_wireless_type(battery->cable_type) && is_wired_type(current_cable_type)))
3791 battery->max_charge_power = 0;
3792
3793 if ((current_cable_type == battery->cable_type) && !battery->slate_mode) {
3794 dev_dbg(battery->dev,
3795 "%s: Cable is NOT Changed(%d)\n",
3796 __func__, battery->cable_type);
3797 /* Do NOT activate cable work for NOT changed */
3798 goto end_of_cable_work;
3799 }
3800
3801 #if defined(CONFIG_BATTERY_SWELLING)
3802 if ((current_cable_type == SEC_BATTERY_CABLE_NONE) ||
3803 (battery->cable_type == SEC_BATTERY_CABLE_NONE && battery->swelling_mode == SWELLING_MODE_NONE) ||
3804 (battery->cable_type == SEC_BATTERY_CABLE_OTG && battery->swelling_mode == SWELLING_MODE_NONE)) {
3805 battery->swelling_mode = SWELLING_MODE_NONE;
3806 /* restore 4.4V float voltage */
3807 val.intval = battery->pdata->swelling_normal_float_voltage;
3808 psy_do_property(battery->pdata->charger_name, set,
3809 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
3810 pr_info("%s: float voltage = %d\n", __func__, val.intval);
3811 } else {
3812 pr_info("%s: skip float_voltage setting, swelling_mode(%d)\n",
3813 __func__, battery->swelling_mode);
3814 }
3815 #endif
3816
3817 battery->cable_type = current_cable_type;
3818 battery->wpc_vout_level = WIRELESS_VOUT_10V;
3819 if (is_wireless_type(battery->cable_type)) {
3820 power_supply_changed(battery->psy_bat);
3821 /* After 10sec wireless charging, Vrect headroom has to be reduced */
3822 wake_lock(&battery->wc_headroom_wake_lock);
3823 queue_delayed_work(battery->monitor_wqueue, &battery->wc_headroom_work,
3824 msecs_to_jiffies(10000));
3825 }
3826
3827 if (battery->pdata->check_cable_result_callback)
3828 battery->pdata->check_cable_result_callback(battery->cable_type);
3829 /* platform can NOT get information of cable connection
3830 * because wakeup time is too short to check uevent
3831 * To make sure that target is wakeup
3832 * if cable is connected and disconnected,
3833 * activated wake lock in a few seconds
3834 */
3835 wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
3836
3837 if (battery->cable_type == SEC_BATTERY_CABLE_NONE ||
3838 ((battery->pdata->cable_check_type &
3839 SEC_BATTERY_CABLE_CHECK_NOINCOMPATIBLECHARGE) &&
3840 battery->cable_type == SEC_BATTERY_CABLE_UNKNOWN)) {
3841 /* initialize all status */
3842 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
3843 battery->vbus_chg_by_siop = false;
3844 battery->is_recharging = false;
3845 #if defined(CONFIG_BATTERY_CISD)
3846 battery->cisd.charging_end_time = 0;
3847 battery->cisd.recharge_count = 0;
3848 battery->cisd.charging_end_time_2 = 0;
3849 battery->cisd.recharge_count_2 = 0;
3850 battery->cisd.ab_vbat_check_count = 0;
3851 battery->cisd.state &= ~CISD_STATE_OVER_VOLTAGE;
3852 #endif
3853 battery->input_voltage = 0;
3854 battery->charge_power = 0;
3855 battery->max_charge_power = 0;
3856 battery->pd_max_charge_power = 0;
3857 sec_bat_set_charging_status(battery,
3858 POWER_SUPPLY_STATUS_DISCHARGING);
3859 battery->chg_limit = false;
3860 battery->mix_limit = false;
3861 battery->chg_limit_recovery_cable = SEC_BATTERY_CABLE_NONE;
3862 battery->wc_heating_start_time = 0;
3863 battery->health = POWER_SUPPLY_HEALTH_GOOD;
3864 cancel_delayed_work(&battery->afc_work);
3865 wake_unlock(&battery->afc_wake_lock);
3866 sec_bat_change_default_current(battery, SEC_BATTERY_CABLE_USB,
3867 USB_CURRENT_HIGH_SPEED, USB_CURRENT_HIGH_SPEED);
3868 sec_bat_change_default_current(battery, SEC_BATTERY_CABLE_TA,
3869 battery->pdata->default_input_current, battery->pdata->default_charging_current);
3870 /* usb default current is 100mA before configured*/
3871 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_USB_100MA,
3872 (SEC_BAT_CURRENT_EVENT_CHARGE_DISABLE |
3873 SEC_BAT_CURRENT_EVENT_AFC |
3874 SEC_BAT_CURRENT_EVENT_USB_SUPER |
3875 SEC_BAT_CURRENT_EVENT_USB_100MA |
3876 SEC_BAT_CURRENT_EVENT_VBAT_OVP |
3877 SEC_BAT_CURRENT_EVENT_VSYS_OVP |
3878 SEC_BAT_CURRENT_EVENT_CHG_LIMIT |
3879 SEC_BAT_CURRENT_EVENT_AICL |
3880 SEC_BAT_CURRENT_EVENT_SELECT_PDO));
3881
3882 cancel_delayed_work(&battery->slowcharging_work);
3883 battery->wc_cv_mode = false;
3884 battery->is_sysovlo = false;
3885 battery->is_vbatovlo = false;
3886 battery->is_abnormal_temp = false;
3887
3888 if (sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF))
3889 goto end_of_cable_work;
3890 } else if(battery->slate_mode) {
3891 dev_info(battery->dev,
3892 "%s:slate mode on\n",__func__);
3893 battery->is_recharging = false;
3894 battery->cable_type = SEC_BATTERY_CABLE_NONE;
3895 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
3896 battery->health = POWER_SUPPLY_HEALTH_GOOD;
3897 sec_bat_set_charging_status(battery,
3898 POWER_SUPPLY_STATUS_DISCHARGING);
3899 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_BUCK_OFF);
3900 } else {
3901 #if defined(CONFIG_EN_OOPS)
3902 val.intval = battery->cable_type;
3903 psy_do_property(battery->pdata->fuelgauge_name, set,
3904 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, val);
3905 #endif
3906 /* Do NOT display the charging icon when OTG or HMT_CONNECTED is enabled */
3907 if (battery->cable_type == SEC_BATTERY_CABLE_OTG ||
3908 battery->cable_type == SEC_BATTERY_CABLE_POWER_SHARING) {
3909 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
3910 battery->status = POWER_SUPPLY_STATUS_DISCHARGING;
3911 } else if (!battery->is_sysovlo && !battery->is_vbatovlo && !battery->is_abnormal_temp &&
3912 (!battery->charging_block || !battery->swelling_mode)) {
3913 if (battery->pdata->full_check_type !=
3914 SEC_BATTERY_FULLCHARGED_NONE)
3915 battery->charging_mode =
3916 SEC_BATTERY_CHARGING_1ST;
3917 else
3918 battery->charging_mode =
3919 SEC_BATTERY_CHARGING_2ND;
3920
3921 if (battery->status == POWER_SUPPLY_STATUS_FULL)
3922 sec_bat_set_charging_status(battery,
3923 POWER_SUPPLY_STATUS_FULL);
3924 else
3925 sec_bat_set_charging_status(battery,
3926 POWER_SUPPLY_STATUS_CHARGING);
3927 }
3928
3929 if (!battery->is_sysovlo && !battery->is_vbatovlo && !battery->is_abnormal_temp)
3930 battery->health = POWER_SUPPLY_HEALTH_GOOD;
3931
3932 if (battery->cable_type == SEC_BATTERY_CABLE_TA ||
3933 battery->cable_type == SEC_BATTERY_CABLE_WIRELESS ||
3934 battery->cable_type == SEC_BATTERY_CABLE_PMA_WIRELESS) {
3935 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_AFC, SEC_BAT_CURRENT_EVENT_AFC);
3936 } else {
3937 cancel_delayed_work(&battery->afc_work);
3938 wake_unlock(&battery->afc_wake_lock);
3939 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_AFC);
3940 }
3941
3942 if (battery->cable_type == SEC_BATTERY_CABLE_OTG ||
3943 battery->cable_type == SEC_BATTERY_CABLE_POWER_SHARING) {
3944 if (sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF))
3945 goto end_of_cable_work;
3946 } else if (!battery->is_sysovlo && !battery->is_vbatovlo && !battery->is_abnormal_temp &&
3947 (!battery->charging_block || !battery->swelling_mode)) {
3948 if (sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING))
3949 goto end_of_cable_work;
3950 }
3951
3952 if (battery->cable_type == SEC_BATTERY_CABLE_USB && !lpcharge)
3953 queue_delayed_work(battery->monitor_wqueue, &battery->slowcharging_work,
3954 msecs_to_jiffies(3000));
3955
3956 #if defined(CONFIG_CALC_TIME_TO_FULL)
3957 if (lpcharge) {
3958 cancel_delayed_work(&battery->timetofull_work);
3959 if (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC) {
3960 int work_delay = 0;
3961
3962 if (!is_wireless_type(battery->cable_type)) {
3963 work_delay = battery->pdata->pre_afc_work_delay;
3964 } else {
3965 work_delay = battery->pdata->pre_wc_afc_work_delay;
3966 }
3967
3968 queue_delayed_work(battery->monitor_wqueue,
3969 &battery->timetofull_work, msecs_to_jiffies(work_delay));
3970 }
3971 }
3972 #endif
3973 }
3974
3975 /* set online(cable type) */
3976 val.intval = battery->cable_type;
3977 psy_do_property(battery->pdata->charger_name, set,
3978 POWER_SUPPLY_PROP_ONLINE, val);
3979 psy_do_property(battery->pdata->fuelgauge_name, set,
3980 POWER_SUPPLY_PROP_ONLINE, val);
3981 /* set charging current */
3982 psy_do_property(battery->pdata->charger_name, get,
3983 POWER_SUPPLY_PROP_CURRENT_AVG, val);
3984 battery->aicl_current = 0;
3985 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_AICL);
3986 battery->input_current = val.intval;
3987 /* to init battery type current when wireless charging -> battery case */
3988 if (battery->cable_type == SEC_BATTERY_CABLE_NONE)
3989 psy_do_property(battery->pdata->charger_name, set,
3990 POWER_SUPPLY_PROP_CURRENT_MAX, val);
3991 if (battery->status != POWER_SUPPLY_STATUS_DISCHARGING)
3992 sec_bat_check_input_voltage(battery);
3993 sec_bat_set_charging_current(battery);
3994
3995 /* polling time should be reset when cable is changed
3996 * polling_in_sleep should be reset also
3997 * before polling time is re-calculated
3998 * to prevent from counting 1 for events
3999 * right after cable is connected
4000 */
4001 battery->polling_in_sleep = false;
4002 sec_bat_get_polling_time(battery);
4003
4004 dev_info(battery->dev,
4005 "%s: Status:%s, Sleep:%s, Charging:%s, Short Poll:%s\n",
4006 __func__, sec_bat_status_str[battery->status],
4007 battery->polling_in_sleep ? "Yes" : "No",
4008 (battery->charging_mode ==
4009 SEC_BATTERY_CHARGING_NONE) ? "No" : "Yes",
4010 battery->polling_short ? "Yes" : "No");
4011 dev_info(battery->dev,
4012 "%s: Polling time is reset to %d sec.\n", __func__,
4013 battery->polling_time);
4014
4015 battery->polling_count = 1; /* initial value = 1 */
4016
4017 wake_lock(&battery->monitor_wake_lock);
4018 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
4019 end_of_cable_work:
4020 wake_unlock(&battery->cable_wake_lock);
4021 dev_info(battery->dev, "%s: End\n", __func__);
4022 }
4023
4024 static void sec_bat_afc_work(struct work_struct *work)
4025 {
4026 struct sec_battery_info *battery = container_of(work,
4027 struct sec_battery_info, afc_work.work);
4028 union power_supply_propval value = {0, };
4029
4030 psy_do_property(battery->pdata->charger_name, get,
4031 POWER_SUPPLY_PROP_CURRENT_MAX, value);
4032 battery->current_max = value.intval;
4033
4034 if (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC) {
4035 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_AFC);
4036 if ((battery->wc_status != SEC_WIRELESS_PAD_NONE &&
4037 battery->current_max >= battery->pdata->pre_wc_afc_input_current) ||
4038 ((battery->cable_type == SEC_BATTERY_CABLE_TA) &&
4039 battery->current_max >= battery->pdata->pre_afc_input_current)) {
4040 sec_bat_set_charging_current(battery);
4041 }
4042 }
4043 wake_unlock(&battery->afc_wake_lock);
4044 }
4045
4046 ssize_t sec_bat_show_attrs(struct device *dev,
4047 struct device_attribute *attr, char *buf)
4048 {
4049 struct power_supply *psy = dev_get_drvdata(dev);
4050 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
4051 const ptrdiff_t offset = attr - sec_battery_attrs;
4052 union power_supply_propval value = {0, };
4053 int i = 0;
4054 int ret = 0;
4055
4056 switch (offset) {
4057 case BATT_RESET_SOC:
4058 break;
4059 case BATT_READ_RAW_SOC:
4060 {
4061 value.intval =
4062 SEC_FUELGAUGE_CAPACITY_TYPE_RAW;
4063 psy_do_property(battery->pdata->fuelgauge_name, get,
4064 POWER_SUPPLY_PROP_CAPACITY, value);
4065
4066 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4067 value.intval);
4068 }
4069 break;
4070 case BATT_READ_ADJ_SOC:
4071 break;
4072 case BATT_TYPE:
4073 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n",
4074 battery->batt_type);
4075 break;
4076 case BATT_VFOCV:
4077 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4078 battery->voltage_ocv);
4079 break;
4080 case BATT_VOL_ADC:
4081 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4082 battery->inbat_adc);
4083 break;
4084 case BATT_VOL_ADC_CAL:
4085 break;
4086 case BATT_VOL_AVER:
4087 break;
4088 case BATT_VOL_ADC_AVER:
4089 break;
4090
4091 case BATT_CURRENT_UA_NOW:
4092 {
4093 value.intval = SEC_BATTERY_CURRENT_UA;
4094 psy_do_property(battery->pdata->fuelgauge_name, get,
4095 POWER_SUPPLY_PROP_CURRENT_NOW, value);
4096 #if defined(CONFIG_SEC_FACTORY)
4097 pr_err("%s: batt_current_ua_now (%d)\n",
4098 __func__, value.intval);
4099 #endif
4100 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4101 value.intval);
4102 }
4103 break;
4104 case BATT_CURRENT_UA_AVG:
4105 {
4106 value.intval = SEC_BATTERY_CURRENT_UA;
4107 psy_do_property(battery->pdata->fuelgauge_name, get,
4108 POWER_SUPPLY_PROP_CURRENT_AVG, value);
4109
4110 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4111 value.intval);
4112 }
4113 break;
4114
4115 case BATT_FILTER_CFG:
4116 {
4117 psy_do_property(battery->pdata->fuelgauge_name, get,
4118 POWER_SUPPLY_PROP_FILTER_CFG, value);
4119
4120 i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n",
4121 value.intval);
4122 }
4123 break;
4124 case BATT_TEMP:
4125 switch (battery->pdata->thermal_source) {
4126 case SEC_BATTERY_THERMAL_SOURCE_FG:
4127 psy_do_property(battery->pdata->fuelgauge_name, get,
4128 POWER_SUPPLY_PROP_TEMP, value);
4129 break;
4130 case SEC_BATTERY_THERMAL_SOURCE_CALLBACK:
4131 if (battery->pdata->get_temperature_callback) {
4132 battery->pdata->get_temperature_callback(
4133 POWER_SUPPLY_PROP_TEMP, &value);
4134 }
4135 break;
4136 case SEC_BATTERY_THERMAL_SOURCE_ADC:
4137 sec_bat_get_value_by_adc(battery,
4138 SEC_BAT_ADC_CHANNEL_TEMP, &value);
4139 break;
4140 default:
4141 break;
4142 }
4143 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4144 value.intval);
4145 break;
4146 case BATT_TEMP_ADC:
4147 /*
4148 If F/G is used for reading the temperature and
4149 compensation table is used,
4150 the raw value that isn't compensated can be read by
4151 POWER_SUPPLY_PROP_TEMP_AMBIENT
4152 */
4153 switch (battery->pdata->thermal_source) {
4154 case SEC_BATTERY_THERMAL_SOURCE_FG:
4155 psy_do_property(battery->pdata->fuelgauge_name, get,
4156 POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
4157 battery->temp_adc = value.intval;
4158 break;
4159 default:
4160 break;
4161 }
4162 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4163 battery->temp_adc);
4164 break;
4165 case BATT_TEMP_AVER:
4166 break;
4167 case BATT_TEMP_ADC_AVER:
4168 break;
4169 case USB_TEMP:
4170 if (battery->pdata->usb_thermal_source) {
4171 sec_bat_get_value_by_adc(battery,
4172 SEC_BAT_ADC_CHANNEL_USB_TEMP, &value);
4173 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4174 value.intval);
4175 } else {
4176 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4177 0);
4178 }
4179 break;
4180 case USB_TEMP_ADC:
4181 if (battery->pdata->usb_thermal_source) {
4182 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4183 battery->usb_temp_adc);
4184 } else {
4185 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4186 0);
4187 }
4188 break;
4189 case CHG_TEMP:
4190 if (battery->pdata->chg_thermal_source) {
4191 sec_bat_get_value_by_adc(battery,
4192 SEC_BAT_ADC_CHANNEL_CHG_TEMP, &value);
4193 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4194 value.intval);
4195 } else {
4196 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4197 0);
4198 }
4199 break;
4200 case CHG_TEMP_ADC:
4201 if (battery->pdata->chg_thermal_source) {
4202 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4203 battery->chg_temp_adc);
4204 } else {
4205 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4206 0);
4207 }
4208 break;
4209 case SLAVE_CHG_TEMP:
4210 if (battery->pdata->slave_thermal_source) {
4211 sec_bat_get_value_by_adc(battery,
4212 SEC_BAT_ADC_CHANNEL_SLAVE_CHG_TEMP, &value);
4213 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4214 value.intval);
4215 } else {
4216 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4217 0);
4218 }
4219 break;
4220 case SLAVE_CHG_TEMP_ADC:
4221 if (battery->pdata->slave_thermal_source) {
4222 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4223 battery->slave_chg_temp_adc);
4224 } else {
4225 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4226 0);
4227 }
4228 break;
4229 case BATT_VF_ADC:
4230 break;
4231 case BATT_SLATE_MODE:
4232 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4233 battery->slate_mode);
4234 break;
4235
4236 case BATT_LP_CHARGING:
4237 if (lpcharge) {
4238 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4239 lpcharge ? 1 : 0);
4240 }
4241 break;
4242 case SIOP_ACTIVATED:
4243 break;
4244 case SIOP_LEVEL:
4245 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4246 battery->siop_level);
4247 break;
4248 case SIOP_EVENT:
4249 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", 0);
4250 break;
4251 case BATT_CHARGING_SOURCE:
4252 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4253 battery->cable_type);
4254 break;
4255 case FG_REG_DUMP:
4256 break;
4257 case FG_RESET_CAP:
4258 break;
4259 case FG_CAPACITY:
4260 {
4261 value.intval =
4262 SEC_BATTERY_CAPACITY_DESIGNED;
4263 psy_do_property(battery->pdata->fuelgauge_name, get,
4264 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4265
4266 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x ",
4267 value.intval);
4268
4269 value.intval =
4270 SEC_BATTERY_CAPACITY_ABSOLUTE;
4271 psy_do_property(battery->pdata->fuelgauge_name, get,
4272 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4273
4274 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x ",
4275 value.intval);
4276
4277 value.intval =
4278 SEC_BATTERY_CAPACITY_TEMPERARY;
4279 psy_do_property(battery->pdata->fuelgauge_name, get,
4280 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4281
4282 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x ",
4283 value.intval);
4284
4285 value.intval =
4286 SEC_BATTERY_CAPACITY_CURRENT;
4287 psy_do_property(battery->pdata->fuelgauge_name, get,
4288 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4289
4290 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x\n",
4291 value.intval);
4292 }
4293 break;
4294 case FG_ASOC:
4295 value.intval = -1;
4296 {
4297 struct power_supply *psy_fg = NULL;
4298 psy_fg = get_power_supply_by_name(battery->pdata->fuelgauge_name);
4299 if (!psy_fg) {
4300 pr_err("%s: Fail to get psy (%s)\n",
4301 __func__, battery->pdata->fuelgauge_name);
4302 } else {
4303 if (psy_fg->desc->get_property != NULL) {
4304 ret = psy_fg->desc->get_property(psy_fg,
4305 POWER_SUPPLY_PROP_ENERGY_FULL, &value);
4306 if (ret < 0) {
4307 pr_err("%s: Fail to %s get (%d=>%d)\n",
4308 __func__, battery->pdata->fuelgauge_name,
4309 POWER_SUPPLY_PROP_ENERGY_FULL, ret);
4310 }
4311 }
4312 }
4313 }
4314 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4315 value.intval);
4316 break;
4317 case AUTH:
4318 break;
4319 case CHG_CURRENT_ADC:
4320 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4321 battery->current_adc);
4322 break;
4323 case WC_ADC:
4324 break;
4325 case WC_STATUS:
4326 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4327 is_wireless_type(battery->cable_type) ? 1: 0);
4328 break;
4329 case WC_ENABLE:
4330 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4331 battery->wc_enable);
4332 break;
4333 case WC_CONTROL:
4334 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4335 battery->wc_enable);
4336 break;
4337 case WC_CONTROL_CNT:
4338 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4339 battery->wc_enable_cnt_value);
4340 break;
4341 case LED_COVER:
4342 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4343 battery->led_cover);
4344 break;
4345 case HV_CHARGER_STATUS:
4346 {
4347 int check_val = 0;
4348 if (is_hv_wire_12v_type(battery->cable_type) ||
4349 battery->max_charge_power >= HV_CHARGER_STATUS_STANDARD2) /* 20000mW */
4350 check_val = 2;
4351 else if (is_hv_wire_type(battery->cable_type) ||
4352 (battery->cable_type == SEC_BATTERY_CABLE_PDIC &&
4353 battery->pd_max_charge_power >= HV_CHARGER_STATUS_STANDARD1 &&
4354 battery->pdic_info.sink_status.available_pdo_num > 1) ||
4355 battery->cable_type == SEC_BATTERY_CABLE_PREPARE_TA ||
4356 battery->max_charge_power >= HV_CHARGER_STATUS_STANDARD1) /* 12000mW */
4357 check_val = 1;
4358
4359 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", check_val);
4360 }
4361 break;
4362 case HV_WC_CHARGER_STATUS:
4363 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4364 is_hv_wireless_type(battery->cable_type) ? 1 : 0);
4365 break;
4366 case HV_CHARGER_SET:
4367 break;
4368 case FACTORY_MODE:
4369 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4370 battery->factory_mode);
4371 break;
4372 case STORE_MODE:
4373 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4374 battery->store_mode);
4375 break;
4376 case UPDATE:
4377 break;
4378 case TEST_MODE:
4379 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4380 battery->test_mode);
4381 break;
4382
4383 case BATT_EVENT_CALL:
4384 case BATT_EVENT_2G_CALL:
4385 case BATT_EVENT_TALK_GSM:
4386 break;
4387 case BATT_EVENT_3G_CALL:
4388 case BATT_EVENT_TALK_WCDMA:
4389 break;
4390 case BATT_EVENT_MUSIC:
4391 break;
4392 case BATT_EVENT_VIDEO:
4393 break;
4394 case BATT_EVENT_BROWSER:
4395 break;
4396 case BATT_EVENT_HOTSPOT:
4397 break;
4398 case BATT_EVENT_CAMERA:
4399 break;
4400 case BATT_EVENT_CAMCORDER:
4401 break;
4402 case BATT_EVENT_DATA_CALL:
4403 break;
4404 case BATT_EVENT_WIFI:
4405 break;
4406 case BATT_EVENT_WIBRO:
4407 break;
4408 case BATT_EVENT_LTE:
4409 break;
4410 case BATT_EVENT_LCD:
4411 break;
4412 case BATT_EVENT_GPS:
4413 break;
4414 case BATT_EVENT:
4415 break;
4416 case BATT_TEMP_TABLE:
4417 i += scnprintf(buf + i, PAGE_SIZE - i,
4418 "%d %d %d %d %d %d %d %d\n",
4419 battery->pdata->temp_high_threshold_normal,
4420 battery->pdata->temp_high_recovery_normal,
4421 battery->pdata->temp_low_threshold_normal,
4422 battery->pdata->temp_low_recovery_normal,
4423 battery->pdata->temp_high_threshold_lpm,
4424 battery->pdata->temp_high_recovery_lpm,
4425 battery->pdata->temp_low_threshold_lpm,
4426 battery->pdata->temp_low_recovery_lpm);
4427 break;
4428 case BATT_HIGH_CURRENT_USB:
4429 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4430 battery->is_hc_usb);
4431 break;
4432 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
4433 case TEST_CHARGE_CURRENT:
4434 {
4435 psy_do_property(battery->pdata->charger_name, get,
4436 POWER_SUPPLY_PROP_CURRENT_NOW, value);
4437 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4438 value.intval);
4439 }
4440 break;
4441 #endif
4442 case SET_STABILITY_TEST:
4443 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4444 battery->stability_test);
4445 break;
4446 case BATT_CAPACITY_MAX:
4447 psy_do_property(battery->pdata->fuelgauge_name, get,
4448 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, value);
4449 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4450 break;
4451 case BATT_INBAT_VOLTAGE:
4452 case BATT_INBAT_VOLTAGE_OCV:
4453 if(battery->pdata->support_fgsrc_change == true) {
4454 int j, k, ocv, ocv_data[10];
4455 value.intval = 0;
4456 psy_do_property(battery->pdata->fgsrc_switch_name, set,
4457 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4458 for (j = 0; j < 10; j++) {
4459 mdelay(175);
4460 psy_do_property(battery->pdata->fuelgauge_name, get,
4461 POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
4462 ocv_data[j] = value.intval;
4463 }
4464 value.intval = 1;
4465 psy_do_property(battery->pdata->fgsrc_switch_name, set,
4466 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4467 for (j = 1; j < 10; j++) {
4468 ocv = ocv_data[j];
4469 k = j;
4470 while (k > 0 && ocv_data[k-1] > ocv) {
4471 ocv_data[k] = ocv_data[k-1];
4472 k--;
4473 }
4474 ocv_data[k] = ocv;
4475 }
4476 ocv = 0;
4477 for (j = 2; j < 8; j++) {
4478 ocv += ocv_data[j];
4479 }
4480 ret = ocv / 6;
4481 } else {
4482 ret = sec_bat_get_inbat_vol_by_adc(battery);
4483 }
4484 dev_info(battery->dev, "in-battery voltage ocv(%d)\n", ret);
4485 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4486 ret);
4487 break;
4488 case CHECK_SLAVE_CHG:
4489 psy_do_property(battery->pdata->charger_name, get,
4490 POWER_SUPPLY_EXT_PROP_CHECK_SLAVE_I2C, value);
4491 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4492 value.intval);
4493 pr_info("%s : CHECK_SLAVE_CHG=%d\n",__func__,value.intval);
4494 break;
4495 case BATT_INBAT_WIRELESS_CS100:
4496 psy_do_property(battery->pdata->wireless_charger_name, get,
4497 POWER_SUPPLY_PROP_STATUS, value);
4498 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4499 break;
4500 case HMT_TA_CONNECTED:
4501 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4502 (battery->cable_type == SEC_BATTERY_CABLE_HMT_CONNECTED) ? 1 : 0);
4503 break;
4504 case HMT_TA_CHARGE:
4505 #if defined(CONFIG_CCIC_NOTIFIER)
4506 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4507 (battery->current_event & SEC_BAT_CURRENT_EVENT_CHARGE_DISABLE) ? 0 : 1);
4508 #else
4509 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4510 (battery->cable_type == SEC_BATTERY_CABLE_HMT_CHARGE) ? 1 : 0);
4511 #endif
4512 break;
4513 #if defined(CONFIG_BATTERY_AGE_FORECAST)
4514 case FG_CYCLE:
4515 value.intval = SEC_BATTERY_CAPACITY_CYCLE;
4516 psy_do_property(battery->pdata->fuelgauge_name, get,
4517 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4518 value.intval = value.intval / 100;
4519 dev_info(battery->dev, "fg cycle(%d)\n", value.intval);
4520 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4521 break;
4522 case FG_FULL_VOLTAGE:
4523 i += scnprintf(buf + i, PAGE_SIZE - i, "%d %d\n",
4524 battery->pdata->chg_float_voltage, battery->pdata->recharge_condition_vcell);
4525 break;
4526 case FG_FULLCAPNOM:
4527 value.intval =
4528 SEC_BATTERY_CAPACITY_AGEDCELL;
4529 psy_do_property(battery->pdata->fuelgauge_name, get,
4530 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4531 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4532 break;
4533 case BATTERY_CYCLE:
4534 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", battery->batt_cycle);
4535 break;
4536 #endif
4537 case BATT_WPC_TEMP:
4538 if (battery->pdata->wpc_thermal_source) {
4539 sec_bat_get_value_by_adc(battery,
4540 SEC_BAT_ADC_CHANNEL_WPC_TEMP, &value);
4541 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4542 value.intval);
4543 } else {
4544 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4545 0);
4546 }
4547 break;
4548 case BATT_WPC_TEMP_ADC:
4549 if (battery->pdata->wpc_thermal_source) {
4550 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4551 battery->wpc_temp_adc);
4552 } else {
4553 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4554 0);
4555 }
4556 break;
4557 case BATT_COIL_TEMP:
4558 if (battery->pdata->coil_thermal_source) {
4559 sec_bat_get_value_by_adc(battery,
4560 SEC_BAT_ADC_CHANNEL_WPC_TEMP, &value);
4561 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4562 value.intval);
4563 } else {
4564 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4565 0);
4566 }
4567 break;
4568 case BATT_COIL_TEMP_ADC:
4569 if (battery->pdata->coil_thermal_source) {
4570 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4571 battery->coil_temp_adc);
4572 } else {
4573 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4574 0);
4575 }
4576 break;
4577 case BATT_WIRELESS_MST_SWITCH_TEST:
4578 value.intval = SEC_WIRELESS_MST_SWITCH_VERIFY;
4579 psy_do_property(battery->pdata->wireless_charger_name, get,
4580 POWER_SUPPLY_PROP_MANUFACTURER, value);
4581 pr_info("%s MST switch verify. result: %x\n", __func__, value.intval);
4582 i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", value.intval);
4583 break;
4584 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
4585 case BATT_WIRELESS_FIRMWARE_UPDATE:
4586 value.intval = SEC_WIRELESS_OTP_FIRM_VERIFY;
4587 psy_do_property(battery->pdata->wireless_charger_name, get,
4588 POWER_SUPPLY_PROP_MANUFACTURER, value);
4589 pr_info("%s RX firmware verify. result: %d\n", __func__, value.intval);
4590 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4591 break;
4592 case OTP_FIRMWARE_RESULT:
4593 value.intval = SEC_WIRELESS_OTP_FIRM_RESULT;
4594 psy_do_property(battery->pdata->wireless_charger_name, get,
4595 POWER_SUPPLY_PROP_MANUFACTURER, value);
4596 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4597 break;
4598 case WC_IC_GRADE:
4599 value.intval = SEC_WIRELESS_IC_GRADE;
4600 psy_do_property(battery->pdata->wireless_charger_name, get,
4601 POWER_SUPPLY_PROP_MANUFACTURER, value);
4602 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%x ", value.intval);
4603
4604 value.intval = SEC_WIRELESS_IC_REVISION;
4605 psy_do_property(battery->pdata->wireless_charger_name, get,
4606 POWER_SUPPLY_PROP_MANUFACTURER, value);
4607 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%x\n", value.intval);
4608 break;
4609 case OTP_FIRMWARE_VER_BIN:
4610 value.intval = SEC_WIRELESS_OTP_FIRM_VER_BIN;
4611 psy_do_property(battery->pdata->wireless_charger_name, get,
4612 POWER_SUPPLY_PROP_MANUFACTURER, value);
4613 i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", value.intval);
4614 break;
4615 case OTP_FIRMWARE_VER:
4616 value.intval = SEC_WIRELESS_OTP_FIRM_VER;
4617 psy_do_property(battery->pdata->wireless_charger_name, get,
4618 POWER_SUPPLY_PROP_MANUFACTURER, value);
4619
4620 i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", value.intval);
4621 break;
4622 case TX_FIRMWARE_RESULT:
4623 value.intval = SEC_WIRELESS_TX_FIRM_RESULT;
4624 psy_do_property(battery->pdata->wireless_charger_name, get,
4625 POWER_SUPPLY_PROP_MANUFACTURER, value);
4626 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4627 break;
4628 case TX_FIRMWARE_VER:
4629 value.intval = SEC_WIRELESS_TX_FIRM_VER;
4630 psy_do_property(battery->pdata->wireless_charger_name, get,
4631 POWER_SUPPLY_PROP_MANUFACTURER, value);
4632
4633 i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", value.intval);
4634 break;
4635 case BATT_TX_STATUS:
4636 value.intval = SEC_TX_FIRMWARE;
4637 psy_do_property(battery->pdata->wireless_charger_name, get,
4638 POWER_SUPPLY_PROP_MANUFACTURER, value);
4639
4640 i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", value.intval);
4641 break;
4642 #endif
4643 case WC_VOUT:
4644 psy_do_property(battery->pdata->wireless_charger_name, get,
4645 POWER_SUPPLY_PROP_ENERGY_NOW, value);
4646 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4647 break;
4648 case WC_VRECT:
4649 psy_do_property(battery->pdata->wireless_charger_name, get,
4650 POWER_SUPPLY_PROP_ENERGY_AVG, value);
4651 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4652 break;
4653 case BATT_HV_WIRELESS_STATUS:
4654 psy_do_property(battery->pdata->wireless_charger_name, get,
4655 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
4656 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4657 break;
4658 case BATT_HV_WIRELESS_PAD_CTRL:
4659 break;
4660 case WC_OP_FREQ:
4661 psy_do_property(battery->pdata->wireless_charger_name, get,
4662 POWER_SUPPLY_EXT_PROP_WIRELESS_OP_FREQ, value);
4663 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n", value.intval);
4664 break;
4665 case WC_CMD_INFO:
4666 psy_do_property(battery->pdata->wireless_charger_name, get,
4667 POWER_SUPPLY_EXT_PROP_WIRELESS_TX_CMD, value);
4668 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%02x ",
4669 value.intval);
4670
4671 psy_do_property(battery->pdata->wireless_charger_name, get,
4672 POWER_SUPPLY_EXT_PROP_WIRELESS_TX_VAL, value);
4673 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%02x ",
4674 value.intval);
4675 break;
4676 case BATT_TUNE_FLOAT_VOLTAGE:
4677 ret = battery->pdata->chg_float_voltage;
4678 pr_info("%s float voltage = %d mA",__func__, ret);
4679 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4680 ret);
4681 break;
4682 case BATT_TUNE_INPUT_CHARGE_CURRENT:
4683 ret = battery->pdata->charging_current[i].input_current_limit;
4684 pr_info("%s input charge current = %d mA",__func__, ret);
4685 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4686 ret);
4687 break;
4688 case BATT_TUNE_FAST_CHARGE_CURRENT:
4689 ret = battery->pdata->charging_current[i].fast_charging_current;
4690 pr_info("%s fast charge current = %d mA",__func__, ret);
4691 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4692 ret);
4693 break;
4694 case BATT_TUNE_UI_TERM_CURRENT_1ST:
4695 ret = battery->pdata->full_check_current_1st;
4696 pr_info("%s ui term current = %d mA",__func__, ret);
4697 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4698 ret);
4699 break;
4700 case BATT_TUNE_UI_TERM_CURRENT_2ND:
4701 ret = battery->pdata->full_check_current_2nd;
4702 pr_info("%s ui term current = %d mA",__func__, ret);
4703 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4704 ret);
4705 break;
4706 case BATT_TUNE_TEMP_HIGH_NORMAL:
4707 ret = battery->pdata->temp_high_threshold_normal;
4708 pr_info("%s temp high normal block = %d ",__func__, ret);
4709 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4710 ret);
4711 break;
4712 case BATT_TUNE_TEMP_HIGH_REC_NORMAL:
4713 ret = battery->pdata->temp_high_recovery_normal;
4714 pr_info("%s temp high normal recover = %d ",__func__, ret);
4715 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4716 ret);
4717 break;
4718 case BATT_TUNE_TEMP_LOW_NORMAL:
4719 ret = battery->pdata->temp_low_threshold_normal;
4720 pr_info("%s temp low normal block = %d ",__func__, ret);
4721 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4722 ret);
4723 break;
4724 case BATT_TUNE_TEMP_LOW_REC_NORMAL:
4725 ret = battery->pdata->temp_low_recovery_normal;
4726 pr_info("%s temp low normal recover = %d ",__func__, ret);
4727 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4728 ret);
4729 break;
4730 case BATT_TUNE_CHG_TEMP_HIGH:
4731 ret = battery->pdata->chg_high_temp;
4732 pr_info("%s chg_high_temp = %d ",__func__, ret);
4733 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4734 ret);
4735 break;
4736 case BATT_TUNE_CHG_TEMP_REC:
4737 ret = battery->pdata->chg_high_temp_recovery;
4738 pr_info("%s chg_high_temp_recovery = %d ",__func__, ret);
4739 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4740 ret);
4741 break;
4742 case BATT_TUNE_CHG_LIMMIT_CUR:
4743 ret = battery->pdata->chg_charging_limit_current;
4744 pr_info("%s chg_charging_limit_current = %d ",__func__, ret);
4745 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4746 ret);
4747 break;
4748 case BATT_TUNE_COIL_TEMP_HIGH:
4749 break;
4750 case BATT_TUNE_COIL_TEMP_REC:
4751 break;
4752 case BATT_TUNE_COIL_LIMMIT_CUR:
4753 break;
4754 #if defined(CONFIG_UPDATE_BATTERY_DATA)
4755 case BATT_UPDATE_DATA:
4756 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n",
4757 battery->data_path ? "OK" : "NOK");
4758 break;
4759 #endif
4760 case BATT_MISC_EVENT:
4761 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4762 battery->misc_event);
4763 break;
4764 case BATT_EXT_DEV_CHG:
4765 break;
4766 case BATT_WDT_CONTROL:
4767 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4768 battery->wdt_kick_disable);
4769 break;
4770 case MODE:
4771 value.strval = NULL;
4772 psy_do_property(battery->pdata->charger_name, get,
4773 POWER_SUPPLY_EXT_PROP_MULTI_CHARGER_MODE, value);
4774 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n",
4775 (value.strval) ? value.strval : "master");
4776 break;
4777 case CHECK_PS_READY:
4778 #if defined(CONFIG_CCIC_NOTIFIER)
4779 value.intval = battery->pdic_ps_rdy;
4780 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4781 value.intval);
4782 pr_info("%s : CHECK_PS_READY=%d\n",__func__,value.intval);
4783 #endif
4784 break;
4785 case BATT_CHIP_ID:
4786 psy_do_property(battery->pdata->charger_name, get,
4787 POWER_SUPPLY_EXT_PROP_CHIP_ID, value);
4788 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4789 value.intval);
4790 break;
4791 case CISD_FULLCAPREP_MAX:
4792 {
4793 union power_supply_propval fullcaprep_val;
4794
4795 fullcaprep_val.intval = SEC_BATTERY_CAPACITY_FULL;
4796 psy_do_property(battery->pdata->fuelgauge_name, get,
4797 POWER_SUPPLY_PROP_ENERGY_NOW, fullcaprep_val);
4798
4799 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4800 fullcaprep_val.intval);
4801 }
4802 break;
4803 #if defined(CONFIG_BATTERY_CISD)
4804 case CISD_DATA:
4805 {
4806 struct cisd *pcisd = &battery->cisd;
4807 char temp_buf[1024] = {0,};
4808 int j = 0;
4809
4810 sprintf(temp_buf+strlen(temp_buf), "%d", pcisd->data[CISD_DATA_RESET_ALG]);
4811 for (j = CISD_DATA_RESET_ALG + 1; j < CISD_DATA_MAX_PER_DAY; j++)
4812 sprintf(temp_buf+strlen(temp_buf), " %d", pcisd->data[j]);
4813 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", temp_buf);
4814 }
4815 break;
4816 case CISD_DATA_JSON:
4817 {
4818 struct cisd *pcisd = &battery->cisd;
4819 char temp_buf[1920] = {0,};
4820 int j = 0;
4821
4822 sprintf(temp_buf+strlen(temp_buf), "\"%s\":\"%d\"",
4823 cisd_data_str[CISD_DATA_RESET_ALG], pcisd->data[CISD_DATA_RESET_ALG]);
4824 for (j = CISD_DATA_RESET_ALG + 1; j < CISD_DATA_MAX; j++)
4825 sprintf(temp_buf+strlen(temp_buf), ",\"%s\":\"%d\"", cisd_data_str[j], pcisd->data[j]);
4826 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", temp_buf);
4827 }
4828 break;
4829 case CISD_DATA_D_JSON:
4830 {
4831 struct cisd *pcisd = &battery->cisd;
4832 char temp_buf[1920] = {0,};
4833 int j = 0;
4834
4835 sprintf(temp_buf+strlen(temp_buf), "\"%s\":\"%d\"",
4836 cisd_data_str_d[CISD_DATA_FULL_COUNT_PER_DAY-CISD_DATA_MAX],
4837 pcisd->data[CISD_DATA_FULL_COUNT_PER_DAY]);
4838 for (j = CISD_DATA_FULL_COUNT_PER_DAY + 1; j < CISD_DATA_MAX_PER_DAY; j++)
4839 sprintf(temp_buf+strlen(temp_buf), ",\"%s\":\"%d\"",
4840 cisd_data_str_d[j-CISD_DATA_MAX], pcisd->data[j]);
4841
4842 /* Clear Daily Data */
4843 for (j = CISD_DATA_FULL_COUNT_PER_DAY; j < CISD_DATA_MAX_PER_DAY; j++)
4844 pcisd->data[j] = 0;
4845
4846 pcisd->data[CISD_DATA_FULL_COUNT_PER_DAY] = 1;
4847 pcisd->data[CISD_DATA_BATT_TEMP_MAX_PER_DAY] = -300;
4848 pcisd->data[CISD_DATA_CHG_TEMP_MAX_PER_DAY] = -300;
4849 pcisd->data[CISD_DATA_WPC_TEMP_MAX_PER_DAY] = -300;
4850 pcisd->data[CISD_DATA_USB_TEMP_MAX_PER_DAY] = -300;
4851 pcisd->data[CISD_DATA_BATT_TEMP_MIN_PER_DAY] = 1000;
4852 pcisd->data[CISD_DATA_CHG_TEMP_MIN_PER_DAY] = 1000;
4853 pcisd->data[CISD_DATA_WPC_TEMP_MIN_PER_DAY] = 1000;
4854 pcisd->data[CISD_DATA_USB_TEMP_MIN_PER_DAY] = 1000;
4855
4856 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MAX_PER_DAY] = -300;
4857 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MAX_PER_DAY] = -300;
4858 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MAX_PER_DAY] = -300;
4859 pcisd->data[CISD_DATA_CHG_USB_TEMP_MAX_PER_DAY] = -300;
4860 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MIN_PER_DAY] = 1000;
4861 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MIN_PER_DAY] = 1000;
4862 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MIN_PER_DAY] = 1000;
4863 pcisd->data[CISD_DATA_CHG_USB_TEMP_MIN_PER_DAY] = 1000;
4864
4865 pcisd->data[CISD_DATA_CAP_MIN_PER_DAY] = 0xFFFF;
4866 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", temp_buf);
4867 }
4868 break;
4869 case CISD_WIRE_COUNT:
4870 {
4871 struct cisd *pcisd = &battery->cisd;
4872 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4873 pcisd->data[CISD_DATA_WIRE_COUNT]);
4874 }
4875 break;
4876 case CISD_WC_DATA:
4877 {
4878 struct cisd *pcisd = &battery->cisd;
4879 struct pad_data *pad_data = pcisd->pad_array;
4880 char temp_buf[1024] = {0,};
4881 int j = 0;
4882
4883 sprintf(temp_buf+strlen(temp_buf), "%d %d",
4884 PAD_INDEX_VALUE, pcisd->pad_count);
4885 while ((pad_data != NULL) && ((pad_data = pad_data->next) != NULL) &&
4886 (pad_data->id < MAX_PAD_ID) && (j++ < pcisd->pad_count))
4887 sprintf(temp_buf+strlen(temp_buf), " 0x%02x:%d", pad_data->id, pad_data->count);
4888 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", temp_buf);
4889 }
4890 break;
4891 case CISD_WC_DATA_JSON:
4892 {
4893 struct cisd *pcisd = &battery->cisd;
4894 struct pad_data *pad_data = pcisd->pad_array;
4895 char temp_buf[1024] = {0,};
4896 int j = 0;
4897
4898 sprintf(temp_buf+strlen(temp_buf), "\"%s\":\"%d\"",
4899 PAD_INDEX_STRING, PAD_INDEX_VALUE);
4900 while ((pad_data != NULL) && ((pad_data = pad_data->next) != NULL) &&
4901 (pad_data->id < MAX_PAD_ID) && (j++ < pcisd->pad_count))
4902 sprintf(temp_buf+strlen(temp_buf), ",\"%s%02x\":\"%d\"",
4903 PAD_JSON_STRING, pad_data->id, pad_data->count);
4904 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", temp_buf);
4905 }
4906 break;
4907 case PREV_BATTERY_DATA:
4908 {
4909 if (battery->enable_update_data)
4910 i += scnprintf(buf + i, PAGE_SIZE - i, "%d, %d, %d, %d\n",
4911 battery->voltage_now, battery->temperature,
4912 battery->is_jig_on, !battery->charging_block);
4913 }
4914 break;
4915 case PREV_BATTERY_INFO:
4916 {
4917 i += scnprintf(buf + i, PAGE_SIZE - i, "%d,%d,%d,%d\n",
4918 battery->prev_volt, battery->prev_temp,
4919 battery->prev_jig_on, battery->prev_chg_on);
4920 pr_info("%s: Read Prev Battery Info : %d, %d, %d, %d\n", __func__,
4921 battery->prev_volt, battery->prev_temp,
4922 battery->prev_jig_on, battery->prev_chg_on);
4923 }
4924 break;
4925 #endif
4926 #if defined(CONFIG_BATTERY_SBM_DATA)
4927 case SBM_DATA:
4928 if (battery->sbm_data) {
4929 sec_bat_get_sbm_data_string(&value);
4930 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", value.strval);
4931 battery->sbm_data = false;
4932 } else {
4933 i = -EINVAL;
4934 }
4935 break;
4936 #endif
4937 case SAFETY_TIMER_SET:
4938 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4939 battery->safety_timer_set);
4940 break;
4941 case BATT_SWELLING_CONTROL:
4942 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4943 battery->skip_swelling);
4944 break;
4945 case SAFETY_TIMER_INFO:
4946 i += scnprintf(buf + i, PAGE_SIZE - i, "%ld\n",
4947 battery->cal_safety_time);
4948 break;
4949 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
4950 case BATT_TEMP_TEST:
4951 i += scnprintf(buf + i, PAGE_SIZE - i, "%d %d %d %d\n",
4952 battery->temperature_test_battery,
4953 battery->temperature_test_usb,
4954 battery->temperature_test_wpc,
4955 battery->temperature_test_chg);
4956 break;
4957 #endif
4958 case BATT_CURRENT_EVENT:
4959 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4960 battery->current_event);
4961 break;
4962 case CC_INFO:
4963 {
4964 union power_supply_propval cc_val;
4965
4966 cc_val.intval = SEC_BATTERY_CAPACITY_QH;
4967 psy_do_property(battery->pdata->fuelgauge_name, get,
4968 POWER_SUPPLY_PROP_ENERGY_NOW, cc_val);
4969
4970 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
4971 cc_val.intval);
4972 }
4973 break;
4974 case EXT_EVENT:
4975 break;
4976 default:
4977 i = -EINVAL;
4978 break;
4979 }
4980
4981 return i;
4982 }
4983
4984 void update_external_temp_table(struct sec_battery_info *battery, int temp[])
4985 {
4986 battery->pdata->temp_high_threshold_normal = temp[0];
4987 battery->pdata->temp_high_recovery_normal = temp[1];
4988 battery->pdata->temp_low_threshold_normal = temp[2];
4989 battery->pdata->temp_low_recovery_normal = temp[3];
4990 battery->pdata->temp_high_threshold_lpm = temp[4];
4991 battery->pdata->temp_high_recovery_lpm = temp[5];
4992 battery->pdata->temp_low_threshold_lpm = temp[6];
4993 battery->pdata->temp_low_recovery_lpm = temp[7];
4994
4995 }
4996
4997 ssize_t sec_bat_store_attrs(
4998 struct device *dev,
4999 struct device_attribute *attr,
5000 const char *buf, size_t count)
5001 {
5002 struct power_supply *psy = dev_get_drvdata(dev);
5003 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
5004 const ptrdiff_t offset = attr - sec_battery_attrs;
5005 int ret = -EINVAL;
5006 int x = 0;
5007 int t[12];
5008 int i = 0;
5009 union power_supply_propval value = {0, };
5010
5011 switch (offset) {
5012 case BATT_RESET_SOC:
5013 /* Do NOT reset fuel gauge in charging mode */
5014 if ((battery->cable_type == SEC_BATTERY_CABLE_NONE) ||
5015 battery->is_jig_on) {
5016 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_BATT_RESET_SOC, 0);
5017
5018 value.intval =
5019 SEC_FUELGAUGE_CAPACITY_TYPE_RESET;
5020 psy_do_property(battery->pdata->fuelgauge_name, set,
5021 POWER_SUPPLY_PROP_CAPACITY, value);
5022 dev_info(battery->dev,"do reset SOC\n");
5023 /* update battery info */
5024 sec_bat_get_battery_info(battery);
5025 }
5026 ret = count;
5027 break;
5028 case BATT_READ_RAW_SOC:
5029 break;
5030 case BATT_READ_ADJ_SOC:
5031 break;
5032 case BATT_TYPE:
5033 strncpy(battery->batt_type, buf, sizeof(battery->batt_type) - 1);
5034 battery->batt_type[sizeof(battery->batt_type)-1] = '\0';
5035 ret = count;
5036 break;
5037 case BATT_VFOCV:
5038 break;
5039 case BATT_VOL_ADC:
5040 break;
5041 case BATT_VOL_ADC_CAL:
5042 break;
5043 case BATT_VOL_AVER:
5044 break;
5045 case BATT_VOL_ADC_AVER:
5046 break;
5047 case BATT_CURRENT_UA_NOW:
5048 break;
5049 case BATT_CURRENT_UA_AVG:
5050 break;
5051 case BATT_FILTER_CFG:
5052 if (sscanf(buf, "%10d\n", &x) == 1) {
5053 value.intval = x;
5054 psy_do_property(battery->pdata->fuelgauge_name, set,
5055 POWER_SUPPLY_PROP_FILTER_CFG, value);
5056 ret = count;
5057 }
5058 break;
5059 case BATT_TEMP:
5060 #if defined(CONFIG_ENG_BATTERY_CONCEPT) || defined(CONFIG_SEC_FACTORY)
5061 if (sscanf(buf, "%10d\n", &x) == 1) {
5062 dev_info(battery->dev,
5063 "%s: cooldown mode %s \n", __func__, (x ? "enable" : "disable"));
5064 if (x == 0)
5065 battery->cooldown_mode = false;
5066 else
5067 battery->cooldown_mode = true;
5068 ret = count;
5069 }
5070 #endif
5071 break;
5072 case BATT_TEMP_ADC:
5073 break;
5074 case BATT_TEMP_AVER:
5075 break;
5076 case BATT_TEMP_ADC_AVER:
5077 break;
5078 case USB_TEMP:
5079 break;
5080 case USB_TEMP_ADC:
5081 break;
5082 case CHG_TEMP:
5083 break;
5084 case CHG_TEMP_ADC:
5085 break;
5086 case SLAVE_CHG_TEMP:
5087 break;
5088 case SLAVE_CHG_TEMP_ADC:
5089 break;
5090 case BATT_VF_ADC:
5091 break;
5092 case BATT_SLATE_MODE:
5093 if (sscanf(buf, "%10d\n", &x) == 1) {
5094 if (x == battery->slate_mode) {
5095 dev_info(battery->dev,
5096 "%s : skip same slate mode : %d\n", __func__, x);
5097 return count;
5098 } else if (x == 1) {
5099 battery->slate_mode = true;
5100 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_SLATE, SEC_BAT_CURRENT_EVENT_SLATE);
5101 dev_info(battery->dev,
5102 "%s: enable slate mode : %d\n", __func__, x);
5103 } else if (x == 0) {
5104 battery->slate_mode = false;
5105 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_SLATE);
5106 dev_info(battery->dev,
5107 "%s: disable slate mode : %d\n", __func__, x);
5108 } else {
5109 dev_info(battery->dev,
5110 "%s: SLATE MODE unknown command\n", __func__);
5111 return -EINVAL;
5112 }
5113 wake_lock(&battery->cable_wake_lock);
5114 queue_delayed_work(battery->monitor_wqueue,
5115 &battery->cable_work, 0);
5116 ret = count;
5117 }
5118 break;
5119 case BATT_LP_CHARGING:
5120 break;
5121 case SIOP_ACTIVATED:
5122 break;
5123 case SIOP_LEVEL:
5124 if (sscanf(buf, "%10d\n", &x) == 1) {
5125 dev_info(battery->dev,
5126 "%s: siop level: %d\n", __func__, x);
5127
5128 battery->wc_heating_start_time = 0;
5129 if (x == battery->siop_level) {
5130 dev_info(battery->dev,
5131 "%s: skip same siop level: %d\n", __func__, x);
5132 return count;
5133 } else if (x >= 0 && x <= 100) {
5134 battery->siop_level = x;
5135 } else {
5136 battery->siop_level = 100;
5137 }
5138
5139 wake_lock(&battery->siop_level_wake_lock);
5140 queue_delayed_work(battery->monitor_wqueue, &battery->siop_level_work, 0);
5141
5142 ret = count;
5143 }
5144 break;
5145 case SIOP_EVENT:
5146 if (sscanf(buf, "%10d\n", &x) == 1) {
5147 ret = count;
5148 }
5149 break;
5150 case BATT_CHARGING_SOURCE:
5151 break;
5152 case FG_REG_DUMP:
5153 break;
5154 case FG_RESET_CAP:
5155 break;
5156 case FG_CAPACITY:
5157 break;
5158 case FG_ASOC:
5159 break;
5160 case AUTH:
5161 break;
5162 case CHG_CURRENT_ADC:
5163 break;
5164 case WC_ADC:
5165 break;
5166 case WC_STATUS:
5167 break;
5168 case WC_ENABLE:
5169 if (sscanf(buf, "%10d\n", &x) == 1) {
5170 if (x == 0) {
5171 mutex_lock(&battery->wclock);
5172 battery->wc_enable = false;
5173 battery->wc_enable_cnt = 0;
5174 mutex_unlock(&battery->wclock);
5175 } else if (x == 1) {
5176 mutex_lock(&battery->wclock);
5177 battery->wc_enable = true;
5178 battery->wc_enable_cnt = 0;
5179 mutex_unlock(&battery->wclock);
5180 } else {
5181 dev_info(battery->dev,
5182 "%s: WPC ENABLE unknown command\n",
5183 __func__);
5184 return -EINVAL;
5185 }
5186 wake_lock(&battery->cable_wake_lock);
5187 queue_delayed_work(battery->monitor_wqueue,
5188 &battery->cable_work, 0);
5189 ret = count;
5190 }
5191 break;
5192 case WC_CONTROL:
5193 if (sscanf(buf, "%10d\n", &x) == 1) {
5194 if (battery->pdata->wpc_en) {
5195 if (x == 0) {
5196 mutex_lock(&battery->wclock);
5197 battery->wc_enable = false;
5198 battery->wc_enable_cnt = 0;
5199 value.intval = 0;
5200 psy_do_property(battery->pdata->wireless_charger_name, set,
5201 POWER_SUPPLY_EXT_PROP_WC_CONTROL, value);
5202 gpio_direction_output(battery->pdata->wpc_en, 1);
5203 pr_info("%s: WC CONTROL: Disable", __func__);
5204 mutex_unlock(&battery->wclock);
5205 } else if (x == 1) {
5206 mutex_lock(&battery->wclock);
5207 battery->wc_enable = true;
5208 battery->wc_enable_cnt = 0;
5209 value.intval = 1;
5210 psy_do_property(battery->pdata->wireless_charger_name, set,
5211 POWER_SUPPLY_EXT_PROP_WC_CONTROL, value);
5212 gpio_direction_output(battery->pdata->wpc_en, 0);
5213 pr_info("%s: WC CONTROL: Enable", __func__);
5214 mutex_unlock(&battery->wclock);
5215 } else {
5216 dev_info(battery->dev,
5217 "%s: WC CONTROL unknown command\n",
5218 __func__);
5219 return -EINVAL;
5220 }
5221 }
5222 ret = count;
5223 }
5224 break;
5225 case WC_CONTROL_CNT:
5226 if (sscanf(buf, "%10d\n", &x) == 1) {
5227 battery->wc_enable_cnt_value = x;
5228 ret = count;
5229 }
5230 break;
5231 case LED_COVER:
5232 if (sscanf(buf, "%10d\n", &x) == 1) {
5233 pr_info("%s: MFC, LED_COVER(%d)\n", __func__, x);
5234 battery->led_cover = x;
5235 value.intval = battery->led_cover;
5236 psy_do_property(battery->pdata->wireless_charger_name, set,
5237 POWER_SUPPLY_PROP_FILTER_CFG, value);
5238 ret = count;
5239 }
5240 break;
5241 case HV_CHARGER_STATUS:
5242 break;
5243 case HV_WC_CHARGER_STATUS:
5244 break;
5245 case HV_CHARGER_SET:
5246 if (sscanf(buf, "%10d\n", &x) == 1) {
5247 dev_info(battery->dev,
5248 "%s: HV_CHARGER_SET(%d)\n", __func__, x);
5249 if (x == 1) {
5250 battery->wire_status = SEC_BATTERY_CABLE_9V_TA;
5251 wake_lock(&battery->cable_wake_lock);
5252 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
5253 } else {
5254 battery->wire_status = SEC_BATTERY_CABLE_NONE;
5255 wake_lock(&battery->cable_wake_lock);
5256 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
5257 }
5258 ret = count;
5259 }
5260 break;
5261 case FACTORY_MODE:
5262 if (sscanf(buf, "%10d\n", &x) == 1) {
5263 battery->factory_mode = x ? true : false;
5264 ret = count;
5265 }
5266 break;
5267 case STORE_MODE:
5268 if (sscanf(buf, "%10d\n", &x) == 1) {
5269 #if !defined(CONFIG_SEC_FACTORY)
5270 if (x) {
5271 battery->store_mode = true;
5272 wake_lock(&battery->parse_mode_dt_wake_lock);
5273 queue_delayed_work(battery->monitor_wqueue,
5274 &battery->parse_mode_dt_work, 0);
5275 }
5276 #endif
5277 ret = count;
5278 }
5279 break;
5280 case UPDATE:
5281 if (sscanf(buf, "%10d\n", &x) == 1) {
5282 /* update battery info */
5283 sec_bat_get_battery_info(battery);
5284 ret = count;
5285 }
5286 break;
5287 case TEST_MODE:
5288 if (sscanf(buf, "%10d\n", &x) == 1) {
5289 battery->test_mode = x;
5290 wake_lock(&battery->monitor_wake_lock);
5291 queue_delayed_work(battery->monitor_wqueue,
5292 &battery->monitor_work, 0);
5293 ret = count;
5294 }
5295 break;
5296
5297 case BATT_EVENT_CALL:
5298 case BATT_EVENT_2G_CALL:
5299 case BATT_EVENT_TALK_GSM:
5300 if (sscanf(buf, "%10d\n", &x) == 1) {
5301 ret = count;
5302 }
5303 break;
5304 case BATT_EVENT_3G_CALL:
5305 case BATT_EVENT_TALK_WCDMA:
5306 if (sscanf(buf, "%10d\n", &x) == 1) {
5307 ret = count;
5308 }
5309 break;
5310 case BATT_EVENT_MUSIC:
5311 if (sscanf(buf, "%10d\n", &x) == 1) {
5312 ret = count;
5313 }
5314 break;
5315 case BATT_EVENT_VIDEO:
5316 if (sscanf(buf, "%10d\n", &x) == 1) {
5317 ret = count;
5318 }
5319 break;
5320 case BATT_EVENT_BROWSER:
5321 if (sscanf(buf, "%10d\n", &x) == 1) {
5322 ret = count;
5323 }
5324 break;
5325 case BATT_EVENT_HOTSPOT:
5326 if (sscanf(buf, "%10d\n", &x) == 1) {
5327 ret = count;
5328 }
5329 break;
5330 case BATT_EVENT_CAMERA:
5331 if (sscanf(buf, "%10d\n", &x) == 1) {
5332 ret = count;
5333 }
5334 break;
5335 case BATT_EVENT_CAMCORDER:
5336 if (sscanf(buf, "%10d\n", &x) == 1) {
5337 ret = count;
5338 }
5339 break;
5340 case BATT_EVENT_DATA_CALL:
5341 if (sscanf(buf, "%10d\n", &x) == 1) {
5342 ret = count;
5343 }
5344 break;
5345 case BATT_EVENT_WIFI:
5346 if (sscanf(buf, "%10d\n", &x) == 1) {
5347 ret = count;
5348 }
5349 break;
5350 case BATT_EVENT_WIBRO:
5351 if (sscanf(buf, "%10d\n", &x) == 1) {
5352 ret = count;
5353 }
5354 break;
5355 case BATT_EVENT_LTE:
5356 if (sscanf(buf, "%10d\n", &x) == 1) {
5357 ret = count;
5358 }
5359 break;
5360 case BATT_EVENT_LCD:
5361 if (sscanf(buf, "%10d\n", &x) == 1) {
5362 struct timespec ts;
5363 get_monotonic_boottime(&ts);
5364 if (x) {
5365 battery->lcd_status = true;
5366 } else {
5367 battery->lcd_status = false;
5368 }
5369 ret = count;
5370 }
5371 break;
5372 case BATT_EVENT_GPS:
5373 if (sscanf(buf, "%10d\n", &x) == 1) {
5374 ret = count;
5375 }
5376 break;
5377 case BATT_TEMP_TABLE:
5378 if (sscanf(buf, "%10d %10d %10d %10d %10d %10d %10d %10d\n",
5379 &t[0], &t[1], &t[2], &t[3], &t[4], &t[5], &t[6], &t[7]) == 8) {
5380 pr_info("%s: (new) %d %d %d %d %d %d %d %d\n",
5381 __func__, t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7]);
5382 pr_info("%s: (default) %d %d %d %d %d %d %d %d\n",
5383 __func__,
5384 battery->pdata->temp_high_threshold_normal,
5385 battery->pdata->temp_high_recovery_normal,
5386 battery->pdata->temp_low_threshold_normal,
5387 battery->pdata->temp_low_recovery_normal,
5388 battery->pdata->temp_high_threshold_lpm,
5389 battery->pdata->temp_high_recovery_lpm,
5390 battery->pdata->temp_low_threshold_lpm,
5391 battery->pdata->temp_low_recovery_lpm);
5392 update_external_temp_table(battery, t);
5393 ret = count;
5394 }
5395 break;
5396 case BATT_HIGH_CURRENT_USB:
5397 if (sscanf(buf, "%10d\n", &x) == 1) {
5398 battery->is_hc_usb = x ? true : false;
5399 value.intval = battery->is_hc_usb;
5400
5401 psy_do_property(battery->pdata->charger_name, set,
5402 POWER_SUPPLY_PROP_USB_HC, value);
5403
5404 pr_info("%s: is_hc_usb (%d)\n", __func__, battery->is_hc_usb);
5405 ret = count;
5406 }
5407 break;
5408 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
5409 case TEST_CHARGE_CURRENT:
5410 if (sscanf(buf, "%10d\n", &x) == 1) {
5411 if (x >= 0 && x <= 2000) {
5412 dev_err(battery->dev,
5413 "%s: BATT_TEST_CHARGE_CURRENT(%d)\n", __func__, x);
5414 battery->pdata->charging_current[
5415 SEC_BATTERY_CABLE_USB].input_current_limit = x;
5416 battery->pdata->charging_current[
5417 SEC_BATTERY_CABLE_USB].fast_charging_current = x;
5418 if (x > 500) {
5419 battery->eng_not_full_status = true;
5420 battery->pdata->temp_check_type =
5421 SEC_BATTERY_TEMP_CHECK_NONE;
5422 }
5423 if (battery->cable_type == SEC_BATTERY_CABLE_USB) {
5424 value.intval = x;
5425 psy_do_property(battery->pdata->charger_name, set,
5426 POWER_SUPPLY_PROP_CURRENT_NOW,
5427 value);
5428 }
5429 }
5430 ret = count;
5431 }
5432 break;
5433 #endif
5434 case SET_STABILITY_TEST:
5435 if (sscanf(buf, "%10d\n", &x) == 1) {
5436 dev_err(battery->dev,
5437 "%s: BATT_STABILITY_TEST(%d)\n", __func__, x);
5438 if (x) {
5439 battery->stability_test = true;
5440 battery->eng_not_full_status = true;
5441 }
5442 else {
5443 battery->stability_test = false;
5444 battery->eng_not_full_status = false;
5445 }
5446 ret = count;
5447 }
5448 break;
5449 case BATT_CAPACITY_MAX:
5450 if (sscanf(buf, "%10d\n", &x) == 1) {
5451 dev_err(battery->dev,
5452 "%s: BATT_CAPACITY_MAX(%d), fg_reset(%d)\n", __func__, x, fg_reset);
5453 if (!fg_reset && !battery->store_mode) {
5454 value.intval = x;
5455 psy_do_property(battery->pdata->fuelgauge_name, set,
5456 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, value);
5457
5458 /* update soc */
5459 value.intval = 0;
5460 psy_do_property(battery->pdata->fuelgauge_name, get,
5461 POWER_SUPPLY_PROP_CAPACITY, value);
5462 battery->capacity = value.intval;
5463 } else {
5464 #if !defined(CONFIG_SAMSUNG_PRODUCT_SHIP)
5465 battery->fg_reset = 1;
5466 #endif
5467 }
5468 ret = count;
5469 }
5470 break;
5471 case BATT_INBAT_VOLTAGE:
5472 break;
5473 case BATT_INBAT_VOLTAGE_OCV:
5474 break;
5475 case CHECK_SLAVE_CHG:
5476 break;
5477 case BATT_INBAT_WIRELESS_CS100:
5478 if (sscanf(buf, "%10d\n", &x) == 1) {
5479 pr_info("%s send cs100 command \n",__func__);
5480 value.intval = POWER_SUPPLY_STATUS_FULL;
5481 psy_do_property(battery->pdata->wireless_charger_name, set,
5482 POWER_SUPPLY_PROP_STATUS, value);
5483 ret = count;
5484 }
5485 break;
5486 case HMT_TA_CONNECTED:
5487 if (sscanf(buf, "%10d\n", &x) == 1) {
5488 #if !defined(CONFIG_CCIC_NOTIFIER)
5489 dev_info(battery->dev,
5490 "%s: HMT_TA_CONNECTED(%d)\n", __func__, x);
5491 if (x) {
5492 value.intval = false;
5493 psy_do_property(battery->pdata->charger_name, set,
5494 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
5495 value);
5496 dev_info(battery->dev,
5497 "%s: changed to OTG cable detached\n", __func__);
5498
5499 battery->wire_status = SEC_BATTERY_CABLE_HMT_CONNECTED;
5500 wake_lock(&battery->cable_wake_lock);
5501 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
5502 } else {
5503 value.intval = true;
5504 psy_do_property(battery->pdata->charger_name, set,
5505 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
5506 value);
5507 dev_info(battery->dev,
5508 "%s: changed to OTG cable attached\n", __func__);
5509
5510 battery->wire_status = SEC_BATTERY_CABLE_OTG;
5511 wake_lock(&battery->cable_wake_lock);
5512 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
5513 }
5514 #endif
5515 ret = count;
5516 }
5517 break;
5518 case HMT_TA_CHARGE:
5519 if (sscanf(buf, "%10d\n", &x) == 1) {
5520 #if defined(CONFIG_CCIC_NOTIFIER)
5521 dev_info(battery->dev,
5522 "%s: HMT_TA_CHARGE(%d)\n", __func__, x);
5523
5524 /* do not charge off without cable type, since wdt could be expired */
5525 if (x && (battery->cable_type != SEC_BATTERY_CABLE_NONE)
5526 && (battery->cable_type != SEC_BATTERY_CABLE_OTG)) {
5527 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_CHARGE_DISABLE);
5528 /* No charging when FULL & NONE */
5529 if (!((battery->status == POWER_SUPPLY_STATUS_FULL) &&
5530 (battery->charging_mode == SEC_BATTERY_CHARGING_NONE))) {
5531 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING);
5532 }
5533 } else if (!x) {
5534 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_CHARGE_DISABLE,
5535 SEC_BAT_CURRENT_EVENT_CHARGE_DISABLE);
5536 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
5537 } else
5538 dev_info(battery->dev, "%s: Wrong HMT control\n", __func__);
5539
5540 ret = count;
5541 #else
5542 dev_info(battery->dev,
5543 "%s: HMT_TA_CHARGE(%d)\n", __func__, x);
5544 psy_do_property(battery->pdata->charger_name, get,
5545 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
5546 if (value.intval) {
5547 dev_info(battery->dev,
5548 "%s: ignore HMT_TA_CHARGE(%d)\n", __func__, x);
5549 } else {
5550 if (x) {
5551 value.intval = false;
5552 psy_do_property(battery->pdata->charger_name, set,
5553 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
5554 value);
5555 dev_info(battery->dev,
5556 "%s: changed to OTG cable detached\n", __func__);
5557 battery->wire_status = SEC_BATTERY_CABLE_HMT_CHARGE;
5558 wake_lock(&battery->cable_wake_lock);
5559 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
5560 } else {
5561 value.intval = false;
5562 psy_do_property(battery->pdata->charger_name, set,
5563 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
5564 value);
5565 dev_info(battery->dev,
5566 "%s: changed to OTG cable detached\n", __func__);
5567 battery->wire_status = SEC_BATTERY_CABLE_HMT_CONNECTED;
5568 wake_lock(&battery->cable_wake_lock);
5569 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
5570 }
5571 }
5572 ret = count;
5573 #endif
5574 }
5575 break;
5576 #if defined(CONFIG_BATTERY_AGE_FORECAST)
5577 case FG_CYCLE:
5578 break;
5579 case FG_FULL_VOLTAGE:
5580 break;
5581 case FG_FULLCAPNOM:
5582 break;
5583 case BATTERY_CYCLE:
5584 if (sscanf(buf, "%10d\n", &x) == 1) {
5585 dev_info(battery->dev, "%s: BATTERY_CYCLE(%d)\n", __func__, x);
5586 if (x >= 0) {
5587 int prev_battery_cycle = battery->batt_cycle;
5588 battery->batt_cycle = x;
5589 #if defined(CONFIG_BATTERY_CISD)
5590 battery->cisd.data[CISD_DATA_CYCLE] = x;
5591 #endif
5592 if (prev_battery_cycle < 0) {
5593 sec_bat_aging_check(battery);
5594 }
5595 }
5596 ret = count;
5597 }
5598 break;
5599 #endif
5600 case BATT_WPC_TEMP:
5601 case BATT_WPC_TEMP_ADC:
5602 case BATT_COIL_TEMP:
5603 case BATT_COIL_TEMP_ADC:
5604 break;
5605 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
5606 case BATT_WIRELESS_FIRMWARE_UPDATE:
5607 if (sscanf(buf, "%10d\n", &x) == 1) {
5608 if (x == SEC_WIRELESS_RX_SDCARD_MODE) {
5609 pr_info("%s fw mode is SDCARD \n", __func__);
5610 sec_bat_fw_update_work(battery, SEC_WIRELESS_RX_SDCARD_MODE);
5611 } else if (x == SEC_WIRELESS_RX_BUILT_IN_MODE) {
5612 pr_info("%s fw mode is BUILD IN \n", __func__);
5613 sec_bat_fw_update_work(battery, SEC_WIRELESS_RX_BUILT_IN_MODE);
5614 } else if (x == SEC_WIRELESS_TX_ON_MODE) {
5615 pr_info("%s tx mode is on \n", __func__);
5616 sec_bat_fw_update_work(battery, SEC_WIRELESS_TX_ON_MODE);
5617 } else if (x == SEC_WIRELESS_TX_OFF_MODE) {
5618 pr_info("%s tx mode is off \n", __func__);
5619 sec_bat_fw_update_work(battery, SEC_WIRELESS_TX_OFF_MODE);
5620 } else {
5621 dev_info(battery->dev, "%s: wireless firmware unknown command\n", __func__);
5622 return -EINVAL;
5623 }
5624 ret = count;
5625 }
5626 break;
5627 case OTP_FIRMWARE_RESULT:
5628 if (sscanf(buf, "%10d\n", &x) == 1) {
5629 if (x == 2) {
5630 value.intval = x;
5631 pr_info("%s RX firmware update ready!\n", __func__);
5632 psy_do_property(battery->pdata->wireless_charger_name, set,
5633 POWER_SUPPLY_PROP_MANUFACTURER, value);
5634 } else {
5635 dev_info(battery->dev, "%s: firmware unknown command\n", __func__);
5636 return -EINVAL;
5637 }
5638 ret = count;
5639 }
5640 break;
5641 case WC_IC_GRADE:
5642 case OTP_FIRMWARE_VER_BIN:
5643 case OTP_FIRMWARE_VER:
5644 case TX_FIRMWARE_RESULT:
5645 case TX_FIRMWARE_VER:
5646 break;
5647 case BATT_TX_STATUS:
5648 if (sscanf(buf, "%10d\n", &x) == 1) {
5649 if (x == SEC_TX_OFF) {
5650 pr_info("%s TX mode is off \n", __func__);
5651 sec_bat_fw_update_work(battery, SEC_WIRELESS_TX_OFF_MODE);
5652 } else if (x == SEC_TX_STANDBY) {
5653 pr_info("%s TX mode is on \n", __func__);
5654 sec_bat_fw_update_work(battery, SEC_WIRELESS_TX_ON_MODE);
5655 } else {
5656 dev_info(battery->dev, "%s: TX firmware unknown command\n", __func__);
5657 return -EINVAL;
5658 }
5659 ret = count;
5660 }
5661 break;
5662 #endif
5663 case WC_VOUT:
5664 case WC_VRECT:
5665 break;
5666 case BATT_HV_WIRELESS_STATUS:
5667 if (sscanf(buf, "%10d\n", &x) == 1) {
5668 if (x == 1 && is_hv_wireless_type(battery->cable_type)) {
5669 wake_lock(&battery->cable_wake_lock);
5670 #ifdef CONFIG_SEC_FACTORY
5671 pr_info("%s change cable type HV WIRELESS -> WIRELESS \n", __func__);
5672 battery->wc_status = SEC_WIRELESS_PAD_WPC;
5673 battery->cable_type = SEC_BATTERY_CABLE_WIRELESS;
5674 sec_bat_set_charging_current(battery);
5675 #endif
5676 pr_info("%s HV_WIRELESS_STATUS set to 1. Vout set to 5V. \n", __func__);
5677 value.intval = WIRELESS_VOUT_5V;
5678 psy_do_property(battery->pdata->wireless_charger_name, set,
5679 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
5680 wake_unlock(&battery->cable_wake_lock);
5681 } else if (x == 3 && is_hv_wireless_type(battery->cable_type)) {
5682 pr_info("%s HV_WIRELESS_STATUS set to 3. Vout set to 10V. \n", __func__);
5683 value.intval = WIRELESS_VOUT_10V;
5684 psy_do_property(battery->pdata->wireless_charger_name, set,
5685 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
5686 } else {
5687 dev_info(battery->dev, "%s: HV_WIRELESS_STATUS unknown command\n", __func__);
5688 return -EINVAL;
5689 }
5690 ret = count;
5691 }
5692 break;
5693 case BATT_HV_WIRELESS_PAD_CTRL:
5694 if (sscanf(buf, "%10d\n", &x) == 1) {
5695
5696 pr_err("%s: x : %d\n", __func__, x);
5697
5698 if (x == 1) {
5699 ret = sec_set_param(CM_OFFSET, '1');
5700 if (ret < 0) {
5701 pr_err("%s:sec_set_param failed\n", __func__);
5702 return ret;
5703 } else {
5704 pr_info("%s: hv wirelee charging is disabled\n", __func__);
5705 sleep_mode = true;
5706 }
5707 } else if (x == 2) {
5708 ret = sec_set_param(CM_OFFSET, '0');
5709 if (ret < 0) {
5710 pr_err("%s: sec_set_param failed\n", __func__);
5711 return ret;
5712 } else {
5713 pr_info("%s: hv wireless charging is enabled\n", __func__);
5714 sleep_mode = false;
5715 }
5716 } else if (x == 3) {
5717 pr_info("%s led off \n", __func__);
5718 value.intval = WIRELESS_PAD_LED_OFF;
5719 psy_do_property(battery->pdata->wireless_charger_name, set,
5720 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
5721 } else if (x == 4) {
5722 pr_info("%s led on \n", __func__);
5723 value.intval = WIRELESS_PAD_LED_ON;
5724 psy_do_property(battery->pdata->wireless_charger_name, set,
5725 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
5726 } else {
5727 dev_info(battery->dev, "%s: BATT_HV_WIRELESS_PAD_CTRL unknown command\n", __func__);
5728 return -EINVAL;
5729 }
5730 ret = count;
5731 }
5732 break;
5733 case BATT_TUNE_FLOAT_VOLTAGE:
5734 sscanf(buf, "%10d\n", &x);
5735 pr_info("%s float voltage = %d mV",__func__, x);
5736
5737 if(x > 4000 && x <= 4400 ){
5738 value.intval = x;
5739 psy_do_property(battery->pdata->charger_name, set,
5740 POWER_SUPPLY_PROP_VOLTAGE_MAX, value);
5741 }
5742 break;
5743 case BATT_TUNE_INPUT_CHARGE_CURRENT:
5744 sscanf(buf, "%10d\n", &x);
5745 pr_info("%s input charge current = %d mA",__func__, x);
5746
5747 if(x >= 0 && x <= 4000 ){
5748 for(i=0; i < SEC_BATTERY_CABLE_MAX; i++)
5749 battery->pdata->charging_current[i].input_current_limit = x;
5750
5751 value.intval = x;
5752 psy_do_property(battery->pdata->charger_name, set,
5753 POWER_SUPPLY_PROP_CURRENT_MAX, value);
5754 }
5755 break;
5756 case BATT_TUNE_FAST_CHARGE_CURRENT:
5757 sscanf(buf, "%10d\n", &x);
5758 pr_info("%s fast charge current = %d mA",__func__, x);
5759 if(x >= 0 && x <= 4000 ){
5760 for(i=0; i < SEC_BATTERY_CABLE_MAX; i++)
5761 battery->pdata->charging_current[i].fast_charging_current = x;
5762
5763 value.intval = x;
5764 psy_do_property(battery->pdata->charger_name, set,
5765 POWER_SUPPLY_PROP_CURRENT_AVG, value);
5766 }
5767 break;
5768 case BATT_TUNE_UI_TERM_CURRENT_1ST:
5769 sscanf(buf, "%10d\n", &x);
5770 pr_info("%s ui term current = %d mA",__func__, x);
5771
5772 if(x > 0 && x < 1000 ){
5773 battery->pdata->full_check_current_1st = x;
5774 }
5775 break;
5776 case BATT_TUNE_UI_TERM_CURRENT_2ND:
5777 sscanf(buf, "%10d\n", &x);
5778 pr_info("%s ui term current = %d mA",__func__, x);
5779
5780 if(x > 0 && x < 1000 ){
5781 battery->pdata->full_check_current_2nd = x;
5782 }
5783 break;
5784 case BATT_TUNE_TEMP_HIGH_NORMAL:
5785 sscanf(buf, "%10d\n", &x);
5786 pr_info("%s temp high normal block = %d ",__func__, x);
5787 if(x < 1000 && x >= -200)
5788 battery->pdata->temp_high_threshold_normal = x;
5789 break;
5790 case BATT_TUNE_TEMP_HIGH_REC_NORMAL:
5791 sscanf(buf, "%10d\n", &x);
5792 pr_info("%s temp high normal recover = %d ",__func__, x);
5793 if(x < 1000 && x >= -200)
5794 battery->pdata->temp_high_recovery_normal = x;
5795 break;
5796 case BATT_TUNE_TEMP_LOW_NORMAL:
5797 sscanf(buf, "%10d\n", &x);
5798 pr_info("%s temp low normal block = %d ",__func__, x);
5799 if(x < 1000 && x >= -200)
5800 battery->pdata->temp_low_threshold_normal = x;
5801 break;
5802 case BATT_TUNE_TEMP_LOW_REC_NORMAL:
5803 sscanf(buf, "%10d\n", &x);
5804 pr_info("%s temp low normal recover = %d ",__func__, x);
5805 if(x < 1000 && x >= -200)
5806 battery->pdata->temp_low_recovery_normal = x;
5807 break;
5808 case BATT_TUNE_CHG_TEMP_HIGH:
5809 sscanf(buf, "%10d\n", &x);
5810 pr_info("%s chg_high_temp = %d ",__func__, x);
5811 if(x < 1000 && x >= -200)
5812 battery->pdata->chg_high_temp = x;
5813 break;
5814 case BATT_TUNE_CHG_TEMP_REC:
5815 sscanf(buf, "%10d\n", &x);
5816 pr_info("%s chg_high_temp_recovery = %d ",__func__, x);
5817 if(x < 1000 && x >= -200)
5818 battery->pdata->chg_high_temp_recovery = x;
5819 break;
5820 case BATT_TUNE_CHG_LIMMIT_CUR:
5821 sscanf(buf, "%10d\n", &x);
5822 pr_info("%s chg_charging_limit_current = %d ",__func__, x);
5823 if(x < 3000 && x > 0)
5824 {
5825 battery->pdata->chg_charging_limit_current = x;
5826 battery->pdata->charging_current[SEC_BATTERY_CABLE_9V_ERR].input_current_limit= x;
5827 battery->pdata->charging_current[SEC_BATTERY_CABLE_9V_UNKNOWN].input_current_limit= x;
5828 battery->pdata->charging_current[SEC_BATTERY_CABLE_9V_TA].input_current_limit= x;
5829 }
5830 break;
5831 case BATT_TUNE_COIL_TEMP_HIGH:
5832 break;
5833 case BATT_TUNE_COIL_TEMP_REC:
5834 break;
5835 case BATT_TUNE_COIL_LIMMIT_CUR:
5836 sscanf(buf, "%10d\n", &x);
5837 pr_info("%s wpc_charging_limit_current = %d ",__func__, x);
5838 if(x < 3000 && x > 0)
5839 {
5840 battery->pdata->charging_current[SEC_BATTERY_CABLE_9V_ERR].input_current_limit= x;
5841 battery->pdata->charging_current[SEC_BATTERY_CABLE_9V_UNKNOWN].input_current_limit= x;
5842 battery->pdata->charging_current[SEC_BATTERY_CABLE_9V_TA].input_current_limit= x;
5843 }
5844 break;
5845 #if defined(CONFIG_UPDATE_BATTERY_DATA)
5846 case BATT_UPDATE_DATA:
5847 if (!battery->data_path && (count * sizeof(char)) < 256) {
5848 battery->data_path = kzalloc((count * sizeof(char) + 1), GFP_KERNEL);
5849 if (battery->data_path) {
5850 sscanf(buf, "%s\n", battery->data_path);
5851 cancel_delayed_work(&battery->batt_data_work);
5852 wake_lock(&battery->batt_data_wake_lock);
5853 queue_delayed_work(battery->monitor_wqueue,
5854 &battery->batt_data_work, msecs_to_jiffies(100));
5855 } else {
5856 pr_info("%s: failed to alloc data_path buffer\n", __func__);
5857 }
5858 }
5859 ret = count;
5860 break;
5861 #endif
5862 case BATT_MISC_EVENT:
5863 break;
5864 case BATT_EXT_DEV_CHG:
5865 if (sscanf(buf, "%10d\n", &x) == 1) {
5866 pr_info("%s: Connect Ext Device : %d ",__func__, x);
5867
5868 switch (x) {
5869 case EXT_DEV_NONE:
5870 battery->wire_status = SEC_BATTERY_CABLE_NONE;
5871 value.intval = 0;
5872 break;
5873 case EXT_DEV_GAMEPAD_CHG:
5874 battery->wire_status = SEC_BATTERY_CABLE_TA;
5875 value.intval = 0;
5876 break;
5877 case EXT_DEV_GAMEPAD_OTG:
5878 battery->wire_status = SEC_BATTERY_CABLE_OTG;
5879 value.intval = 1;
5880 break;
5881 default:
5882 break;
5883 }
5884
5885 psy_do_property(battery->pdata->charger_name, set,
5886 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
5887 value);
5888
5889 queue_delayed_work(battery->monitor_wqueue,
5890 &battery->cable_work, 0);
5891 ret = count;
5892 }
5893 break;
5894 case BATT_WDT_CONTROL:
5895 if (sscanf(buf, "%10d\n", &x) == 1) {
5896 pr_info("%s: Charger WDT Set : %d\n", __func__, x);
5897 battery->wdt_kick_disable = x;
5898 }
5899 ret = count;
5900 break;
5901 case MODE:
5902 if (sscanf(buf, "%10d\n", &x) == 1) {
5903 value.intval = x;
5904 psy_do_property(battery->pdata->charger_name, set,
5905 POWER_SUPPLY_EXT_PROP_MULTI_CHARGER_MODE, value);
5906 ret = count;
5907 }
5908 break;
5909 case CHECK_PS_READY:
5910 case BATT_CHIP_ID:
5911 break;
5912 case CISD_FULLCAPREP_MAX:
5913 break;
5914 #if defined(CONFIG_BATTERY_CISD)
5915 case CISD_DATA:
5916 {
5917 struct cisd *pcisd = &battery->cisd;
5918 int temp_data[CISD_DATA_MAX_PER_DAY] = {0,};
5919
5920 sscanf(buf, "%10d\n", &temp_data[0]);
5921
5922 if (temp_data[CISD_DATA_RESET_ALG] > 0) {
5923 if (sscanf(buf, "%10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d, %10d\n",
5924 &temp_data[0], &temp_data[1], &temp_data[2],
5925 &temp_data[3], &temp_data[4], &temp_data[5],
5926 &temp_data[6], &temp_data[7], &temp_data[8],
5927 &temp_data[9], &temp_data[10], &temp_data[11],
5928 &temp_data[12], &temp_data[13], &temp_data[14],
5929 &temp_data[15], &temp_data[16], &temp_data[17],
5930 &temp_data[18], &temp_data[19], &temp_data[20],
5931 &temp_data[21], &temp_data[22], &temp_data[23],
5932 &temp_data[24], &temp_data[25], &temp_data[26],
5933 &temp_data[27], &temp_data[28], &temp_data[29],
5934 &temp_data[30], &temp_data[31], &temp_data[32],
5935 &temp_data[33], &temp_data[34], &temp_data[35],
5936 &temp_data[36], &temp_data[37], &temp_data[38],
5937 &temp_data[39], &temp_data[40], &temp_data[41],
5938 &temp_data[42], &temp_data[43], &temp_data[44],
5939 &temp_data[45], &temp_data[46], &temp_data[47],
5940 &temp_data[48], &temp_data[49], &temp_data[50],
5941 &temp_data[51], &temp_data[52], &temp_data[53],
5942 &temp_data[54], &temp_data[55], &temp_data[56],
5943 &temp_data[57], &temp_data[58], &temp_data[59],
5944 &temp_data[60], &temp_data[61], &temp_data[62],
5945 &temp_data[63], &temp_data[64], &temp_data[65],
5946 &temp_data[66], &temp_data[67], &temp_data[68],
5947 &temp_data[69], &temp_data[70], &temp_data[71],
5948 &temp_data[72], &temp_data[73], &temp_data[74],
5949 &temp_data[75], &temp_data[76]) <= CISD_DATA_MAX_PER_DAY) {
5950 for (i = 0; i < CISD_DATA_MAX_PER_DAY; i++)
5951 pcisd->data[i] = 0;
5952 pcisd->data[CISD_DATA_ALG_INDEX] = battery->pdata->cisd_alg_index;
5953 pcisd->data[CISD_DATA_FULL_COUNT] = temp_data[0];
5954 pcisd->data[CISD_DATA_CAP_MAX] = temp_data[1];
5955 pcisd->data[CISD_DATA_CAP_MIN] = temp_data[2];
5956 pcisd->data[CISD_DATA_VALERT_COUNT] = temp_data[16];
5957 pcisd->data[CISD_DATA_CYCLE] = temp_data[17];
5958 pcisd->data[CISD_DATA_WIRE_COUNT] = temp_data[18];
5959 pcisd->data[CISD_DATA_WIRELESS_COUNT] = temp_data[19];
5960 pcisd->data[CISD_DATA_HIGH_TEMP_SWELLING] = temp_data[20];
5961 pcisd->data[CISD_DATA_LOW_TEMP_SWELLING] = temp_data[21];
5962 pcisd->data[CISD_DATA_SWELLING_CHARGING_COUNT] = temp_data[22];
5963 pcisd->data[CISD_DATA_AICL_COUNT] = temp_data[26];
5964 pcisd->data[CISD_DATA_BATT_TEMP_MAX] = temp_data[27];
5965 pcisd->data[CISD_DATA_BATT_TEMP_MIN] = temp_data[28];
5966 pcisd->data[CISD_DATA_CHG_TEMP_MAX] = temp_data[29];
5967 pcisd->data[CISD_DATA_CHG_TEMP_MIN] = temp_data[30];
5968 pcisd->data[CISD_DATA_WPC_TEMP_MAX] = temp_data[31];
5969 pcisd->data[CISD_DATA_WPC_TEMP_MIN] = temp_data[32];
5970 pcisd->data[CISD_DATA_UNSAFETY_VOLTAGE] = temp_data[33];
5971 pcisd->data[CISD_DATA_UNSAFETY_TEMPERATURE] = temp_data[34];
5972 pcisd->data[CISD_DATA_SAFETY_TIMER] = temp_data[35];
5973 pcisd->data[CISD_DATA_VSYS_OVP] = temp_data[36];
5974 pcisd->data[CISD_DATA_VBAT_OVP] = temp_data[37];
5975 pcisd->data[CISD_DATA_AFC_FAIL] = temp_data[39];
5976 pcisd->data[CISD_DATA_WATER_DETECT] = temp_data[38];
5977 }
5978 } else {
5979 const char *p = buf;
5980
5981 pr_info("%s: %s\n", __func__, buf);
5982 for (i = CISD_DATA_RESET_ALG; i < CISD_DATA_MAX_PER_DAY; i++) {
5983 if (sscanf(p, "%10d%n", &pcisd->data[i], &x) > 0)
5984 p += (size_t)x;
5985 else {
5986 pr_info("%s: NO DATA (cisd_data)\n", __func__);
5987 temp_data[CISD_DATA_RESET_ALG] = -1;
5988 break;
5989 }
5990 }
5991
5992 pr_info("%s: %s cisd data\n", __func__,
5993 ((temp_data[CISD_DATA_RESET_ALG] < 0 || battery->fg_reset) ? "init" : "update"));
5994
5995 if (temp_data[CISD_DATA_RESET_ALG] < 0 || battery->fg_reset) {
5996 /* initialize data */
5997 for (i = CISD_DATA_RESET_ALG; i < CISD_DATA_MAX_PER_DAY; i++)
5998 pcisd->data[i] = 0;
5999
6000 battery->fg_reset = 0;
6001
6002 pcisd->data[CISD_DATA_ALG_INDEX] = battery->pdata->cisd_alg_index;
6003
6004 pcisd->data[CISD_DATA_FULL_COUNT] = 1;
6005 pcisd->data[CISD_DATA_BATT_TEMP_MAX] = -300;
6006 pcisd->data[CISD_DATA_CHG_TEMP_MAX] = -300;
6007 pcisd->data[CISD_DATA_WPC_TEMP_MAX] = -300;
6008 pcisd->data[CISD_DATA_USB_TEMP_MAX] = -300;
6009 pcisd->data[CISD_DATA_BATT_TEMP_MIN] = 1000;
6010 pcisd->data[CISD_DATA_CHG_TEMP_MIN] = 1000;
6011 pcisd->data[CISD_DATA_WPC_TEMP_MIN] = 1000;
6012 pcisd->data[CISD_DATA_USB_TEMP_MIN] = 1000;
6013 pcisd->data[CISD_DATA_CAP_MIN] = 0xFFFF;
6014
6015 pcisd->data[CISD_DATA_FULL_COUNT_PER_DAY] = 1;
6016 pcisd->data[CISD_DATA_BATT_TEMP_MAX_PER_DAY] = -300;
6017 pcisd->data[CISD_DATA_CHG_TEMP_MAX_PER_DAY] = -300;
6018 pcisd->data[CISD_DATA_WPC_TEMP_MAX_PER_DAY] = -300;
6019 pcisd->data[CISD_DATA_USB_TEMP_MAX_PER_DAY] = -300;
6020 pcisd->data[CISD_DATA_BATT_TEMP_MIN_PER_DAY] = 1000;
6021 pcisd->data[CISD_DATA_CHG_TEMP_MIN_PER_DAY] = 1000;
6022 pcisd->data[CISD_DATA_WPC_TEMP_MIN_PER_DAY] = 1000;
6023 pcisd->data[CISD_DATA_USB_TEMP_MIN_PER_DAY] = 1000;
6024
6025 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MAX] = -300;
6026 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MAX] = -300;
6027 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MAX] = -300;
6028 pcisd->data[CISD_DATA_CHG_USB_TEMP_MAX] = -300;
6029 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MIN] = 1000;
6030 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MIN] = 1000;
6031 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MIN] = 1000;
6032 pcisd->data[CISD_DATA_CHG_USB_TEMP_MIN] = 1000;
6033
6034 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MAX_PER_DAY] = -300;
6035 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MAX_PER_DAY] = -300;
6036 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MAX_PER_DAY] = -300;
6037 pcisd->data[CISD_DATA_CHG_USB_TEMP_MAX_PER_DAY] = -300;
6038 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MIN_PER_DAY] = 1000;
6039 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MIN_PER_DAY] = 1000;
6040 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MIN_PER_DAY] = 1000;
6041 pcisd->data[CISD_DATA_CHG_USB_TEMP_MIN_PER_DAY] = 1000;
6042
6043 pcisd->data[CISD_DATA_CAP_MIN_PER_DAY] = 0xFFFF;
6044
6045
6046 /* initialize pad data */
6047 init_cisd_pad_data(&battery->cisd);
6048 }
6049 }
6050 ret = count;
6051 wake_lock(&battery->monitor_wake_lock);
6052 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
6053 }
6054 break;
6055 case CISD_DATA_JSON:
6056 {
6057 char tc;
6058 struct cisd *pcisd = &battery->cisd;
6059
6060 if (sscanf(buf, "%1c\n", &tc) == 1) {
6061 if (tc == 'c') {
6062 for (i = 0; i < CISD_DATA_MAX; i++)
6063 pcisd->data[i] = 0;
6064
6065 pcisd->data[CISD_DATA_FULL_COUNT] = 1;
6066 pcisd->data[CISD_DATA_BATT_TEMP_MAX] = -300;
6067 pcisd->data[CISD_DATA_CHG_TEMP_MAX] = -300;
6068 pcisd->data[CISD_DATA_WPC_TEMP_MAX] = -300;
6069 pcisd->data[CISD_DATA_USB_TEMP_MAX] = -300;
6070 pcisd->data[CISD_DATA_BATT_TEMP_MIN] = 1000;
6071 pcisd->data[CISD_DATA_CHG_TEMP_MIN] = 1000;
6072 pcisd->data[CISD_DATA_WPC_TEMP_MIN] = 1000;
6073 pcisd->data[CISD_DATA_USB_TEMP_MIN] = 1000;
6074 pcisd->data[CISD_DATA_CAP_MIN] = 0xFFFF;
6075
6076 pcisd->data[CISD_DATA_FULL_COUNT_PER_DAY] = 1;
6077 pcisd->data[CISD_DATA_BATT_TEMP_MAX_PER_DAY] = -300;
6078 pcisd->data[CISD_DATA_CHG_TEMP_MAX_PER_DAY] = -300;
6079 pcisd->data[CISD_DATA_WPC_TEMP_MAX_PER_DAY] = -300;
6080 pcisd->data[CISD_DATA_USB_TEMP_MAX_PER_DAY] = -300;
6081 pcisd->data[CISD_DATA_BATT_TEMP_MIN_PER_DAY] = 1000;
6082 pcisd->data[CISD_DATA_CHG_TEMP_MIN_PER_DAY] = 1000;
6083 pcisd->data[CISD_DATA_WPC_TEMP_MIN_PER_DAY] = 1000;
6084 pcisd->data[CISD_DATA_USB_TEMP_MIN_PER_DAY] = 1000;
6085
6086 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MAX] = -300;
6087 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MAX] = -300;
6088 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MAX] = -300;
6089 pcisd->data[CISD_DATA_CHG_USB_TEMP_MAX] = -300;
6090 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MIN] = 1000;
6091 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MIN] = 1000;
6092 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MIN] = 1000;
6093 pcisd->data[CISD_DATA_CHG_USB_TEMP_MIN] = 1000;
6094
6095 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MAX_PER_DAY] = -300;
6096 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MAX_PER_DAY] = -300;
6097 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MAX_PER_DAY] = -300;
6098 pcisd->data[CISD_DATA_CHG_USB_TEMP_MAX_PER_DAY] = -300;
6099 pcisd->data[CISD_DATA_CHG_BATT_TEMP_MIN_PER_DAY] = 1000;
6100 pcisd->data[CISD_DATA_CHG_CHG_TEMP_MIN_PER_DAY] = 1000;
6101 pcisd->data[CISD_DATA_CHG_WPC_TEMP_MIN_PER_DAY] = 1000;
6102 pcisd->data[CISD_DATA_CHG_USB_TEMP_MIN_PER_DAY] = 1000;
6103
6104 pcisd->data[CISD_DATA_CAP_MIN_PER_DAY] = 0xFFFF;
6105
6106 }
6107 }
6108 ret = count;
6109 }
6110 break;
6111 case CISD_DATA_D_JSON:
6112 break;
6113 case CISD_WIRE_COUNT:
6114 if (sscanf(buf, "%10d\n", &x) == 1) {
6115 struct cisd *pcisd = &battery->cisd;
6116 pr_info("%s: Wire Count : %d\n", __func__, x);
6117 pcisd->data[CISD_DATA_WIRE_COUNT] = x;
6118 pcisd->data[CISD_DATA_WIRE_COUNT_PER_DAY]++;
6119 }
6120 ret = count;
6121 break;
6122 case CISD_WC_DATA:
6123 set_cisd_pad_data(battery, buf);
6124 ret = count;
6125 break;
6126 case CISD_WC_DATA_JSON:
6127 break;
6128 case PREV_BATTERY_DATA:
6129 if (sscanf(buf, "%10d, %10d, %10d, %10d\n",
6130 &battery->prev_volt, &battery->prev_temp,
6131 &battery->prev_jig_on, &battery->prev_chg_on) >= 4) {
6132 pr_info("%s: prev voltage : %d, prev_temp : %d, prev_jig_on : %d, prev_chg_on : %d\n",
6133 __func__, battery->prev_volt, battery->prev_temp,
6134 battery->prev_jig_on, battery->prev_chg_on);
6135
6136 if (battery->prev_volt >= 3700 && battery->prev_temp >= 150 &&
6137 !battery->prev_jig_on && battery->fg_reset)
6138 pr_info("%s: Battery have been Removed\n", __func__);
6139
6140 ret = count;
6141 }
6142 battery->enable_update_data = 1;
6143 break;
6144 case PREV_BATTERY_INFO:
6145 break;
6146 #endif
6147 #if defined(CONFIG_BATTERY_SBM_DATA)
6148 case SBM_DATA:
6149 break;
6150 #endif
6151 case SAFETY_TIMER_SET:
6152 if (sscanf(buf, "%10d\n", &x) == 1) {
6153 if (x) {
6154 battery->safety_timer_set = true;
6155 } else {
6156 battery->safety_timer_set = false;
6157 }
6158 ret = count;
6159 }
6160 break;
6161 case BATT_SWELLING_CONTROL:
6162 if (sscanf(buf, "%10d\n", &x) == 1) {
6163 if (x) {
6164 pr_info("%s : 15TEST START!! SWELLING MODE DISABLE\n", __func__);
6165 battery->skip_swelling = true;
6166 } else {
6167 pr_info("%s : 15TEST END!! SWELLING MODE END\n", __func__);
6168 battery->skip_swelling = false;
6169 }
6170 ret = count;
6171 }
6172 break;
6173 case SAFETY_TIMER_INFO:
6174 break;
6175 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
6176 case BATT_TEMP_TEST:
6177 {
6178 char tc;
6179 if (sscanf(buf, "%c %10d\n", &tc, &x) == 2) {
6180 pr_info("%s : temperature t: %c, temp: %d\n", __func__, tc, x);
6181 if (tc == 'u') {
6182 battery->temperature_test_usb = x;
6183 } else if (tc == 'w') {
6184 battery->temperature_test_wpc = x;
6185 } else if (tc == 'b') {
6186 battery->temperature_test_battery = x;
6187 } else if (tc == 'c') {
6188 battery->temperature_test_chg = x;
6189 }
6190 ret = count;
6191 }
6192 break;
6193 }
6194 #endif
6195 case BATT_CURRENT_EVENT:
6196 break;
6197 case CC_INFO:
6198 break;
6199 case EXT_EVENT:
6200 if (sscanf(buf, "%10d\n", &x) == 1) {
6201 dev_info(battery->dev,
6202 "%s: ext event 0x%x \n", __func__, x);
6203 battery->ext_event = x;
6204 wake_lock(&battery->ext_event_wake_lock);
6205 queue_delayed_work(battery->monitor_wqueue, &battery->ext_event_work, 0);
6206 ret = count;
6207 }
6208 break;
6209 default:
6210 ret = -EINVAL;
6211 break;
6212 }
6213
6214 return ret;
6215 }
6216
6217 static int sec_bat_create_attrs(struct device *dev)
6218 {
6219 unsigned long i = 0;
6220 int rc = 0;
6221
6222 for (i = 0; i < ARRAY_SIZE(sec_battery_attrs); i++) {
6223 rc = device_create_file(dev, &sec_battery_attrs[i]);
6224 if (rc)
6225 goto create_attrs_failed;
6226 }
6227 goto create_attrs_succeed;
6228
6229 create_attrs_failed:
6230 while (i--)
6231 device_remove_file(dev, &sec_battery_attrs[i]);
6232 create_attrs_succeed:
6233 return rc;
6234 }
6235
6236 static int sec_bat_set_property(struct power_supply *psy,
6237 enum power_supply_property psp,
6238 const union power_supply_propval *val)
6239 {
6240 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6241 int current_cable_type = SEC_BATTERY_CABLE_NONE;
6242 int full_check_type = SEC_BATTERY_FULLCHARGED_NONE;
6243 union power_supply_propval value = {0, };
6244 enum power_supply_ext_property ext_psp = (enum power_supply_ext_property) psp;
6245
6246 dev_dbg(battery->dev,
6247 "%s: (%d,%d)\n", __func__, psp, val->intval);
6248
6249 switch (psp) {
6250 case POWER_SUPPLY_PROP_STATUS:
6251 if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST)
6252 full_check_type = battery->pdata->full_check_type;
6253 else
6254 full_check_type = battery->pdata->full_check_type_2nd;
6255 if ((full_check_type == SEC_BATTERY_FULLCHARGED_CHGINT) &&
6256 (val->intval == POWER_SUPPLY_STATUS_FULL))
6257 sec_bat_do_fullcharged(battery);
6258 sec_bat_set_charging_status(battery, val->intval);
6259 break;
6260 case POWER_SUPPLY_PROP_HEALTH:
6261 sec_bat_ovp_uvlo_result(battery, val->intval);
6262 break;
6263 case POWER_SUPPLY_PROP_ONLINE:
6264 current_cable_type = val->intval;
6265 #if !defined(CONFIG_CCIC_NOTIFIER)
6266 if ((battery->muic_cable_type != ATTACHED_DEV_SMARTDOCK_TA_MUIC)
6267 && ((current_cable_type == SEC_BATTERY_CABLE_SMART_OTG) ||
6268 (current_cable_type == SEC_BATTERY_CABLE_SMART_NOTG)))
6269 break;
6270 #endif
6271
6272 if (current_cable_type < 0) {
6273 dev_info(battery->dev,
6274 "%s: ignore event(%d)\n",
6275 __func__, current_cable_type);
6276 } else if (current_cable_type == SEC_BATTERY_CABLE_OTG) {
6277 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
6278 battery->is_recharging = false;
6279 sec_bat_set_charging_status(battery,
6280 POWER_SUPPLY_STATUS_DISCHARGING);
6281 battery->cable_type = current_cable_type;
6282 wake_lock(&battery->monitor_wake_lock);
6283 queue_delayed_work(battery->monitor_wqueue,
6284 &battery->monitor_work, 0);
6285 break;
6286 } else {
6287 battery->wire_status = current_cable_type;
6288 if ((battery->wire_status == SEC_BATTERY_CABLE_NONE) &&
6289 (battery->wc_status != SEC_WIRELESS_PAD_NONE) )
6290 current_cable_type = SEC_BATTERY_CABLE_WIRELESS;
6291 }
6292 dev_info(battery->dev,
6293 "%s: current_cable(%d), wc_status(%d), wire_status(%d)\n",
6294 __func__, current_cable_type, battery->wc_status,
6295 battery->wire_status);
6296
6297 /* cable is attached or detached
6298 * if current_cable_type is minus value,
6299 * check cable by sec_bat_get_cable_type()
6300 * although SEC_BATTERY_CABLE_SOURCE_EXTERNAL is set
6301 * (0 is SEC_BATTERY_CABLE_UNKNOWN)
6302 */
6303 if ((current_cable_type >= 0) &&
6304 (current_cable_type < SEC_BATTERY_CABLE_MAX) &&
6305 (battery->pdata->cable_source_type &
6306 SEC_BATTERY_CABLE_SOURCE_EXTERNAL)) {
6307
6308 wake_lock(&battery->cable_wake_lock);
6309 queue_delayed_work(battery->monitor_wqueue,
6310 &battery->cable_work,0);
6311 } else {
6312 if (sec_bat_get_cable_type(battery,
6313 battery->pdata->cable_source_type)) {
6314 wake_lock(&battery->cable_wake_lock);
6315 queue_delayed_work(battery->monitor_wqueue,
6316 &battery->cable_work,0);
6317 }
6318 }
6319 break;
6320 case POWER_SUPPLY_PROP_CAPACITY:
6321 battery->capacity = val->intval;
6322 power_supply_changed(battery->psy_bat);
6323 break;
6324 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
6325 /* If JIG is attached, the voltage is set as 1079 */
6326 pr_info("%s : set to the battery history : (%d)\n",__func__, val->intval);
6327 if(val->intval == 1079) {
6328 battery->voltage_now = 1079;
6329 battery->voltage_avg = 1079;
6330 power_supply_changed(battery->psy_bat);
6331 }
6332 break;
6333 case POWER_SUPPLY_PROP_CHARGE_TYPE:
6334 wake_lock(&battery->monitor_wake_lock);
6335 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
6336 break;
6337 case POWER_SUPPLY_PROP_PRESENT:
6338 battery->present = val->intval;
6339
6340 wake_lock(&battery->monitor_wake_lock);
6341 queue_delayed_work(battery->monitor_wqueue,
6342 &battery->monitor_work, 0);
6343 break;
6344 #if defined(CONFIG_BATTERY_SWELLING)
6345 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
6346 break;
6347 #endif
6348 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION:
6349 case POWER_SUPPLY_PROP_CHARGE_COUNTER_SHADOW:
6350 break;
6351 case POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL:
6352 value.intval = val->intval;
6353 pr_info("%s: CHGIN-OTG %s\n", __func__, value.intval > 0 ? "on" : "off");
6354 psy_do_property(battery->pdata->charger_name, set,
6355 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
6356 break;
6357 case POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL:
6358 value.intval = val->intval;
6359 pr_info("%s: WCIN-UNO %s\n", __func__, value.intval > 0 ? "on" : "off");
6360 psy_do_property(battery->pdata->charger_name, set,
6361 POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL, value);
6362 break;
6363 #if defined(CONFIG_UPDATE_BATTERY_DATA)
6364 case POWER_SUPPLY_PROP_POWER_DESIGN:
6365 sec_bat_parse_dt(battery->dev, battery);
6366 break;
6367 #endif
6368 #if defined(CONFIG_BATTERY_CISD)
6369 case POWER_SUPPLY_PROP_VOLTAGE_MIN:
6370 pr_info("%s: Valert was occured! run monitor work for updating cisd data!\n", __func__);
6371 battery->cisd.data[CISD_DATA_VALERT_COUNT]++;
6372 battery->cisd.data[CISD_DATA_VALERT_COUNT_PER_DAY]++;
6373 wake_lock(&battery->monitor_wake_lock);
6374 queue_delayed_work_on(0, battery->monitor_wqueue,
6375 &battery->monitor_work, 0);
6376 break;
6377 #endif
6378 case POWER_SUPPLY_PROP_MAX ... POWER_SUPPLY_EXT_PROP_MAX:
6379 switch (ext_psp) {
6380 case POWER_SUPPLY_EXT_PROP_AICL_CURRENT:
6381 battery->aicl_current = val->intval;
6382 battery->max_charge_power = battery->charge_power = battery->input_voltage * val->intval;
6383 pr_info("%s: aicl : %dmA, %dmW)\n", __func__,
6384 battery->aicl_current, battery->charge_power);
6385
6386 if (is_wired_type(battery->cable_type))
6387 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_AICL,
6388 SEC_BAT_CURRENT_EVENT_AICL);
6389
6390 #if defined(CONFIG_BATTERY_CISD)
6391 battery->cisd.data[CISD_DATA_AICL_COUNT]++;
6392 battery->cisd.data[CISD_DATA_AICL_COUNT_PER_DAY]++;
6393 #endif
6394 break;
6395 case POWER_SUPPLY_EXT_PROP_SYSOVLO:
6396 if (battery->status != POWER_SUPPLY_STATUS_DISCHARGING) {
6397 pr_info("%s: Vsys is ovlo !!\n", __func__);
6398 battery->is_sysovlo = true;
6399 battery->is_recharging = false;
6400 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
6401 battery->health = POWER_SUPPLY_HEALTH_VSYS_OVP;
6402 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_VSYS_OVP, SEC_BAT_CURRENT_EVENT_VSYS_OVP);
6403 sec_bat_set_charging_status(battery, POWER_SUPPLY_STATUS_NOT_CHARGING);
6404 #if defined(CONFIG_BATTERY_CISD)
6405 battery->cisd.data[CISD_DATA_VSYS_OVP]++;
6406 battery->cisd.data[CISD_DATA_VSYS_OVP_PER_DAY]++;
6407 #endif
6408 #if defined(CONFIG_SEC_ABC)
6409 sec_abc_send_event("MODULE=battery@ERROR=vsys_ovp");
6410 #endif
6411 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
6412 wake_lock(&battery->monitor_wake_lock);
6413 queue_delayed_work(battery->monitor_wqueue,
6414 &battery->monitor_work, 0);
6415 }
6416 break;
6417 case POWER_SUPPLY_EXT_PROP_VBAT_OVP:
6418 if (battery->status != POWER_SUPPLY_STATUS_DISCHARGING) {
6419 pr_info("%s: Vbat is ovlo !!\n", __func__);
6420 battery->is_vbatovlo = true;
6421 battery->is_recharging = false;
6422 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
6423 battery->health = POWER_SUPPLY_HEALTH_VBAT_OVP;
6424 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_VBAT_OVP, SEC_BAT_CURRENT_EVENT_VBAT_OVP);
6425 sec_bat_set_charging_status(battery, POWER_SUPPLY_STATUS_NOT_CHARGING);
6426
6427 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
6428 wake_lock(&battery->monitor_wake_lock);
6429 queue_delayed_work(battery->monitor_wqueue,
6430 &battery->monitor_work, 0);
6431 }
6432 break;
6433 case POWER_SUPPLY_EXT_PROP_USB_CONFIGURE:
6434 if (battery->pdic_info.sink_status.rp_currentlvl > RP_CURRENT_LEVEL_DEFAULT)
6435 return 0;
6436 pr_info("%s: usb configured %d\n", __func__, val->intval);
6437 if (val->intval == USB_CURRENT_UNCONFIGURED) {
6438 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_USB_100MA,
6439 (SEC_BAT_CURRENT_EVENT_USB_100MA | SEC_BAT_CURRENT_EVENT_USB_SUPER));
6440 } else if (val->intval == USB_CURRENT_HIGH_SPEED) {
6441 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_TIMEOUT_OPEN_TYPE, 1);
6442 sec_bat_set_current_event(battery, 0,
6443 (SEC_BAT_CURRENT_EVENT_USB_100MA | SEC_BAT_CURRENT_EVENT_USB_SUPER));
6444 sec_bat_change_default_current(battery, SEC_BATTERY_CABLE_USB,
6445 USB_CURRENT_HIGH_SPEED, USB_CURRENT_HIGH_SPEED);
6446 } else if (val->intval == USB_CURRENT_SUPER_SPEED) {
6447 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_TIMEOUT_OPEN_TYPE, 1);
6448 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_USB_SUPER,
6449 (SEC_BAT_CURRENT_EVENT_USB_100MA | SEC_BAT_CURRENT_EVENT_USB_SUPER));
6450 sec_bat_change_default_current(battery, SEC_BATTERY_CABLE_USB,
6451 USB_CURRENT_SUPER_SPEED, USB_CURRENT_SUPER_SPEED);
6452 }
6453 sec_bat_set_charging_current(battery);
6454 break;
6455 case POWER_SUPPLY_EXT_PROP_HV_DISABLE:
6456 pr_info("HV wired charging mode is %s\n", (val->intval == CH_MODE_AFC_DISABLE_VAL ? "Disabled" : "Enabled"));
6457 sec_bat_set_current_event(battery, (val->intval == CH_MODE_AFC_DISABLE_VAL ?
6458 SEC_BAT_CURRENT_EVENT_HV_DISABLE : 0), SEC_BAT_CURRENT_EVENT_HV_DISABLE);
6459 break;
6460 case POWER_SUPPLY_EXT_PROP_WC_CONTROL:
6461 pr_info("%s: Recover MFC IC (wc_enable: %d)\n",
6462 __func__, battery->wc_enable);
6463
6464 if (battery->pdata->wpc_en) {
6465 mutex_lock(&battery->wclock);
6466 if (battery->wc_enable) {
6467 gpio_direction_output(battery->pdata->wpc_en, 1);
6468 msleep(500);
6469 gpio_direction_output(battery->pdata->wpc_en, 0);
6470 }
6471 mutex_unlock(&battery->wclock);
6472 }
6473 #if defined(CONFIG_BATTERY_CISD)
6474 increase_cisd_count(CISD_DATA_DROP_VALUE);
6475 #endif
6476 break;
6477 default:
6478 return -EINVAL;
6479 }
6480 break;
6481 default:
6482 return -EINVAL;
6483 }
6484
6485 return 0;
6486 }
6487
6488 static int sec_bat_get_property(struct power_supply *psy,
6489 enum power_supply_property psp,
6490 union power_supply_propval *val)
6491 {
6492 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6493 union power_supply_propval value = {0, };
6494 enum power_supply_ext_property ext_psp = (enum power_supply_ext_property) psp;
6495
6496 switch (psp) {
6497 case POWER_SUPPLY_PROP_STATUS:
6498 if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE) ||
6499 (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) {
6500 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
6501 } else {
6502 if ((battery->pdata->cable_check_type &
6503 SEC_BATTERY_CABLE_CHECK_NOUSBCHARGE) &&
6504 !lpcharge) {
6505 switch (battery->cable_type) {
6506 case SEC_BATTERY_CABLE_USB:
6507 case SEC_BATTERY_CABLE_USB_CDP:
6508 val->intval =
6509 POWER_SUPPLY_STATUS_DISCHARGING;
6510 return 0;
6511 }
6512 }
6513 #if defined(CONFIG_STORE_MODE)
6514 if (battery->store_mode && !lpcharge &&
6515 battery->cable_type != SEC_BATTERY_CABLE_NONE &&
6516 battery->cable_type != SEC_BATTERY_CABLE_OTG &&
6517 battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
6518 val->intval = POWER_SUPPLY_STATUS_CHARGING;
6519 } else
6520 #endif
6521 val->intval = battery->status;
6522 }
6523 break;
6524 case POWER_SUPPLY_PROP_CHARGE_TYPE:
6525 if (battery->cable_type == SEC_BATTERY_CABLE_NONE) {
6526 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
6527 } else {
6528 psy_do_property(battery->pdata->charger_name, get,
6529 POWER_SUPPLY_PROP_CHARGE_TYPE, value);
6530 if (value.intval == SEC_BATTERY_CABLE_UNKNOWN)
6531 /* if error in CHARGE_TYPE of charger
6532 * set CHARGE_TYPE as NONE
6533 */
6534 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
6535 else
6536 val->intval = value.intval;
6537 }
6538 break;
6539 case POWER_SUPPLY_PROP_HEALTH:
6540 if (battery->health >= POWER_SUPPLY_HEALTH_MAX)
6541 val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
6542 else
6543 val->intval = battery->health;
6544 break;
6545 case POWER_SUPPLY_PROP_PRESENT:
6546 val->intval = battery->present;
6547 break;
6548 case POWER_SUPPLY_PROP_ONLINE:
6549 if (is_hv_wireless_type(battery->cable_type) ||
6550 (battery->cable_type == SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV)) {
6551 if (sec_bat_hv_wc_normal_mode_check(battery))
6552 val->intval = SEC_BATTERY_CABLE_WIRELESS;
6553 else
6554 val->intval = SEC_BATTERY_CABLE_HV_WIRELESS_ETX;
6555 }
6556 else if(battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_PACK)
6557 val->intval = SEC_BATTERY_CABLE_WIRELESS;
6558 else if(battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND)
6559 val->intval = SEC_BATTERY_CABLE_WIRELESS;
6560 else if(battery->cable_type == SEC_BATTERY_CABLE_PMA_WIRELESS)
6561 val->intval = SEC_BATTERY_CABLE_WIRELESS;
6562 else if(battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_VEHICLE)
6563 val->intval = SEC_BATTERY_CABLE_WIRELESS;
6564 else if(battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX)
6565 val->intval = SEC_BATTERY_CABLE_WIRELESS;
6566 else
6567 val->intval = battery->cable_type;
6568 pr_info("%s cable type = %d sleep_mode = %d\n", __func__, val->intval, sleep_mode);
6569 break;
6570 case POWER_SUPPLY_PROP_TECHNOLOGY:
6571 val->intval = battery->pdata->technology;
6572 break;
6573 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
6574 #ifdef CONFIG_SEC_FACTORY
6575 psy_do_property(battery->pdata->fuelgauge_name, get,
6576 POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
6577 battery->voltage_now = value.intval;
6578 dev_err(battery->dev,
6579 "%s: voltage now(%d)\n", __func__, battery->voltage_now);
6580 #endif
6581 /* voltage value should be in uV */
6582 val->intval = battery->voltage_now * 1000;
6583 break;
6584 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
6585 #ifdef CONFIG_SEC_FACTORY
6586 value.intval = SEC_BATTERY_VOLTAGE_AVERAGE;
6587 psy_do_property(battery->pdata->fuelgauge_name, get,
6588 POWER_SUPPLY_PROP_VOLTAGE_AVG, value);
6589 battery->voltage_avg = value.intval;
6590 dev_err(battery->dev,
6591 "%s: voltage avg(%d)\n", __func__, battery->voltage_avg);
6592 #endif
6593 /* voltage value should be in uV */
6594 val->intval = battery->voltage_avg * 1000;
6595 break;
6596 case POWER_SUPPLY_PROP_CURRENT_NOW:
6597 val->intval = battery->current_now;
6598 break;
6599 case POWER_SUPPLY_PROP_CURRENT_AVG:
6600 val->intval = battery->current_avg;
6601 break;
6602 case POWER_SUPPLY_PROP_CHARGE_FULL:
6603 #if defined(CONFIG_BATTERY_CISD)
6604 val->intval = battery->pdata->battery_full_capacity * 1000;
6605 #else
6606 val->intval = 0;
6607 #endif
6608 break;
6609 /* charging mode (differ from power supply) */
6610 case POWER_SUPPLY_PROP_CHARGE_NOW:
6611 val->intval = battery->charging_mode;
6612 break;
6613 case POWER_SUPPLY_PROP_CAPACITY:
6614 if (battery->pdata->fake_capacity) {
6615 val->intval = 90;
6616 pr_info("%s : capacity(%d)\n", __func__, val->intval);
6617 } else {
6618 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
6619 if (battery->status == POWER_SUPPLY_STATUS_FULL) {
6620 if(battery->eng_not_full_status)
6621 val->intval = battery->capacity;
6622 else
6623 val->intval = 100;
6624 } else {
6625 val->intval = battery->capacity;
6626 }
6627 #else
6628 if (battery->status == POWER_SUPPLY_STATUS_FULL)
6629 val->intval = 100;
6630 else
6631 val->intval = battery->capacity;
6632 #endif
6633 }
6634 break;
6635 case POWER_SUPPLY_PROP_TEMP:
6636 val->intval = battery->temperature;
6637 break;
6638 case POWER_SUPPLY_PROP_TEMP_AMBIENT:
6639 val->intval = battery->temper_amb;
6640 break;
6641 #if defined(CONFIG_CALC_TIME_TO_FULL)
6642 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
6643 if (battery->capacity == 100) {
6644 val->intval = -1;
6645 break;
6646 }
6647
6648 if (((battery->status == POWER_SUPPLY_STATUS_CHARGING) ||
6649 (battery->status == POWER_SUPPLY_STATUS_FULL && battery->capacity != 100)) &&
6650 !battery->swelling_mode)
6651 val->intval = battery->timetofull;
6652 else
6653 val->intval = -1;
6654 break;
6655 #endif
6656 #if defined(CONFIG_BATTERY_SWELLING)
6657 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
6658 if (battery->swelling_mode)
6659 val->intval = 1;
6660 else
6661 val->intval = 0;
6662 break;
6663 #endif
6664 case POWER_SUPPLY_PROP_CHARGE_COUNTER_SHADOW:
6665 val->intval = battery->wire_status;
6666 break;
6667 case POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL:
6668 case POWER_SUPPLY_PROP_CHARGE_UNO_CONTROL:
6669 break;
6670 case POWER_SUPPLY_PROP_POWER_NOW:
6671 val->intval = battery->charge_power;
6672 break;
6673 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
6674 val->intval = battery->charge_counter;
6675 break;
6676 case POWER_SUPPLY_PROP_MAX ... POWER_SUPPLY_EXT_PROP_MAX:
6677 switch (ext_psp) {
6678 case POWER_SUPPLY_EXT_PROP_SUB_PBA_TEMP_REC:
6679 val->intval = !battery->vbus_limit;
6680 break;
6681 default:
6682 return -EINVAL;
6683 }
6684 break;
6685 default:
6686 return -EINVAL;
6687 }
6688 return 0;
6689 }
6690
6691 static int sec_usb_get_property(struct power_supply *psy,
6692 enum power_supply_property psp,
6693 union power_supply_propval *val)
6694 {
6695 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6696
6697 switch (psp) {
6698 case POWER_SUPPLY_PROP_ONLINE:
6699 break;
6700 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
6701 /* V -> uV */
6702 val->intval = battery->input_voltage * 1000000;
6703 return 0;
6704 case POWER_SUPPLY_PROP_CURRENT_MAX:
6705 /* mA -> uA */
6706 val->intval = battery->pdata->charging_current[battery->cable_type].input_current_limit * 1000;
6707 return 0;
6708 default:
6709 return -EINVAL;
6710 }
6711
6712 if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE) ||
6713 (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) {
6714 val->intval = 0;
6715 return 0;
6716 }
6717 /* Set enable=1 only if the USB charger is connected */
6718 switch (battery->wire_status) {
6719 case SEC_BATTERY_CABLE_USB:
6720 case SEC_BATTERY_CABLE_USB_CDP:
6721 val->intval = 1;
6722 break;
6723 case SEC_BATTERY_CABLE_PDIC:
6724 val->intval = (battery->pd_usb_attached) ? 1:0;
6725 break;
6726 default:
6727 val->intval = 0;
6728 break;
6729 }
6730
6731 if (battery->slate_mode)
6732 val->intval = 0;
6733 return 0;
6734 }
6735
6736 static int sec_ac_get_property(struct power_supply *psy,
6737 enum power_supply_property psp,
6738 union power_supply_propval *val)
6739 {
6740 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6741 enum power_supply_ext_property ext_psp = (enum power_supply_ext_property) psp;
6742
6743 switch (psp) {
6744 case POWER_SUPPLY_PROP_ONLINE:
6745 if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE) ||
6746 (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) {
6747 val->intval = 0;
6748 return 0;
6749 }
6750
6751 /* Set enable=1 only if the AC charger is connected */
6752 switch (battery->cable_type) {
6753 case SEC_BATTERY_CABLE_TA:
6754 case SEC_BATTERY_CABLE_UARTOFF:
6755 case SEC_BATTERY_CABLE_LAN_HUB:
6756 case SEC_BATTERY_CABLE_UNKNOWN:
6757 case SEC_BATTERY_CABLE_PREPARE_TA:
6758 case SEC_BATTERY_CABLE_9V_ERR:
6759 case SEC_BATTERY_CABLE_9V_UNKNOWN:
6760 case SEC_BATTERY_CABLE_9V_TA:
6761 case SEC_BATTERY_CABLE_12V_TA:
6762 case SEC_BATTERY_CABLE_HMT_CONNECTED:
6763 case SEC_BATTERY_CABLE_HMT_CHARGE:
6764 case SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT:
6765 case SEC_BATTERY_CABLE_QC20:
6766 case SEC_BATTERY_CABLE_QC30:
6767 case SEC_BATTERY_CABLE_TIMEOUT:
6768 case SEC_BATTERY_CABLE_SMART_OTG:
6769 case SEC_BATTERY_CABLE_SMART_NOTG:
6770 val->intval = 1;
6771 break;
6772 case SEC_BATTERY_CABLE_PDIC:
6773 val->intval = (battery->pd_usb_attached) ? 0:1;
6774 break;
6775 default:
6776 val->intval = 0;
6777 break;
6778 }
6779 break;
6780 case POWER_SUPPLY_PROP_TEMP:
6781 val->intval = battery->chg_temp;
6782 break;
6783 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
6784 /* V -> uV */
6785 val->intval = battery->input_voltage * 1000000;
6786 return 0;
6787 case POWER_SUPPLY_PROP_CURRENT_MAX:
6788 /* mA -> uA */
6789 val->intval = battery->pdata->charging_current[battery->cable_type].input_current_limit * 1000;
6790 return 0;
6791 case POWER_SUPPLY_PROP_MAX ... POWER_SUPPLY_EXT_PROP_MAX:
6792 switch (ext_psp) {
6793 case POWER_SUPPLY_EXT_PROP_WATER_DETECT:
6794 if (battery->misc_event & (BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE |
6795 BATT_MISC_EVENT_HICCUP_TYPE)) {
6796 val->intval = 1;
6797 pr_info("%s: Water Detect\n", __func__);
6798 } else {
6799 val->intval = 0;
6800 }
6801 break;
6802 default:
6803 return -EINVAL;
6804 }
6805 break;
6806 default:
6807 return -EINVAL;
6808 }
6809
6810 if (lpcharge && (battery->misc_event & BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE)) {
6811 val->intval = 1;
6812 }
6813
6814 return 0;
6815 }
6816
6817 static int sec_wireless_get_property(struct power_supply *psy,
6818 enum power_supply_property psp,
6819 union power_supply_propval *val)
6820 {
6821 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6822
6823 switch (psp) {
6824 case POWER_SUPPLY_PROP_ONLINE:
6825 val->intval = is_wireless_type(battery->cable_type) ?
6826 1 : 0;
6827 break;
6828 case POWER_SUPPLY_PROP_PRESENT:
6829 val->intval = (battery->pdata->wireless_charger_name) ?
6830 1 : 0;
6831 break;
6832 case POWER_SUPPLY_PROP_VOLTAGE_MAX:
6833 /* V -> uV */
6834 val->intval = battery->input_voltage * 1000000;
6835 return 0;
6836 case POWER_SUPPLY_PROP_CURRENT_MAX:
6837 /* mA -> uA */
6838 val->intval = battery->pdata->charging_current[battery->cable_type].input_current_limit * 1000;
6839 return 0;
6840 default:
6841 return -EINVAL;
6842 }
6843
6844 return 0;
6845 }
6846
6847 static int sec_wireless_set_property(struct power_supply *psy,
6848 enum power_supply_property psp,
6849 const union power_supply_propval *val)
6850 {
6851 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6852 enum power_supply_ext_property ext_psp = (enum power_supply_ext_property) psp;
6853
6854 switch (psp) {
6855 case POWER_SUPPLY_PROP_ONLINE:
6856 #if defined(CONFIG_BATTERY_CISD)
6857 if (val->intval != SEC_WIRELESS_PAD_NONE && battery->wc_status == SEC_WIRELESS_PAD_NONE) {
6858 battery->cisd.data[CISD_DATA_WIRELESS_COUNT]++;
6859 battery->cisd.data[CISD_DATA_WIRELESS_COUNT_PER_DAY]++;
6860 }
6861 #endif
6862 /* Clear the FOD State */
6863 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_WIRELESS_FOD, 1);
6864
6865 if (val->intval == SEC_WIRELESS_PAD_A4WP)
6866 battery->wc_status = SEC_WIRELESS_PAD_WPC;
6867 else
6868 battery->wc_status = val->intval;
6869
6870 if ((battery->ext_event & BATT_EXT_EVENT_CALL) &&
6871 (battery->wc_status == SEC_WIRELESS_PAD_WPC_PACK ||
6872 battery->wc_status == SEC_WIRELESS_PAD_WPC_PACK_HV ||
6873 battery->wc_status == SEC_WIRELESS_PAD_TX)) {
6874 battery->wc_rx_phm_mode = true;
6875 }
6876
6877 wake_lock(&battery->cable_wake_lock);
6878 queue_delayed_work(battery->monitor_wqueue,
6879 &battery->cable_work, 0);
6880 break;
6881 case POWER_SUPPLY_PROP_AUTHENTIC:
6882 #if defined(CONFIG_BATTERY_CISD)
6883 pr_info("%s : tx_type(0x%x)\n", __func__, val->intval);
6884 count_cisd_pad_data(&battery->cisd, val->intval);
6885 #endif
6886 break;
6887 case POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL:
6888 if (val->intval) {
6889 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK,
6890 SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK);
6891 } else {
6892 sec_bat_set_current_event(battery, 0,
6893 SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK);
6894 }
6895
6896 if (is_hv_wireless_type(battery->cable_type)) {
6897 union power_supply_propval value = {0, };
6898 int cnt;
6899
6900 mutex_lock(&battery->iolock);
6901 value.intval = (val->intval) ? WIRELESS_VOUT_5V :
6902 battery->wpc_vout_level;
6903 psy_do_property(battery->pdata->wireless_charger_name, set,
6904 POWER_SUPPLY_PROP_INPUT_VOLTAGE_REGULATION, value);
6905 battery->aicl_current = 0; /* reset aicl current */
6906 mutex_unlock(&battery->iolock);
6907
6908 for (cnt = 0; cnt < 5; cnt++) {
6909 msleep(100);
6910 psy_do_property(battery->pdata->wireless_charger_name, get,
6911 POWER_SUPPLY_PROP_ENERGY_NOW, value);
6912 if (value.intval <= 6000) {
6913 pr_info("%s: wireless vout goes to 5V Vout(%d).\n",
6914 __func__, value.intval);
6915 break;
6916 }
6917 }
6918 }
6919 break;
6920 case POWER_SUPPLY_PROP_CURRENT_MAX:
6921 battery->aicl_current = 0; /* reset aicl current */
6922 pr_info("%s: reset aicl\n", __func__);
6923 break;
6924 case POWER_SUPPLY_PROP_MAX ... POWER_SUPPLY_EXT_PROP_MAX:
6925 switch (ext_psp) {
6926 case POWER_SUPPLY_EXT_PROP_WIRELESS_TX_CHG_ERR:
6927 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_WIRELESS_FOD, !val->intval);
6928 break;
6929 case POWER_SUPPLY_EXT_PROP_CALL_EVENT:
6930 if(val->intval == 1) {
6931 pr_info("%s : PHM enabled\n",__func__);
6932 battery->wc_rx_phm_mode = true;
6933 }
6934 break;
6935 default:
6936 return -EINVAL;
6937 }
6938 break;
6939 default:
6940 return -EINVAL;
6941 }
6942
6943 return 0;
6944 }
6945
6946 static int sec_ps_set_property(struct power_supply *psy,
6947 enum power_supply_property psp,
6948 const union power_supply_propval *val)
6949 {
6950 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6951 union power_supply_propval value;
6952
6953 switch (psp) {
6954 case POWER_SUPPLY_PROP_STATUS:
6955 if (val->intval == 0 && battery->ps_enable == true) {
6956 battery->ps_enable = false;
6957 value.intval = val->intval;
6958 psy_do_property(battery->pdata->charger_name, set,
6959 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
6960 } else if ((val->intval == 1) && (battery->ps_enable == false) &&
6961 (battery->ps_status == true)) {
6962 battery->ps_enable = true;
6963 value.intval = val->intval;
6964 psy_do_property(battery->pdata->charger_name, set,
6965 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
6966 } else {
6967 dev_err(battery->dev,
6968 "%s: invalid setting (%d)\n", __func__, val->intval);
6969 }
6970 break;
6971 case POWER_SUPPLY_PROP_ONLINE:
6972 if (val->intval == SEC_BATTERY_CABLE_POWER_SHARING) {
6973 battery->ps_status = true;
6974 battery->ps_enable = true;
6975 value.intval = battery->ps_enable;
6976 psy_do_property(battery->pdata->charger_name, set,
6977 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
6978 } else {
6979 battery->ps_status = false;
6980 battery->ps_enable = false;
6981 value.intval = battery->ps_enable;
6982 psy_do_property(battery->pdata->charger_name, set,
6983 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
6984 }
6985 break;
6986 default:
6987 return -EINVAL;
6988 }
6989
6990 return 0;
6991 }
6992
6993 static int sec_ps_get_property(struct power_supply *psy,
6994 enum power_supply_property psp,
6995 union power_supply_propval *val)
6996 {
6997 struct sec_battery_info *battery = power_supply_get_drvdata(psy);
6998
6999 switch (psp) {
7000 case POWER_SUPPLY_PROP_STATUS:
7001 val->intval = (battery->ps_enable) ? 1 : 0;
7002 break;
7003 case POWER_SUPPLY_PROP_ONLINE:
7004 val->intval = (battery->ps_status) ? 1 : 0;
7005 break;
7006 default:
7007 return -EINVAL;
7008 }
7009
7010 return 0;
7011 }
7012
7013 #if defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER) || defined(CONFIG_MUIC_NOTIFIER)
7014 static int sec_bat_cable_check(struct sec_battery_info *battery,
7015 muic_attached_dev_t attached_dev)
7016 {
7017 int current_cable_type = -1;
7018 union power_supply_propval val = {0, };
7019
7020 pr_info("[%s]ATTACHED(%d)\n", __func__, attached_dev);
7021
7022 switch (attached_dev)
7023 {
7024 case ATTACHED_DEV_JIG_UART_OFF_MUIC:
7025 case ATTACHED_DEV_JIG_UART_ON_MUIC:
7026 battery->is_jig_on = true;
7027 #if defined(CONFIG_BATTERY_CISD)
7028 battery->skip_cisd = true;
7029 #endif
7030 case ATTACHED_DEV_SMARTDOCK_MUIC:
7031 case ATTACHED_DEV_DESKDOCK_MUIC:
7032 case ATTACHED_DEV_JIG_USB_ON_MUIC:
7033 current_cable_type = SEC_BATTERY_CABLE_NONE;
7034 break;
7035 case ATTACHED_DEV_UNDEFINED_CHARGING_MUIC:
7036 case ATTACHED_DEV_UNDEFINED_RANGE_MUIC:
7037 current_cable_type = SEC_BATTERY_CABLE_NONE;
7038 #if defined(CONFIG_BATTERY_CISD)
7039 battery->cisd.data[CISD_DATA_WATER_DETECT]++;
7040 battery->cisd.data[CISD_DATA_WATER_DETECT_PER_DAY]++;
7041 #endif
7042 #if defined(CONFIG_SEC_ABC)
7043 sec_abc_send_event("MODULE=battery@ERROR=water_detect");
7044 #endif
7045 break;
7046 case ATTACHED_DEV_OTG_MUIC:
7047 case ATTACHED_DEV_JIG_UART_OFF_VB_OTG_MUIC:
7048 case ATTACHED_DEV_HMT_MUIC:
7049 current_cable_type = SEC_BATTERY_CABLE_OTG;
7050 break;
7051 case ATTACHED_DEV_TIMEOUT_OPEN_MUIC:
7052 current_cable_type = SEC_BATTERY_CABLE_TIMEOUT;
7053 break;
7054 case ATTACHED_DEV_USB_MUIC:
7055 case ATTACHED_DEV_JIG_USB_OFF_MUIC:
7056 case ATTACHED_DEV_SMARTDOCK_USB_MUIC:
7057 case ATTACHED_DEV_UNOFFICIAL_ID_USB_MUIC:
7058 current_cable_type = SEC_BATTERY_CABLE_USB;
7059 break;
7060 case ATTACHED_DEV_JIG_UART_ON_VB_MUIC:
7061 case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
7062 case ATTACHED_DEV_JIG_UART_OFF_VB_FG_MUIC:
7063 current_cable_type = SEC_BATTERY_CABLE_UARTOFF;
7064 break;
7065 case ATTACHED_DEV_RDU_TA_MUIC:
7066 battery->store_mode = true;
7067 wake_lock(&battery->parse_mode_dt_wake_lock);
7068 queue_delayed_work(battery->monitor_wqueue, &battery->parse_mode_dt_work, 0);
7069 case ATTACHED_DEV_TA_MUIC:
7070 case ATTACHED_DEV_CARDOCK_MUIC:
7071 case ATTACHED_DEV_DESKDOCK_VB_MUIC:
7072 case ATTACHED_DEV_SMARTDOCK_TA_MUIC:
7073 case ATTACHED_DEV_UNOFFICIAL_TA_MUIC:
7074 case ATTACHED_DEV_UNOFFICIAL_ID_TA_MUIC:
7075 case ATTACHED_DEV_UNOFFICIAL_ID_ANY_MUIC:
7076 case ATTACHED_DEV_UNSUPPORTED_ID_VB_MUIC:
7077 current_cable_type = SEC_BATTERY_CABLE_TA;
7078 break;
7079 case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
7080 case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
7081 case ATTACHED_DEV_AFC_CHARGER_5V_DUPLI_MUIC:
7082 if (is_hv_wire_type(battery->cable_type) &&
7083 (battery->chg_limit || battery->vbus_chg_by_siop)) {
7084 current_cable_type = SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT;
7085 } else if (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC &&
7086 battery->pdic_info.sink_status.rp_currentlvl == RP_CURRENT_LEVEL_DEFAULT) {
7087 current_cable_type = SEC_BATTERY_CABLE_PREPARE_TA;
7088 } else {
7089 current_cable_type = SEC_BATTERY_CABLE_TA;
7090 }
7091 break;
7092 case ATTACHED_DEV_CDP_MUIC:
7093 case ATTACHED_DEV_UNOFFICIAL_ID_CDP_MUIC:
7094 current_cable_type = SEC_BATTERY_CABLE_USB_CDP;
7095 break;
7096 case ATTACHED_DEV_USB_LANHUB_MUIC:
7097 current_cable_type = SEC_BATTERY_CABLE_LAN_HUB;
7098 break;
7099 case ATTACHED_DEV_CHARGING_CABLE_MUIC:
7100 current_cable_type = SEC_BATTERY_CABLE_POWER_SHARING;
7101 break;
7102 case ATTACHED_DEV_AFC_CHARGER_PREPARE_MUIC:
7103 case ATTACHED_DEV_QC_CHARGER_PREPARE_MUIC:
7104 current_cable_type = SEC_BATTERY_CABLE_PREPARE_TA;
7105 break;
7106 case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
7107 case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
7108 case ATTACHED_DEV_AFC_CHARGER_9V_DUPLI_MUIC:
7109 current_cable_type = SEC_BATTERY_CABLE_9V_TA;
7110 break;
7111 #if defined(CONFIG_MUIC_HV_12V)
7112 case ATTACHED_DEV_AFC_CHARGER_12V_MUIC:
7113 case ATTACHED_DEV_AFC_CHARGER_12V_DUPLI_MUIC:
7114 current_cable_type = SEC_BATTERY_CABLE_12V_TA;
7115 break;
7116 #endif
7117 case ATTACHED_DEV_AFC_CHARGER_ERR_V_MUIC:
7118 case ATTACHED_DEV_AFC_CHARGER_ERR_V_DUPLI_MUIC:
7119 case ATTACHED_DEV_QC_CHARGER_ERR_V_MUIC:
7120 current_cable_type = SEC_BATTERY_CABLE_9V_ERR;
7121 #if defined(CONFIG_BATTERY_CISD)
7122 battery->cisd.data[CISD_DATA_AFC_FAIL]++;
7123 battery->cisd.data[CISD_DATA_AFC_FAIL_PER_DAY]++;
7124 #endif
7125 #if defined(CONFIG_SEC_ABC)
7126 sec_abc_send_event("MODULE=battery@ERROR=afc_fail");
7127 #endif
7128 break;
7129 case ATTACHED_DEV_HV_ID_ERR_UNDEFINED_MUIC:
7130 case ATTACHED_DEV_HV_ID_ERR_UNSUPPORTED_MUIC:
7131 case ATTACHED_DEV_HV_ID_ERR_SUPPORTED_MUIC:
7132 current_cable_type = SEC_BATTERY_CABLE_9V_UNKNOWN;
7133 #if defined(CONFIG_BATTERY_CISD)
7134 battery->cisd.data[CISD_DATA_AFC_FAIL]++;
7135 battery->cisd.data[CISD_DATA_AFC_FAIL_PER_DAY]++;
7136 #endif
7137 #if defined(CONFIG_SEC_ABC)
7138 sec_abc_send_event("MODULE=battery@ERROR=afc_fail");
7139 #endif
7140 break;
7141 case ATTACHED_DEV_VZW_INCOMPATIBLE_MUIC:
7142 current_cable_type = SEC_BATTERY_CABLE_UNKNOWN;
7143 break;
7144 default:
7145 pr_err("%s: invalid type for charger:%d\n",
7146 __func__, attached_dev);
7147 break;
7148 }
7149
7150 if (battery->is_jig_on && !battery->pdata->support_fgsrc_change)
7151 psy_do_property(battery->pdata->fuelgauge_name, set,
7152 POWER_SUPPLY_PROP_ENERGY_NOW, val);
7153
7154 return current_cable_type;
7155 }
7156 #endif
7157
7158 #if defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
7159 #if defined(CONFIG_CCIC_NOTIFIER)
7160 static int sec_bat_get_pd_list_index(PDIC_SINK_STATUS *sink_status, struct sec_bat_pdic_list *pd_list)
7161 {
7162 int i = 0;
7163
7164 for (i = 0; i < pd_list->max_pd_count; i++) {
7165 if (pd_list->pd_info[i].pdo_index == sink_status->current_pdo_num)
7166 return i;
7167 }
7168
7169 return 0;
7170 }
7171
7172 static void sec_bat_set_rp_current(struct sec_battery_info *battery, int cable_type)
7173 {
7174 if (battery->pdic_info.sink_status.rp_currentlvl == RP_CURRENT_LEVEL3) {
7175 if (battery->current_event & SEC_BAT_CURRENT_EVENT_HV_DISABLE)
7176 sec_bat_change_default_current(battery, cable_type,
7177 battery->pdata->default_input_current, battery->pdata->default_charging_current);
7178 else
7179 sec_bat_change_default_current(battery, cable_type,
7180 RP_CURRENT_RP3, battery->pdata->max_charging_current);
7181 }
7182 else if (battery->pdic_info.sink_status.rp_currentlvl == RP_CURRENT_LEVEL2)
7183 sec_bat_change_default_current(battery, cable_type,
7184 RP_CURRENT_RP2, RP_CURRENT_RP2);
7185 else if (cable_type == SEC_BATTERY_CABLE_USB) {
7186 if (battery->current_event & SEC_BAT_CURRENT_EVENT_USB_SUPER)
7187 sec_bat_change_default_current(battery, SEC_BATTERY_CABLE_USB,
7188 USB_CURRENT_SUPER_SPEED, USB_CURRENT_SUPER_SPEED);
7189 else
7190 sec_bat_change_default_current(battery, cable_type,
7191 RP_CURRENT_RP1, RP_CURRENT_RP1);
7192 }
7193
7194 pr_info("%s:(%d)\n", __func__, battery->pdic_info.sink_status.rp_currentlvl);
7195 battery->max_charge_power = 0;
7196 sec_bat_set_charging_current(battery);
7197 }
7198 #endif
7199
7200 static int make_pd_list(struct sec_battery_info *battery)
7201 {
7202 int i = 0, j = 0, min = 0, temp_voltage = 0, temp_current = 0, temp_index = 0;
7203 int base_charge_power = 0, selected_pdo_voltage = 0, selected_pdo_num = 0;
7204 int pd_list_index = 0;
7205 int pd_charging_charge_power = battery->current_event & SEC_BAT_CURRENT_EVENT_HV_DISABLE ?
7206 battery->pdata->nv_charge_power : battery->pdata->pd_charging_charge_power;
7207
7208 for (base_charge_power = pd_charging_charge_power * 1000;
7209 base_charge_power >= 1000000; base_charge_power -= 1000000)
7210 {
7211 selected_pdo_voltage = battery->pdata->max_input_voltage + 1;
7212 selected_pdo_num = 0;
7213 for(i=1; i<= battery->pdic_info.sink_status.available_pdo_num; i++)
7214 {
7215 if (battery->pdic_info.sink_status.power_list[i].max_voltage *
7216 battery->pdic_info.sink_status.power_list[i].max_current > base_charge_power - 1000000 &&
7217 battery->pdic_info.sink_status.power_list[i].max_voltage *
7218 battery->pdic_info.sink_status.power_list[i].max_current <= base_charge_power)
7219 {
7220 if (battery->pdic_info.sink_status.power_list[i].max_voltage < selected_pdo_voltage)
7221 {
7222 selected_pdo_voltage = battery->pdic_info.sink_status.power_list[i].max_voltage;
7223 selected_pdo_num = i;
7224 battery->pdic_info.sink_status.power_list[i].max_current =
7225 battery->pdic_info.sink_status.power_list[i].max_current >
7226 battery->pdata->max_input_current ?
7227 battery->pdata->max_input_current : battery->pdic_info.sink_status.power_list[i].max_current;
7228 }
7229 }
7230 }
7231 if (selected_pdo_num)
7232 {
7233 battery->pd_list.pd_info[pd_list_index].input_voltage =
7234 battery->pdic_info.sink_status.power_list[selected_pdo_num].max_voltage;
7235 battery->pd_list.pd_info[pd_list_index].input_current =
7236 battery->pdic_info.sink_status.power_list[selected_pdo_num].max_current;
7237 battery->pd_list.pd_info[pd_list_index].pdo_index = selected_pdo_num;
7238 pd_list_index++;
7239 }
7240 }
7241 pr_info("%s: total pd_list_index: %d\n", __func__, pd_list_index);
7242 if (pd_list_index <= 0) {
7243 pr_info("%s : PDO list is empty!!\n", __func__);
7244 return 0;
7245 }
7246
7247 for (i = 0; i < pd_list_index - 1; i++) {
7248 min = i;
7249 for (j = i + 1; j < pd_list_index; j++) {
7250 if (battery->pd_list.pd_info[j].input_voltage <
7251 battery->pd_list.pd_info[min].input_voltage)
7252 min = j;
7253 }
7254 temp_voltage = battery->pd_list.pd_info[i].input_voltage;
7255 battery->pd_list.pd_info[i].input_voltage =
7256 battery->pd_list.pd_info[min].input_voltage;
7257 battery->pd_list.pd_info[min].input_voltage = temp_voltage;
7258 temp_current = battery->pd_list.pd_info[i].input_current;
7259 battery->pd_list.pd_info[i].input_current =
7260 battery->pd_list.pd_info[min].input_current;
7261 battery->pd_list.pd_info[min].input_current = temp_current;
7262 temp_index = battery->pd_list.pd_info[i].pdo_index;
7263 battery->pd_list.pd_info[i].pdo_index =
7264 battery->pd_list.pd_info[min].pdo_index;
7265 battery->pd_list.pd_info[min].pdo_index = temp_index;
7266 }
7267 for(i = 0; i < pd_list_index; i++) {
7268 pr_info("%s: Made pd_list[%d], voltage : %d, current : %d, index : %d\n", __func__, i,
7269 battery->pd_list.pd_info[i].input_voltage,
7270 battery->pd_list.pd_info[i].input_current,
7271 battery->pd_list.pd_info[i].pdo_index);
7272 }
7273 battery->pd_list.max_pd_count = pd_list_index;
7274 battery->max_charge_power = battery->pdic_info.sink_status.power_list[ \
7275 battery->pd_list.pd_info[pd_list_index-1].pdo_index].max_voltage * \
7276 battery->pdic_info.sink_status.power_list[battery->pd_list.pd_info[ \
7277 pd_list_index-1].pdo_index].max_current / 1000;
7278 battery->pd_max_charge_power = battery->max_charge_power;
7279
7280 if (battery->pdic_info.sink_status.selected_pdo_num == battery->pd_list.pd_info[pd_list_index-1].pdo_index) {
7281 battery->pd_list.now_pd_index = pd_list_index - 1;
7282 battery->pdic_ps_rdy = true;
7283 dev_info(battery->dev, "%s: battery->pdic_ps_rdy(%d)\n", __func__, battery->pdic_ps_rdy);
7284 } else {
7285 /* change input current before request new pdo if new pdo's input current is less than now */
7286 if (battery->pd_list.pd_info[pd_list_index-1].input_current < battery->input_current) {
7287 union power_supply_propval value = {0, };
7288 int input_current = battery->pd_list.pd_info[pd_list_index-1].input_current;
7289
7290 value.intval = input_current;
7291 battery->input_current = input_current;
7292 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_SELECT_PDO,
7293 SEC_BAT_CURRENT_EVENT_SELECT_PDO);
7294 psy_do_property(battery->pdata->charger_name, set,
7295 POWER_SUPPLY_PROP_CURRENT_MAX, value);
7296 }
7297 battery->pdic_ps_rdy = false;
7298 select_pdo(battery->pd_list.pd_info[pd_list_index-1].pdo_index);
7299 }
7300
7301 return battery->pd_list.max_pd_count;
7302 }
7303
7304 static int usb_typec_handle_notification(struct notifier_block *nb,
7305 unsigned long action, void *data)
7306 {
7307 const char *cmd;
7308 struct sec_battery_info *battery =
7309 container_of(nb, struct sec_battery_info, usb_typec_nb);
7310 int cable_type = SEC_BATTERY_CABLE_NONE, i = 0, current_pdo = 0;
7311 int pd_charging_charge_power = battery->current_event & SEC_BAT_CURRENT_EVENT_HV_DISABLE ?
7312 battery->pdata->nv_charge_power : battery->pdata->pd_charging_charge_power;
7313 CC_NOTI_ATTACH_TYPEDEF usb_typec_info = *(CC_NOTI_ATTACH_TYPEDEF *)data;
7314
7315 dev_info(battery->dev, "%s: action (%ld) dump(0x%01x, 0x%01x, 0x%02x, 0x%04x, 0x%04x, 0x%04x)\n",
7316 __func__, action, usb_typec_info.src, usb_typec_info.dest, usb_typec_info.id,
7317 usb_typec_info.attach, usb_typec_info.rprd, usb_typec_info.cable_type);
7318
7319 if (usb_typec_info.dest != CCIC_NOTIFY_DEV_BATTERY) {
7320 dev_info(battery->dev, "%s: skip handler dest(%d)\n",
7321 __func__, usb_typec_info.dest);
7322 return 0;
7323 }
7324
7325 mutex_lock(&battery->typec_notylock);
7326 switch (usb_typec_info.id) {
7327 case CCIC_NOTIFY_ID_WATER:
7328 case CCIC_NOTIFY_ID_ATTACH:
7329 switch (usb_typec_info.attach) {
7330 case MUIC_NOTIFY_CMD_DETACH:
7331 case MUIC_NOTIFY_CMD_LOGICALLY_DETACH:
7332 cmd = "DETACH";
7333 battery->is_jig_on = false;
7334 battery->pd_usb_attached = false;
7335 cable_type = SEC_BATTERY_CABLE_NONE;
7336 battery->muic_cable_type = ATTACHED_DEV_NONE_MUIC;
7337 battery->pdic_info.sink_status.rp_currentlvl = RP_CURRENT_LEVEL_NONE;
7338 break;
7339 case MUIC_NOTIFY_CMD_ATTACH:
7340 case MUIC_NOTIFY_CMD_LOGICALLY_ATTACH:
7341 /* Skip notify from MUIC if PDIC is attached already */
7342 if (battery->wire_status == SEC_BATTERY_CABLE_PDIC) {
7343 mutex_unlock(&battery->typec_notylock);
7344 return 0;
7345 }
7346 cmd = "ATTACH";
7347 battery->muic_cable_type = usb_typec_info.cable_type;
7348 cable_type = sec_bat_cable_check(battery, battery->muic_cable_type);
7349 if (battery->cable_type != cable_type &&
7350 battery->pdic_info.sink_status.rp_currentlvl >= RP_CURRENT_LEVEL_DEFAULT &&
7351 (cable_type == SEC_BATTERY_CABLE_USB || cable_type == SEC_BATTERY_CABLE_TA)) {
7352 sec_bat_set_rp_current(battery, cable_type);
7353 } else if ((struct pdic_notifier_struct *)usb_typec_info.pd != NULL &&
7354 (*(struct pdic_notifier_struct *)usb_typec_info.pd).event == PDIC_NOTIFY_EVENT_CCIC_ATTACH &&
7355 (*(struct pdic_notifier_struct *)usb_typec_info.pd).sink_status.rp_currentlvl >= RP_CURRENT_LEVEL_DEFAULT &&
7356 (cable_type == SEC_BATTERY_CABLE_USB || cable_type == SEC_BATTERY_CABLE_TA)) {
7357 battery->pdic_info.sink_status.rp_currentlvl =
7358 (*(struct pdic_notifier_struct *)usb_typec_info.pd).sink_status.rp_currentlvl;
7359 sec_bat_set_rp_current(battery, cable_type);
7360 }
7361 break;
7362 default:
7363 cmd = "ERROR";
7364 cable_type = -1;
7365 battery->muic_cable_type = usb_typec_info.cable_type;
7366 break;
7367 }
7368 battery->pdic_attach = false;
7369 battery->pdic_ps_rdy = false;
7370 #if defined(CONFIG_AFC_CHARGER_MODE)
7371 if (battery->muic_cable_type == ATTACHED_DEV_QC_CHARGER_9V_MUIC ||
7372 battery->muic_cable_type == ATTACHED_DEV_QC_CHARGER_ERR_V_MUIC)
7373 battery->hv_chg_name = "QC";
7374 else if (battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_9V_MUIC ||
7375 battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_9V_DUPLI_MUIC ||
7376 battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_ERR_V_MUIC ||
7377 battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_ERR_V_DUPLI_MUIC)
7378 battery->hv_chg_name = "AFC";
7379 #if defined(CONFIG_MUIC_HV_12V)
7380 else if (battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_12V_MUIC ||
7381 battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_12V_DUPLI_MUIC)
7382 battery->hv_chg_name = "12V";
7383 #endif
7384 else
7385 battery->hv_chg_name = "NONE";
7386 #endif
7387 break;
7388 case CCIC_NOTIFY_ID_POWER_STATUS:
7389 #ifdef CONFIG_SEC_FACTORY
7390 dev_info(battery->dev, "%s: pd_event(%d)\n", __func__,
7391 (*(struct pdic_notifier_struct *)usb_typec_info.pd).event);
7392 #endif
7393 if ((*(struct pdic_notifier_struct *)usb_typec_info.pd).event == PDIC_NOTIFY_EVENT_DETACH){
7394 dev_info(battery->dev, "%s: skip pd operation - attach(%d)\n", __func__, usb_typec_info.attach);
7395 battery->pdic_attach = false;
7396 battery->pdic_ps_rdy = false;
7397 battery->pd_list.now_pd_index = 0;
7398 mutex_unlock(&battery->typec_notylock);
7399 return 0;
7400 }
7401
7402 cmd = "PD_ATTACH";
7403 if ((*(struct pdic_notifier_struct *)usb_typec_info.pd).event == PDIC_NOTIFY_EVENT_CCIC_ATTACH) {
7404 battery->pdic_info.sink_status.rp_currentlvl =
7405 (*(struct pdic_notifier_struct *)usb_typec_info.pd).sink_status.rp_currentlvl;
7406 dev_info(battery->dev, "%s: battery->rp_currentlvl(%d)\n", __func__, battery->pdic_info.sink_status.rp_currentlvl);
7407 if (battery->wire_status == SEC_BATTERY_CABLE_USB || battery->wire_status == SEC_BATTERY_CABLE_TA) {
7408 cable_type = battery->wire_status;
7409 battery->chg_limit = false;
7410 sec_bat_set_rp_current(battery, cable_type);
7411 goto skip_cable_check;
7412 }
7413 mutex_unlock(&battery->typec_notylock);
7414 return 0;
7415 }
7416 if ((*(struct pdic_notifier_struct *)usb_typec_info.pd).event == PDIC_NOTIFY_EVENT_PD_SINK_CAP)
7417 battery->pdic_attach = false;
7418 if (!battery->pdic_attach) {
7419 battery->pdic_info = *(struct pdic_notifier_struct *)usb_typec_info.pd;
7420 battery->pd_list.now_pd_index = 0;
7421 } else {
7422 battery->pdic_info.sink_status.selected_pdo_num =
7423 (*(struct pdic_notifier_struct *)usb_typec_info.pd).sink_status.selected_pdo_num;
7424 battery->pdic_info.sink_status.current_pdo_num =
7425 (*(struct pdic_notifier_struct *)usb_typec_info.pd).sink_status.current_pdo_num;
7426 battery->pd_list.now_pd_index = sec_bat_get_pd_list_index(&battery->pdic_info.sink_status,
7427 &battery->pd_list);
7428 battery->pdic_ps_rdy = true;
7429 dev_info(battery->dev, "%s: battery->pdic_ps_rdy(%d)\n", __func__, battery->pdic_ps_rdy);
7430 }
7431 current_pdo = battery->pdic_info.sink_status.current_pdo_num;
7432 cable_type = SEC_BATTERY_CABLE_PDIC;
7433 battery->muic_cable_type = ATTACHED_DEV_NONE_MUIC;
7434 #if defined(CONFIG_AFC_CHARGER_MODE)
7435 battery->hv_chg_name = "PDIC";
7436 #endif
7437 battery->input_voltage =
7438 battery->pdic_info.sink_status.power_list[current_pdo].max_voltage / 1000;
7439 dev_info(battery->dev, "%s: available pdo : %d, current pdo : %d\n", __func__,
7440 battery->pdic_info.sink_status.available_pdo_num, current_pdo);
7441
7442 for(i=1; i<= battery->pdic_info.sink_status.available_pdo_num; i++) {
7443 pr_info("%s: power_list[%d], voltage : %d, current : %d, power : %d\n", __func__, i,
7444 battery->pdic_info.sink_status.power_list[i].max_voltage,
7445 battery->pdic_info.sink_status.power_list[i].max_current,
7446 battery->pdic_info.sink_status.power_list[i].max_voltage *
7447 battery->pdic_info.sink_status.power_list[i].max_current);
7448
7449 if ((battery->pdic_info.sink_status.power_list[i].max_voltage *
7450 battery->pdic_info.sink_status.power_list[i].max_current) >
7451 (pd_charging_charge_power * 1000)) {
7452 battery->pdic_info.sink_status.power_list[i].max_current =
7453 (pd_charging_charge_power * 1000) /
7454 battery->pdic_info.sink_status.power_list[i].max_voltage;
7455
7456 pr_info("%s: ->updated [%d], voltage : %d, current : %d, power : %d\n", __func__, i,
7457 battery->pdic_info.sink_status.power_list[i].max_voltage,
7458 battery->pdic_info.sink_status.power_list[i].max_current,
7459 battery->pdic_info.sink_status.power_list[i].max_voltage *
7460 battery->pdic_info.sink_status.power_list[i].max_current);
7461 }
7462
7463 }
7464 if (!battery->pdic_attach) {
7465 if (make_pd_list(battery) <= 0)
7466 goto skip_cable_work;
7467 }
7468 battery->pdic_attach = true;
7469 break;
7470 case CCIC_NOTIFY_ID_USB:
7471 if(usb_typec_info.cable_type == PD_USB_TYPE)
7472 battery->pd_usb_attached = true;
7473 dev_info(battery->dev, "%s: CCIC_NOTIFY_ID_USB: %d\n",__func__, battery->pd_usb_attached);
7474 wake_lock(&battery->monitor_wake_lock);
7475 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7476 mutex_unlock(&battery->typec_notylock);
7477 return 0;
7478 default:
7479 cmd = "ERROR";
7480 cable_type = -1;
7481 battery->muic_cable_type = ATTACHED_DEV_NONE_MUIC;
7482 #if defined(CONFIG_AFC_CHARGER_MODE)
7483 battery->hv_chg_name = "NONE";
7484 #endif
7485 break;
7486 }
7487
7488 skip_cable_check:
7489 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE,
7490 (battery->muic_cable_type != ATTACHED_DEV_UNDEFINED_CHARGING_MUIC) &&
7491 (battery->muic_cable_type != ATTACHED_DEV_UNDEFINED_RANGE_MUIC));
7492
7493 /* showing charging icon and noti(no sound, vi, haptic) only
7494 if slow insertion is detected by MUIC */
7495 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_TIMEOUT_OPEN_TYPE,
7496 (battery->muic_cable_type != ATTACHED_DEV_TIMEOUT_OPEN_MUIC));
7497
7498 if (cable_type < 0 || cable_type > SEC_BATTERY_CABLE_MAX) {
7499 dev_info(battery->dev, "%s: ignore event(%d)\n",
7500 __func__, battery->muic_cable_type);
7501 goto skip_cable_work;
7502 } else if ((cable_type == SEC_BATTERY_CABLE_UNKNOWN) &&
7503 (battery->status != POWER_SUPPLY_STATUS_DISCHARGING)) {
7504 battery->cable_type = cable_type;
7505 wake_lock(&battery->monitor_wake_lock);
7506 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7507 dev_info(battery->dev, "%s: UNKNOWN cable plugin\n", __func__);
7508 goto skip_cable_work;
7509 }
7510 battery->wire_status = cable_type;
7511
7512 cancel_delayed_work(&battery->cable_work);
7513 wake_unlock(&battery->cable_wake_lock);
7514
7515 if (cable_type == SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT) {
7516 /* set current event */
7517 cancel_delayed_work(&battery->afc_work);
7518 wake_unlock(&battery->afc_wake_lock);
7519 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_CHG_LIMIT,
7520 (SEC_BAT_CURRENT_EVENT_CHG_LIMIT | SEC_BAT_CURRENT_EVENT_AFC));
7521 wake_lock(&battery->monitor_wake_lock);
7522 battery->polling_count = 1; /* initial value = 1 */
7523 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7524 } else if ((battery->wire_status == battery->cable_type) &&
7525 (((battery->wire_status == SEC_BATTERY_CABLE_USB || battery->wire_status == SEC_BATTERY_CABLE_TA) &&
7526 battery->pdic_info.sink_status.rp_currentlvl > RP_CURRENT_LEVEL_DEFAULT) ||
7527 is_hv_wire_type(battery->wire_status))) {
7528 cancel_delayed_work(&battery->afc_work);
7529 wake_unlock(&battery->afc_wake_lock);
7530 sec_bat_set_current_event(battery, 0, SEC_BAT_CURRENT_EVENT_AFC);
7531
7532 wake_lock(&battery->monitor_wake_lock);
7533 battery->polling_count = 1; /* initial value = 1 */
7534 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7535 } else if (cable_type == SEC_BATTERY_CABLE_PREPARE_TA) {
7536 wake_lock(&battery->cable_wake_lock);
7537 queue_delayed_work(battery->monitor_wqueue,
7538 &battery->cable_work, msecs_to_jiffies(500));
7539 } else {
7540 wake_lock(&battery->cable_wake_lock);
7541 queue_delayed_work(battery->monitor_wqueue,
7542 &battery->cable_work, 0);
7543 }
7544
7545 skip_cable_work:
7546 dev_info(battery->dev, "%s: CMD[%s], CABLE_TYPE[%d]\n", __func__, cmd, cable_type);
7547 mutex_unlock(&battery->typec_notylock);
7548 return 0;
7549 }
7550 #else
7551 #if defined(CONFIG_CCIC_NOTIFIER)
7552 static int batt_pdic_handle_notification(struct notifier_block *nb,
7553 unsigned long action, void *data)
7554 {
7555 const char *cmd;
7556 struct sec_battery_info *battery =
7557 container_of(nb, struct sec_battery_info,
7558 pdic_nb);
7559 battery->pdic_info = *(struct pdic_notifier_struct *)data;
7560
7561 mutex_lock(&battery->batt_handlelock);
7562 pr_info("%s: pdic_event: %d\n", __func__, battery->pdic_info.event);
7563
7564 switch (battery->pdic_info.event) {
7565 int i, selected_pdo;
7566
7567 case PDIC_NOTIFY_EVENT_DETACH:
7568 cmd = "DETACH";
7569 battery->pdic_attach = false;
7570 if (battery->wire_status == SEC_BATTERY_CABLE_PDIC) {
7571 battery->wire_status = SEC_BATTERY_CABLE_NONE;
7572 wake_lock(&battery->cable_wake_lock);
7573 queue_delayed_work(battery->monitor_wqueue,
7574 &battery->cable_work, 0);
7575 }
7576 break;
7577 case PDIC_NOTIFY_EVENT_CCIC_ATTACH:
7578 cmd = "ATTACH";
7579 break;
7580 case PDIC_NOTIFY_EVENT_PD_SINK:
7581 selected_pdo = battery->pdic_info.sink_status.selected_pdo_num;
7582 cmd = "ATTACH";
7583 battery->wire_status = SEC_BATTERY_CABLE_PDIC;
7584 battery->pdic_attach = true;
7585 battery->input_voltage =
7586 battery->pdic_info.sink_status.power_list[selected_pdo].max_voltage / 1000;
7587
7588 pr_info("%s: total pdo : %d, selected pdo : %d\n", __func__,
7589 battery->pdic_info.sink_status.available_pdo_num, selected_pdo);
7590 for(i=1; i<= battery->pdic_info.sink_status.available_pdo_num; i++)
7591 {
7592 pr_info("%s: power_list[%d], voltage : %d, current : %d, power : %d\n", __func__, i,
7593 battery->pdic_info.sink_status.power_list[i].max_voltage,
7594 battery->pdic_info.sink_status.power_list[i].max_current,
7595 battery->pdic_info.sink_status.power_list[i].max_voltage *
7596 battery->pdic_info.sink_status.power_list[i].max_current);
7597 }
7598 wake_lock(&battery->cable_wake_lock);
7599 queue_delayed_work(battery->monitor_wqueue,
7600 &battery->cable_work, 0);
7601 break;
7602 case PDIC_NOTIFY_EVENT_PD_SOURCE:
7603 cmd = "ATTACH";
7604 break;
7605 default:
7606 cmd = "ERROR";
7607 break;
7608 }
7609 pr_info("%s: CMD=%s, cable_type : %d\n", __func__, cmd, battery->cable_type);
7610 mutex_unlock(&battery->batt_handlelock);
7611 return 0;
7612 }
7613 #endif
7614
7615 #if defined(CONFIG_MUIC_NOTIFIER)
7616 static int batt_handle_notification(struct notifier_block *nb,
7617 unsigned long action, void *data)
7618 {
7619 const char *cmd;
7620 int cable_type = SEC_BATTERY_CABLE_NONE;
7621 struct sec_battery_info *battery =
7622 container_of(nb, struct sec_battery_info,
7623 batt_nb);
7624 union power_supply_propval value = {0, };
7625
7626 #if defined(CONFIG_CCIC_NOTIFIER)
7627 CC_NOTI_ATTACH_TYPEDEF *p_noti = (CC_NOTI_ATTACH_TYPEDEF *)data;
7628 muic_attached_dev_t attached_dev = p_noti->cable_type;
7629 #else
7630 muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)data;
7631 #endif
7632
7633 mutex_lock(&battery->batt_handlelock);
7634 switch (action) {
7635 case MUIC_NOTIFY_CMD_DETACH:
7636 case MUIC_NOTIFY_CMD_LOGICALLY_DETACH:
7637 cmd = "DETACH";
7638 battery->is_jig_on = false;
7639 cable_type = SEC_BATTERY_CABLE_NONE;
7640 battery->muic_cable_type = ATTACHED_DEV_NONE_MUIC;
7641 break;
7642 case MUIC_NOTIFY_CMD_ATTACH:
7643 case MUIC_NOTIFY_CMD_LOGICALLY_ATTACH:
7644 cmd = "ATTACH";
7645 cable_type = sec_bat_cable_check(battery, attached_dev);
7646 battery->muic_cable_type = attached_dev;
7647 break;
7648 default:
7649 cmd = "ERROR";
7650 cable_type = -1;
7651 battery->muic_cable_type = ATTACHED_DEV_NONE_MUIC;
7652 break;
7653 }
7654
7655 sec_bat_set_misc_event(battery, BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE,
7656 #if !defined(CONFIG_ENG_BATTERY_CONCEPT) && !defined(CONFIG_SEC_FACTORY)
7657 (battery->muic_cable_type != ATTACHED_DEV_JIG_UART_ON_MUIC) &&
7658 (battery->muic_cable_type != ATTACHED_DEV_JIG_USB_ON_MUIC) &&
7659 #endif
7660 (battery->muic_cable_type != ATTACHED_DEV_UNDEFINED_RANGE_MUIC));
7661
7662 #if defined(CONFIG_CCIC_NOTIFIER)
7663 /* If PD cable is already attached, return this function */
7664 if(battery->pdic_attach) {
7665 dev_info(battery->dev, "%s: ignore event pdic attached(%d)\n",
7666 __func__, battery->pdic_attach);
7667 mutex_unlock(&battery->batt_handlelock);
7668 return 0;
7669 }
7670 #endif
7671
7672 if (attached_dev == ATTACHED_DEV_MHL_MUIC) {
7673 mutex_unlock(&battery->batt_handlelock);
7674 return 0;
7675 }
7676
7677 if (cable_type < 0) {
7678 dev_info(battery->dev, "%s: ignore event(%d)\n",
7679 __func__, cable_type);
7680 } else if (cable_type == SEC_BATTERY_CABLE_POWER_SHARING) {
7681 battery->ps_status = true;
7682 battery->ps_enable = true;
7683 battery->wire_status = cable_type;
7684 dev_info(battery->dev, "%s: power sharing cable plugin\n", __func__);
7685 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS) {
7686 battery->wc_status = SEC_WIRELESS_PAD_WPC;
7687 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_PACK) {
7688 battery->wc_status = SEC_WIRELESS_PAD_WPC_PACK;
7689 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_PACK) {
7690 battery->wc_status = SEC_WIRELESS_PAD_WPC_PACK_HV;
7691 } else if (cable_type == SEC_BATTERY_CABLE_HV_WIRELESS) {
7692 battery->wc_status = SEC_WIRELESS_PAD_WPC_HV;
7693 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND) {
7694 battery->wc_status = SEC_WIRELESS_PAD_WPC_STAND;
7695 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_STAND) {
7696 battery->wc_status = SEC_WIRELESS_PAD_WPC_STAND_HV;
7697 } else if (cable_type == SEC_BATTERY_CABLE_PMA_WIRELESS) {
7698 battery->wc_status = SEC_WIRELESS_PAD_PMA;
7699 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_VEHICLE) {
7700 battery->wc_status = SEC_WIRELESS_PAD_VEHICLE;
7701 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_VEHICLE) {
7702 battery->wc_status = SEC_WIRELESS_PAD_VEHICLE_HV;
7703 } else if (cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) {
7704 battery->wc_status = SEC_WIRELESS_PAD_TX;
7705 } else if ((cable_type == SEC_BATTERY_CABLE_UNKNOWN) &&
7706 (battery->status != POWER_SUPPLY_STATUS_DISCHARGING)) {
7707 battery->cable_type = cable_type;
7708 wake_lock(&battery->monitor_wake_lock);
7709 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7710 dev_info(battery->dev,
7711 "%s: UNKNOWN cable plugin\n", __func__);
7712 mutex_unlock(&battery->batt_handlelock);
7713 return 0;
7714 } else {
7715 battery->wire_status = cable_type;
7716 if ((battery->wire_status == SEC_BATTERY_CABLE_NONE) &&
7717 (battery->wc_status) && (!battery->ps_status))
7718 cable_type = SEC_BATTERY_CABLE_WIRELESS;
7719 }
7720 dev_info(battery->dev,
7721 "%s: current_cable(%d), wc_status(%d), wire_status(%d)\n",
7722 __func__, cable_type, battery->wc_status,
7723 battery->wire_status);
7724
7725 mutex_unlock(&battery->batt_handlelock);
7726 if (attached_dev == ATTACHED_DEV_USB_LANHUB_MUIC) {
7727 if (!strcmp(cmd, "ATTACH")) {
7728 value.intval = true;
7729 psy_do_property(battery->pdata->charger_name, set,
7730 POWER_SUPPLY_PROP_CHARGE_POWERED_OTG_CONTROL,
7731 value);
7732 dev_info(battery->dev,
7733 "%s: Powered OTG cable attached\n", __func__);
7734 } else {
7735 value.intval = false;
7736 psy_do_property(battery->pdata->charger_name, set,
7737 POWER_SUPPLY_PROP_CHARGE_POWERED_OTG_CONTROL,
7738 value);
7739 dev_info(battery->dev,
7740 "%s: Powered OTG cable detached\n", __func__);
7741 }
7742 }
7743
7744 #if defined(CONFIG_AFC_CHARGER_MODE)
7745 if (!strcmp(cmd, "ATTACH")) {
7746 if ((battery->muic_cable_type >= ATTACHED_DEV_QC_CHARGER_PREPARE_MUIC) &&
7747 (battery->muic_cable_type <= ATTACHED_DEV_QC_CHARGER_9V_MUIC)) {
7748 battery->hv_chg_name = "QC";
7749 } else if ((battery->muic_cable_type >= ATTACHED_DEV_AFC_CHARGER_PREPARE_MUIC) &&
7750 (battery->muic_cable_type <= ATTACHED_DEV_AFC_CHARGER_ERR_V_DUPLI_MUIC)) {
7751 battery->hv_chg_name = "AFC";
7752 #if defined(CONFIG_MUIC_HV_12V)
7753 } else if (battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_12V_MUIC ||
7754 battery->muic_cable_type == ATTACHED_DEV_AFC_CHARGER_12V_DUPLI_MUIC) {
7755 battery->hv_chg_name = "12V";
7756 #endif
7757 } else
7758 battery->hv_chg_name = "NONE";
7759 } else {
7760 battery->hv_chg_name = "NONE";
7761 }
7762
7763 pr_info("%s : HV_CHARGER_NAME(%s)\n",
7764 __func__, battery->hv_chg_name);
7765 #endif
7766
7767 if ((cable_type >= 0) &&
7768 cable_type <= SEC_BATTERY_CABLE_MAX) {
7769 if (cable_type == SEC_BATTERY_CABLE_POWER_SHARING) {
7770 value.intval = battery->ps_enable;
7771 psy_do_property(battery->pdata->charger_name, set,
7772 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
7773 wake_lock(&battery->monitor_wake_lock);
7774 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7775 } else if((cable_type == SEC_BATTERY_CABLE_NONE) && (battery->ps_status)) {
7776 if (battery->ps_enable) {
7777 battery->ps_enable = false;
7778 value.intval = battery->ps_enable;
7779 psy_do_property(battery->pdata->charger_name, set,
7780 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, value);
7781 }
7782 battery->ps_status = false;
7783 wake_lock(&battery->monitor_wake_lock);
7784 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
7785 } else if(cable_type != battery->cable_type) {
7786 wake_lock(&battery->cable_wake_lock);
7787 queue_delayed_work(battery->monitor_wqueue,
7788 &battery->cable_work, 0);
7789 } else {
7790 dev_info(battery->dev,
7791 "%s: Cable is Not Changed(%d)\n",
7792 __func__, battery->cable_type);
7793 }
7794 }
7795
7796 pr_info("%s: CMD=%s, attached_dev=%d\n", __func__, cmd, attached_dev);
7797
7798 return 0;
7799 }
7800 #endif /* CONFIG_MUIC_NOTIFIER */
7801 #endif
7802
7803 #if defined(CONFIG_VBUS_NOTIFIER)
7804 static int vbus_handle_notification(struct notifier_block *nb,
7805 unsigned long action, void *data)
7806 {
7807 vbus_status_t vbus_status = *(vbus_status_t *)data;
7808 struct sec_battery_info *battery =
7809 container_of(nb, struct sec_battery_info,
7810 vbus_nb);
7811 union power_supply_propval value = {0, };
7812
7813 mutex_lock(&battery->batt_handlelock);
7814 if (battery->muic_cable_type == ATTACHED_DEV_HMT_MUIC &&
7815 battery->muic_vbus_status != vbus_status &&
7816 battery->muic_vbus_status == STATUS_VBUS_HIGH &&
7817 vbus_status == STATUS_VBUS_LOW) {
7818 msleep(500);
7819 value.intval = true;
7820 psy_do_property(battery->pdata->charger_name, set,
7821 POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
7822 value);
7823 dev_info(battery->dev,
7824 "%s: changed to OTG cable attached\n", __func__);
7825
7826 battery->wire_status = SEC_BATTERY_CABLE_OTG;
7827 wake_lock(&battery->cable_wake_lock);
7828 queue_delayed_work(battery->monitor_wqueue, &battery->cable_work, 0);
7829 }
7830 pr_info("%s: action=%d, vbus_status=%d\n", __func__, (int)action, vbus_status);
7831 mutex_unlock(&battery->batt_handlelock);
7832 battery->muic_vbus_status = vbus_status;
7833
7834 return 0;
7835 }
7836 #endif
7837
7838 #ifdef CONFIG_OF
7839 static int sec_bat_parse_dt(struct device *dev,
7840 struct sec_battery_info *battery)
7841 {
7842 struct device_node *np;
7843 sec_battery_platform_data_t *pdata = battery->pdata;
7844 int ret = 0, len = 0;
7845 unsigned int i = 0;
7846 const u32 *p;
7847 u32 temp = 0;
7848
7849 np = of_find_node_by_name(NULL, "cable-info");
7850 if (!np) {
7851 pr_err ("%s : np NULL\n", __func__);
7852 } else {
7853 struct device_node *child;
7854 u32 input_current = 0, charging_current = 0;
7855
7856 ret = of_property_read_u32(np, "default_input_current", &input_current);
7857 ret = of_property_read_u32(np, "default_charging_current", &charging_current);
7858 ret = of_property_read_u32(np, "full_check_current_1st", &pdata->full_check_current_1st);
7859 ret = of_property_read_u32(np, "full_check_current_2nd", &pdata->full_check_current_2nd);
7860
7861 pdata->default_input_current = input_current;
7862 pdata->default_charging_current = charging_current;
7863
7864 pdata->charging_current =
7865 kzalloc(sizeof(sec_charging_current_t) * SEC_BATTERY_CABLE_MAX,
7866 GFP_KERNEL);
7867
7868 for (i = 0; i < SEC_BATTERY_CABLE_MAX; i++) {
7869 pdata->charging_current[i].input_current_limit = (unsigned int)input_current;
7870 pdata->charging_current[i].fast_charging_current = (unsigned int)charging_current;
7871 }
7872
7873 for_each_child_of_node(np, child) {
7874 ret = of_property_read_u32(child, "input_current", &input_current);
7875 ret = of_property_read_u32(child, "charging_current", &charging_current);
7876
7877 p = of_get_property(child, "cable_number", &len);
7878 if (!p)
7879 return 1;
7880
7881 len = len / sizeof(u32);
7882
7883 for (i = 0; i <= len; i++) {
7884 ret = of_property_read_u32_index(child, "cable_number", i, &temp);
7885 pdata->charging_current[temp].input_current_limit = (unsigned int)input_current;
7886 pdata->charging_current[temp].fast_charging_current = (unsigned int)charging_current;
7887 }
7888
7889 }
7890 }
7891
7892 for (i = 0; i < SEC_BATTERY_CABLE_MAX; i++) {
7893 pr_info("%s : CABLE_NUM(%d) INPUT(%d) CHARGING(%d)\n",
7894 __func__, i,
7895 pdata->charging_current[i].input_current_limit,
7896 pdata->charging_current[i].fast_charging_current);
7897 }
7898
7899 pr_info("%s : TOPOFF_1ST(%d), TOPOFF_2ND(%d)\n",
7900 __func__, pdata->full_check_current_1st, pdata->full_check_current_2nd);
7901 #ifdef CONFIG_SEC_FACTORY
7902 pdata->default_charging_current = 1500;
7903 pdata->charging_current[SEC_BATTERY_CABLE_TA].fast_charging_current = 1500;
7904 #endif
7905 np = of_find_node_by_name(NULL, "battery");
7906 if (!np) {
7907 pr_info("%s: np NULL\n", __func__);
7908 return 1;
7909 }
7910
7911 #if defined(CONFIG_BATTERY_CISD)
7912 ret = of_property_read_u32(np, "battery,battery_full_capacity",
7913 &pdata->battery_full_capacity);
7914 if (ret) {
7915 pr_info("%s : battery_full_capacity is Empty\n", __func__);
7916 } else {
7917 pr_info("%s : battery_full_capacity : %d\n", __func__, pdata->battery_full_capacity);
7918 pdata->cisd_cap_high_thr = pdata->battery_full_capacity + 1000;
7919 pdata->cisd_cap_low_thr = pdata->battery_full_capacity + 500;
7920 pdata->cisd_cap_limit = (pdata->battery_full_capacity * 11) / 10;
7921 }
7922
7923 ret = of_property_read_u32(np, "battery,cisd_max_voltage_thr",
7924 &pdata->max_voltage_thr);
7925 if (ret) {
7926 pr_info("%s : cisd_max_voltage_thr is Empty\n", __func__);
7927 pdata->max_voltage_thr = 4400;
7928 }
7929
7930 ret = of_property_read_u32(np, "battery,cisd_alg_index",
7931 &pdata->cisd_alg_index);
7932 if (ret) {
7933 pr_info("%s : cisd_alg_index is Empty. Defalut set to six\n", __func__);
7934 pdata->cisd_alg_index = 6;
7935 } else {
7936 pr_info("%s : set cisd_alg_index : %d\n", __func__, pdata->cisd_alg_index);
7937 }
7938 #endif
7939
7940 ret = of_property_read_u32(np,
7941 "battery,expired_time", &temp);
7942 if (ret) {
7943 pr_info("expired time is empty\n");
7944 pdata->expired_time = 3 * 60 * 60;
7945 } else {
7946 pdata->expired_time = (unsigned int) temp;
7947 }
7948 pdata->expired_time *= 1000;
7949 battery->expired_time = pdata->expired_time;
7950
7951 ret = of_property_read_u32(np,
7952 "battery,recharging_expired_time", &temp);
7953 if (ret) {
7954 pr_info("expired time is empty\n");
7955 pdata->recharging_expired_time = 90 * 60;
7956 } else {
7957 pdata->recharging_expired_time = (unsigned int) temp;
7958 }
7959 pdata->recharging_expired_time *= 1000;
7960
7961 ret = of_property_read_u32(np,
7962 "battery,standard_curr", &pdata->standard_curr);
7963 if (ret) {
7964 pr_info("standard_curr is empty\n");
7965 pdata->standard_curr = 2150;
7966 }
7967
7968 ret = of_property_read_string(np,
7969 "battery,vendor", (char const **)&pdata->vendor);
7970 if (ret)
7971 pr_info("%s: Vendor is Empty\n", __func__);
7972
7973 ret = of_property_read_string(np,
7974 "battery,charger_name", (char const **)&pdata->charger_name);
7975 if (ret)
7976 pr_info("%s: Charger name is Empty\n", __func__);
7977
7978 ret = of_property_read_string(np,
7979 "battery,fuelgauge_name", (char const **)&pdata->fuelgauge_name);
7980 if (ret)
7981 pr_info("%s: Fuelgauge name is Empty\n", __func__);
7982
7983 ret = of_property_read_string(np,
7984 "battery,wireless_charger_name", (char const **)&pdata->wireless_charger_name);
7985 if (ret)
7986 pr_info("%s: Wireless charger name is Empty\n", __func__);
7987
7988 ret = of_property_read_string(np,
7989 "battery,fgsrc_switch_name", (char const **)&pdata->fgsrc_switch_name);
7990 if (ret) {
7991 pdata->support_fgsrc_change = false;
7992 pr_info("%s: fgsrc_switch_name is Empty\n", __func__);
7993 }
7994 else
7995 pdata->support_fgsrc_change = true;
7996
7997 ret = of_property_read_string(np,
7998 "battery,wireless_charger_name", (char const **)&pdata->wireless_charger_name);
7999 if (ret)
8000 pr_info("%s: Wireless charger name is Empty\n", __func__);
8001
8002 ret = of_property_read_string(np,
8003 "battery,chip_vendor", (char const **)&pdata->chip_vendor);
8004 if (ret)
8005 pr_info("%s: Chip vendor is Empty\n", __func__);
8006
8007 ret = of_property_read_u32(np, "battery,technology",
8008 &pdata->technology);
8009 if (ret)
8010 pr_info("%s : technology is Empty\n", __func__);
8011
8012 ret = of_property_read_u32(np,
8013 "battery,wireless_cc_cv", &pdata->wireless_cc_cv);
8014
8015 ret = of_property_read_u32(np,
8016 "battery,set_cv_vout_in_low_capacity", &pdata->set_cv_vout_in_low_capacity);
8017
8018 pdata->fake_capacity = of_property_read_bool(np,
8019 "battery,fake_capacity");
8020
8021 p = of_get_property(np, "battery,polling_time", &len);
8022 if (!p)
8023 return 1;
8024
8025 len = len / sizeof(u32);
8026 pdata->polling_time = kzalloc(sizeof(*pdata->polling_time) * len, GFP_KERNEL);
8027 ret = of_property_read_u32_array(np, "battery,polling_time",
8028 pdata->polling_time, len);
8029 if (ret)
8030 pr_info("%s : battery,polling_time is Empty\n", __func__);
8031
8032 ret = of_property_read_u32(np, "battery,thermal_source",
8033 &pdata->thermal_source);
8034 if (ret)
8035 pr_info("%s : Thermal source is Empty\n", __func__);
8036
8037 if (pdata->thermal_source == SEC_BATTERY_THERMAL_SOURCE_ADC) {
8038 p = of_get_property(np, "battery,temp_table_adc", &len);
8039 if (!p)
8040 return 1;
8041
8042 len = len / sizeof(u32);
8043
8044 pdata->temp_adc_table_size = len;
8045 pdata->temp_amb_adc_table_size = len;
8046
8047 pdata->temp_adc_table =
8048 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8049 pdata->temp_adc_table_size, GFP_KERNEL);
8050 pdata->temp_amb_adc_table =
8051 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8052 pdata->temp_adc_table_size, GFP_KERNEL);
8053
8054 for(i = 0; i < pdata->temp_adc_table_size; i++) {
8055 ret = of_property_read_u32_index(np,
8056 "battery,temp_table_adc", i, &temp);
8057 pdata->temp_adc_table[i].adc = (int)temp;
8058 if (ret)
8059 pr_info("%s : Temp_adc_table(adc) is Empty\n",
8060 __func__);
8061
8062 ret = of_property_read_u32_index(np,
8063 "battery,temp_table_data", i, &temp);
8064 pdata->temp_adc_table[i].data = (int)temp;
8065 if (ret)
8066 pr_info("%s : Temp_adc_table(data) is Empty\n",
8067 __func__);
8068
8069 ret = of_property_read_u32_index(np,
8070 "battery,temp_table_adc", i, &temp);
8071 pdata->temp_amb_adc_table[i].adc = (int)temp;
8072 if (ret)
8073 pr_info("%s : Temp_amb_adc_table(adc) is Empty\n",
8074 __func__);
8075
8076 ret = of_property_read_u32_index(np,
8077 "battery,temp_table_data", i, &temp);
8078 pdata->temp_amb_adc_table[i].data = (int)temp;
8079 if (ret)
8080 pr_info("%s : Temp_amb_adc_table(data) is Empty\n",
8081 __func__);
8082 }
8083 }
8084 ret = of_property_read_u32(np, "battery,usb_thermal_source",
8085 &pdata->usb_thermal_source);
8086 if (ret)
8087 pr_info("%s : usb_thermal_source is Empty\n", __func__);
8088
8089 if(pdata->usb_thermal_source) {
8090 p = of_get_property(np, "battery,usb_temp_table_adc", &len);
8091 if (!p)
8092 return 1;
8093
8094 len = len / sizeof(u32);
8095
8096 pdata->usb_temp_adc_table_size = len;
8097
8098 pdata->usb_temp_adc_table =
8099 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8100 pdata->usb_temp_adc_table_size, GFP_KERNEL);
8101
8102 for(i = 0; i < pdata->usb_temp_adc_table_size; i++) {
8103 ret = of_property_read_u32_index(np,
8104 "battery,usb_temp_table_adc", i, &temp);
8105 pdata->usb_temp_adc_table[i].adc = (int)temp;
8106 if (ret)
8107 pr_info("%s : Usb_Temp_adc_table(adc) is Empty\n",
8108 __func__);
8109
8110 ret = of_property_read_u32_index(np,
8111 "battery,usb_temp_table_data", i, &temp);
8112 pdata->usb_temp_adc_table[i].data = (int)temp;
8113 if (ret)
8114 pr_info("%s : Usb_Temp_adc_table(data) is Empty\n",
8115 __func__);
8116 }
8117 }
8118
8119 ret = of_property_read_u32(np, "battery,chg_thermal_source",
8120 &pdata->chg_thermal_source);
8121 if (ret)
8122 pr_info("%s : chg_thermal_source is Empty\n", __func__);
8123
8124 if(pdata->chg_thermal_source) {
8125 p = of_get_property(np, "battery,chg_temp_table_adc", &len);
8126 if (!p)
8127 return 1;
8128
8129 len = len / sizeof(u32);
8130
8131 pdata->chg_temp_adc_table_size = len;
8132
8133 pdata->chg_temp_adc_table =
8134 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8135 pdata->chg_temp_adc_table_size, GFP_KERNEL);
8136
8137 for(i = 0; i < pdata->chg_temp_adc_table_size; i++) {
8138 ret = of_property_read_u32_index(np,
8139 "battery,chg_temp_table_adc", i, &temp);
8140 pdata->chg_temp_adc_table[i].adc = (int)temp;
8141 if (ret)
8142 pr_info("%s : CHG_Temp_adc_table(adc) is Empty\n",
8143 __func__);
8144
8145 ret = of_property_read_u32_index(np,
8146 "battery,chg_temp_table_data", i, &temp);
8147 pdata->chg_temp_adc_table[i].data = (int)temp;
8148 if (ret)
8149 pr_info("%s : CHG_Temp_adc_table(data) is Empty\n",
8150 __func__);
8151 }
8152 }
8153
8154 ret = of_property_read_u32(np, "battery,wpc_thermal_source",
8155 &pdata->wpc_thermal_source);
8156 if (ret)
8157 pr_info("%s : wpc_thermal_source is Empty\n", __func__);
8158
8159 if(pdata->wpc_thermal_source) {
8160 p = of_get_property(np, "battery,wpc_temp_table_adc", &len);
8161 if (!p) {
8162 pr_info("%s : wpc_temp_table_adc(adc) is Empty\n",__func__);
8163 } else {
8164 len = len / sizeof(u32);
8165
8166 pdata->wpc_temp_adc_table_size = len;
8167
8168 pdata->wpc_temp_adc_table =
8169 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8170 pdata->wpc_temp_adc_table_size, GFP_KERNEL);
8171
8172 for(i = 0; i < pdata->wpc_temp_adc_table_size; i++) {
8173 ret = of_property_read_u32_index(np,
8174 "battery,wpc_temp_table_adc", i, &temp);
8175 pdata->wpc_temp_adc_table[i].adc = (int)temp;
8176 if (ret)
8177 pr_info("%s : WPC_Temp_adc_table(adc) is Empty\n",
8178 __func__);
8179
8180 ret = of_property_read_u32_index(np,
8181 "battery,wpc_temp_table_data", i, &temp);
8182 pdata->wpc_temp_adc_table[i].data = (int)temp;
8183 if (ret)
8184 pr_info("%s : WPC_Temp_adc_table(data) is Empty\n",
8185 __func__);
8186 }
8187 }
8188 }
8189
8190 ret = of_property_read_u32(np, "battery,coil_thermal_source",
8191 &pdata->coil_thermal_source);
8192 if (ret)
8193 pr_info("%s : coil_thermal_source is Empty\n", __func__);
8194 else
8195 pr_info("%s : coil_thermal_source exists\n", __func__);
8196
8197 ret = of_property_read_u32(np, "battery,slave_thermal_source",
8198 &pdata->slave_thermal_source);
8199 if (ret)
8200 pr_info("%s : slave_thermal_source is Empty\n", __func__);
8201
8202 if(pdata->slave_thermal_source) {
8203 p = of_get_property(np, "battery,slave_chg_temp_table_adc", &len);
8204 if (!p)
8205 return 1;
8206
8207 len = len / sizeof(u32);
8208
8209 pdata->slave_chg_temp_adc_table_size = len;
8210
8211 pdata->slave_chg_temp_adc_table =
8212 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8213 pdata->slave_chg_temp_adc_table_size, GFP_KERNEL);
8214
8215 for(i = 0; i < pdata->slave_chg_temp_adc_table_size; i++) {
8216 ret = of_property_read_u32_index(np,
8217 "battery,slave_chg_temp_table_adc", i, &temp);
8218 pdata->slave_chg_temp_adc_table[i].adc = (int)temp;
8219 if (ret)
8220 pr_info("%s : slave_chg_temp_adc_table(adc) is Empty\n",
8221 __func__);
8222
8223 ret = of_property_read_u32_index(np,
8224 "battery,slave_chg_temp_table_data", i, &temp);
8225 pdata->slave_chg_temp_adc_table[i].data = (int)temp;
8226 if (ret)
8227 pr_info("%s : slave_chg_temp_adc_table(data) is Empty\n",
8228 __func__);
8229 }
8230 }
8231 ret = of_property_read_u32(np, "battery,slave_chg_temp_check",
8232 &pdata->slave_chg_temp_check);
8233 if (ret)
8234 pr_info("%s : slave_chg_temp_check is Empty\n", __func__);
8235
8236 ret = of_property_read_u32(np, "battery,chg_temp_check",
8237 &pdata->chg_temp_check);
8238 if (ret)
8239 pr_info("%s : chg_temp_check is Empty\n", __func__);
8240
8241 if (pdata->chg_temp_check) {
8242 ret = of_property_read_u32(np, "battery,chg_12v_high_temp",
8243 &temp);
8244 pdata->chg_12v_high_temp = (int)temp;
8245 if (ret)
8246 pr_info("%s : chg_12v_high_temp is Empty\n", __func__);
8247
8248 ret = of_property_read_u32(np, "battery,chg_high_temp",
8249 &temp);
8250 pdata->chg_high_temp = (int)temp;
8251 if (ret)
8252 pr_info("%s : chg_high_temp is Empty\n", __func__);
8253
8254 ret = of_property_read_u32(np, "battery,chg_high_temp_recovery",
8255 &temp);
8256 pdata->chg_high_temp_recovery = (int)temp;
8257 if (ret)
8258 pr_info("%s : chg_temp_recovery is Empty\n", __func__);
8259
8260 ret = of_property_read_u32(np, "battery,chg_charging_limit_current",
8261 &pdata->chg_charging_limit_current);
8262 if (ret)
8263 pr_info("%s : chg_charging_limit_current is Empty\n", __func__);
8264
8265 ret = of_property_read_u32(np, "battery,chg_input_limit_current",
8266 &pdata->chg_input_limit_current);
8267 if (ret)
8268 pr_info("%s : chg_input_limit_current is Empty\n", __func__);
8269
8270 ret = of_property_read_u32(np, "battery,mix_high_temp",
8271 &temp);
8272 pdata->mix_high_temp = (int)temp;
8273 if (ret)
8274 pr_info("%s : mix_high_temp is Empty\n", __func__);
8275
8276 ret = of_property_read_u32(np, "battery,mix_high_chg_temp",
8277 &temp);
8278 pdata->mix_high_chg_temp = (int)temp;
8279 if (ret)
8280 pr_info("%s : mix_high_chg_temp is Empty\n", __func__);
8281
8282 ret = of_property_read_u32(np, "battery,mix_high_temp_recovery",
8283 &temp);
8284 pdata->mix_high_temp_recovery = (int)temp;
8285 if (ret)
8286 pr_info("%s : mix_high_temp_recovery is Empty\n", __func__);
8287 }
8288
8289 ret = of_property_read_u32(np, "battery,wpc_temp_check",
8290 &pdata->wpc_temp_check);
8291 if (ret)
8292 pr_info("%s : wpc_temp_check is Empty\n", __func__);
8293
8294 if (pdata->wpc_temp_check) {
8295 ret = of_property_read_u32(np, "battery,wpc_temp_control_source",
8296 &pdata->wpc_temp_control_source);
8297 if (ret) {
8298 pr_info("%s : wpc_temp_control_source is Empty\n", __func__);
8299 pdata->wpc_temp_control_source = TEMP_CONTROL_SOURCE_CHG_THM;
8300 }
8301
8302 ret = of_property_read_u32(np, "battery,wpc_temp_lcd_on_control_source",
8303 &pdata->wpc_temp_lcd_on_control_source);
8304 if (ret) {
8305 pr_info("%s : wpc_temp_lcd_on_control_source is Empty\n", __func__);
8306 pdata->wpc_temp_lcd_on_control_source = TEMP_CONTROL_SOURCE_CHG_THM;
8307 }
8308
8309 ret = of_property_read_u32(np, "battery,wpc_high_temp",
8310 &pdata->wpc_high_temp);
8311 if (ret)
8312 pr_info("%s : wpc_high_temp is Empty\n", __func__);
8313
8314 ret = of_property_read_u32(np, "battery,wpc_high_temp_recovery",
8315 &pdata->wpc_high_temp_recovery);
8316 if (ret)
8317 pr_info("%s : wpc_high_temp_recovery is Empty\n", __func__);
8318
8319 ret = of_property_read_u32(np, "battery,wpc_charging_limit_current",
8320 &pdata->wpc_charging_limit_current);
8321 if (ret)
8322 pr_info("%s : wpc_charging_limit_current is Empty\n", __func__);
8323
8324 ret = of_property_read_u32(np, "battery,wpc_lcd_on_high_temp",
8325 &pdata->wpc_lcd_on_high_temp);
8326 if (ret)
8327 pr_info("%s : wpc_lcd_on_high_temp is Empty\n", __func__);
8328
8329 ret = of_property_read_u32(np, "battery,wpc_lcd_on_high_temp_rec",
8330 &pdata->wpc_lcd_on_high_temp_rec);
8331 if (ret)
8332 pr_info("%s : wpc_lcd_on_high_temp_rec is Empty\n", __func__);
8333
8334 ret = of_property_read_u32(np, "battery,wpc_lcd_on_charging_limit_current",
8335 &pdata->wpc_lcd_on_charging_limit_current);
8336 if (ret) {
8337 pr_info("%s : wpc_lcd_on_charging_limit_current is Empty\n", __func__);
8338 pdata->wpc_lcd_on_charging_limit_current =
8339 pdata->wpc_charging_limit_current;
8340 }
8341 }
8342
8343 ret = of_property_read_u32(np, "battery,wc_full_input_limit_current",
8344 &pdata->wc_full_input_limit_current);
8345 if (ret)
8346 pr_info("%s : wc_full_input_limit_current is Empty\n", __func__);
8347
8348 ret = of_property_read_u32(np, "battery,wc_cv_current",
8349 &pdata->wc_cv_current);
8350 if (ret) {
8351 pr_info("%s : wc_cv_current is Empty\n", __func__);
8352 pdata->wc_cv_current = 820;
8353 }
8354
8355 ret = of_property_read_u32(np, "battery,wc_cv_pack_current",
8356 &pdata->wc_cv_pack_current);
8357 if (ret) {
8358 pr_info("%s : wc_cv_pack_current is Empty\n", __func__);
8359 pdata->wc_cv_pack_current = 500;
8360 }
8361
8362 ret = of_property_read_u32(np, "battery,wc_hero_stand_cc_cv",
8363 &pdata->wc_hero_stand_cc_cv);
8364 if (ret) {
8365 pr_info("%s : wc_hero_stand_cc_cv is Empty\n", __func__);
8366 pdata->wc_hero_stand_cc_cv = 70;
8367 }
8368 ret = of_property_read_u32(np, "battery,wc_hero_stand_cv_current",
8369 &pdata->wc_hero_stand_cv_current);
8370 if (ret) {
8371 pr_info("%s : wc_hero_stand_cv_current is Empty\n", __func__);
8372 pdata->wc_hero_stand_cv_current = 600;
8373 }
8374 ret = of_property_read_u32(np, "battery,wc_hero_stand_hv_cv_current",
8375 &pdata->wc_hero_stand_hv_cv_current);
8376 if (ret) {
8377 pr_info("%s : wc_hero_stand_hv_cv_current is Empty\n", __func__);
8378 pdata->wc_hero_stand_hv_cv_current = 450;
8379 }
8380
8381 ret = of_property_read_u32(np, "battery,sleep_mode_limit_current",
8382 &pdata->sleep_mode_limit_current);
8383 if (ret)
8384 pr_info("%s : sleep_mode_limit_current is Empty\n", __func__);
8385
8386 ret = of_property_read_u32(np, "battery,inbat_voltage",
8387 &pdata->inbat_voltage);
8388 if (ret)
8389 pr_info("%s : inbat_voltage is Empty\n", __func__);
8390
8391 if (pdata->inbat_voltage) {
8392 p = of_get_property(np, "battery,inbat_voltage_table_adc", &len);
8393 if (!p)
8394 return 1;
8395
8396 len = len / sizeof(u32);
8397
8398 pdata->inbat_adc_table_size = len;
8399
8400 pdata->inbat_adc_table =
8401 kzalloc(sizeof(sec_bat_adc_table_data_t) *
8402 pdata->inbat_adc_table_size, GFP_KERNEL);
8403
8404 for(i = 0; i < pdata->inbat_adc_table_size; i++) {
8405 ret = of_property_read_u32_index(np,
8406 "battery,inbat_voltage_table_adc", i, &temp);
8407 pdata->inbat_adc_table[i].adc = (int)temp;
8408 if (ret)
8409 pr_info("%s : inbat_adc_table(adc) is Empty\n",
8410 __func__);
8411
8412 ret = of_property_read_u32_index(np,
8413 "battery,inbat_voltage_table_data", i, &temp);
8414 pdata->inbat_adc_table[i].data = (int)temp;
8415 if (ret)
8416 pr_info("%s : inbat_adc_table(data) is Empty\n",
8417 __func__);
8418 }
8419 }
8420
8421 ret = of_property_read_u32(np, "battery,pre_afc_input_current",
8422 &pdata->pre_afc_input_current);
8423 if (ret) {
8424 pr_info("%s : pre_afc_input_current is Empty\n", __func__);
8425 pdata->pre_afc_input_current = 1000;
8426 }
8427
8428 ret = of_property_read_u32(np, "battery,pre_afc_work_delay",
8429 &pdata->pre_afc_work_delay);
8430 if (ret) {
8431 pr_info("%s : pre_afc_work_delay is Empty\n", __func__);
8432 pdata->pre_afc_work_delay = 2000;
8433 }
8434
8435 ret = of_property_read_u32(np, "battery,pre_wc_afc_input_current",
8436 &pdata->pre_wc_afc_input_current);
8437 if (ret) {
8438 pr_info("%s : pre_wc_afc_input_current is Empty\n", __func__);
8439 pdata->pre_wc_afc_input_current = 500; /* wc input default */
8440 }
8441
8442 ret = of_property_read_u32(np, "battery,pre_wc_afc_work_delay",
8443 &pdata->pre_wc_afc_work_delay);
8444 if (ret) {
8445 pr_info("%s : pre_wc_afc_work_delay is Empty\n", __func__);
8446 pdata->pre_wc_afc_work_delay = 4000;
8447 }
8448
8449 ret = of_property_read_u32(np, "battery,adc_check_count",
8450 &pdata->adc_check_count);
8451 if (ret)
8452 pr_info("%s : Adc check count is Empty\n", __func__);
8453
8454 ret = of_property_read_u32(np, "battery,temp_adc_type",
8455 &pdata->temp_adc_type);
8456 if (ret)
8457 pr_info("%s : Temp adc type is Empty\n", __func__);
8458
8459 ret = of_property_read_u32(np, "battery,cable_check_type",
8460 &pdata->cable_check_type);
8461 if (ret)
8462 pr_info("%s : Cable check type is Empty\n", __func__);
8463
8464 ret = of_property_read_u32(np, "battery,cable_source_type",
8465 &pdata->cable_source_type);
8466 if (ret)
8467 pr_info("%s: Cable_source_type is Empty\n", __func__);
8468 ret = of_property_read_u32(np, "battery,polling_type",
8469 &pdata->polling_type);
8470 if (ret)
8471 pr_info("%s : Polling type is Empty\n", __func__);
8472
8473 ret = of_property_read_u32(np, "battery,monitor_initial_count",
8474 &pdata->monitor_initial_count);
8475 if (ret)
8476 pr_info("%s : Monitor initial count is Empty\n", __func__);
8477
8478 ret = of_property_read_u32(np, "battery,battery_check_type",
8479 &pdata->battery_check_type);
8480 if (ret)
8481 pr_info("%s : Battery check type is Empty\n", __func__);
8482
8483 ret = of_property_read_u32(np, "battery,check_count",
8484 &pdata->check_count);
8485 if (ret)
8486 pr_info("%s : Check count is Empty\n", __func__);
8487
8488 ret = of_property_read_u32(np, "battery,check_adc_max",
8489 &pdata->check_adc_max);
8490 if (ret)
8491 pr_info("%s : Check adc max is Empty\n", __func__);
8492
8493 ret = of_property_read_u32(np, "battery,check_adc_min",
8494 &pdata->check_adc_min);
8495 if (ret)
8496 pr_info("%s : Check adc min is Empty\n", __func__);
8497
8498 ret = of_property_read_u32(np, "battery,ovp_uvlo_check_type",
8499 &pdata->ovp_uvlo_check_type);
8500 if (ret)
8501 pr_info("%s : Ovp Uvlo check type is Empty\n", __func__);
8502
8503 ret = of_property_read_u32(np, "battery,temp_check_type",
8504 &pdata->temp_check_type);
8505 if (ret)
8506 pr_info("%s : Temp check type is Empty\n", __func__);
8507
8508 ret = of_property_read_u32(np, "battery,temp_check_count",
8509 &pdata->temp_check_count);
8510 if (ret)
8511 pr_info("%s : Temp check count is Empty\n", __func__);
8512
8513 ret = of_property_read_u32(np, "battery,temp_highlimit_threshold_normal",
8514 &temp);
8515 pdata->temp_highlimit_threshold_normal = (int)temp;
8516 if (ret)
8517 pr_info("%s : Temp highlimit threshold normal is Empty\n", __func__);
8518
8519 ret = of_property_read_u32(np, "battery,temp_highlimit_recovery_normal",
8520 &temp);
8521 pdata->temp_highlimit_recovery_normal = (int)temp;
8522 if (ret)
8523 pr_info("%s : Temp highlimit recovery normal is Empty\n", __func__);
8524
8525 ret = of_property_read_u32(np, "battery,temp_high_threshold_normal",
8526 &temp);
8527 pdata->temp_high_threshold_normal = (int)temp;
8528 if (ret)
8529 pr_info("%s : Temp high threshold normal is Empty\n", __func__);
8530
8531 ret = of_property_read_u32(np, "battery,temp_high_recovery_normal",
8532 &temp);
8533 pdata->temp_high_recovery_normal = (int)temp;
8534 if (ret)
8535 pr_info("%s : Temp high recovery normal is Empty\n", __func__);
8536
8537 ret = of_property_read_u32(np, "battery,temp_low_threshold_normal",
8538 &temp);
8539 pdata->temp_low_threshold_normal = (int)temp;
8540 if (ret)
8541 pr_info("%s : Temp low threshold normal is Empty\n", __func__);
8542
8543 ret = of_property_read_u32(np, "battery,temp_low_recovery_normal",
8544 &temp);
8545 pdata->temp_low_recovery_normal = (int)temp;
8546 if (ret)
8547 pr_info("%s : Temp low recovery normal is Empty\n", __func__);
8548
8549 ret = of_property_read_u32(np, "battery,temp_highlimit_threshold_lpm",
8550 &temp);
8551 pdata->temp_highlimit_threshold_lpm = (int)temp;
8552 if (ret)
8553 pr_info("%s : Temp highlimit threshold lpm is Empty\n", __func__);
8554
8555 ret = of_property_read_u32(np, "battery,temp_highlimit_recovery_lpm",
8556 &temp);
8557 pdata->temp_highlimit_recovery_lpm = (int)temp;
8558 if (ret)
8559 pr_info("%s : Temp highlimit recovery lpm is Empty\n", __func__);
8560
8561 ret = of_property_read_u32(np, "battery,temp_high_threshold_lpm",
8562 &temp);
8563 pdata->temp_high_threshold_lpm = (int)temp;
8564 if (ret)
8565 pr_info("%s : Temp high threshold lpm is Empty\n", __func__);
8566
8567 ret = of_property_read_u32(np, "battery,temp_high_recovery_lpm",
8568 &temp);
8569 pdata->temp_high_recovery_lpm = (int)temp;
8570 if (ret)
8571 pr_info("%s : Temp high recovery lpm is Empty\n", __func__);
8572
8573 ret = of_property_read_u32(np, "battery,temp_low_threshold_lpm",
8574 &temp);
8575 pdata->temp_low_threshold_lpm = (int)temp;
8576 if (ret)
8577 pr_info("%s : Temp low threshold lpm is Empty\n", __func__);
8578
8579 ret = of_property_read_u32(np, "battery,temp_low_recovery_lpm",
8580 &temp);
8581 pdata->temp_low_recovery_lpm = (int)temp;
8582 if (ret)
8583 pr_info("%s : Temp low recovery lpm is Empty\n", __func__);
8584
8585 pr_info("%s : HIGHLIMIT_THRESHOLD_NOLMAL(%d), HIGHLIMIT_RECOVERY_NORMAL(%d)\n"
8586 "HIGH_THRESHOLD_NORMAL(%d), HIGH_RECOVERY_NORMAL(%d) LOW_THRESHOLD_NORMAL(%d), LOW_RECOVERY_NORMAL(%d)\n"
8587 "HIGHLIMIT_THRESHOLD_LPM(%d), HIGHLIMIT_RECOVERY_LPM(%d)\n"
8588 "HIGH_THRESHOLD_LPM(%d), HIGH_RECOVERY_LPM(%d) LOW_THRESHOLD_LPM(%d), LOW_RECOVERY_LPM(%d)\n",
8589 __func__,
8590 pdata->temp_highlimit_threshold_normal, pdata->temp_highlimit_recovery_normal,
8591 pdata->temp_high_threshold_normal, pdata->temp_high_recovery_normal,
8592 pdata->temp_low_threshold_normal, pdata->temp_low_recovery_normal,
8593 pdata->temp_highlimit_threshold_lpm, pdata->temp_highlimit_recovery_lpm,
8594 pdata->temp_high_threshold_lpm, pdata->temp_high_recovery_lpm,
8595 pdata->temp_low_threshold_lpm, pdata->temp_low_recovery_lpm);
8596
8597 ret = of_property_read_u32(np, "battery,wpc_high_threshold_normal",
8598 &temp);
8599 pdata->wpc_high_threshold_normal = (int)temp;
8600 if (ret)
8601 pr_info("%s : wpc_high_threshold_normal is Empty\n", __func__);
8602
8603 ret = of_property_read_u32(np, "battery,wpc_high_recovery_normal",
8604 &temp);
8605 pdata->wpc_high_recovery_normal = (int)temp;
8606 if (ret)
8607 pr_info("%s : wpc_high_recovery_normal is Empty\n", __func__);
8608
8609 ret = of_property_read_u32(np, "battery,wpc_low_threshold_normal",
8610 &temp);
8611 pdata->wpc_low_threshold_normal = (int)temp;
8612 if (ret)
8613 pr_info("%s : wpc_low_threshold_normal is Empty\n", __func__);
8614
8615 ret = of_property_read_u32(np, "battery,wpc_low_recovery_normal",
8616 &temp);
8617 pdata->wpc_low_recovery_normal = (int)temp;
8618 if (ret)
8619 pr_info("%s : wpc_low_recovery_normal is Empty\n", __func__);
8620
8621 ret = of_property_read_u32(np, "battery,full_check_type",
8622 &pdata->full_check_type);
8623 if (ret)
8624 pr_info("%s : Full check type is Empty\n", __func__);
8625
8626 ret = of_property_read_u32(np, "battery,full_check_type_2nd",
8627 &pdata->full_check_type_2nd);
8628 if (ret)
8629 pr_info("%s : Full check type 2nd is Empty\n", __func__);
8630
8631 ret = of_property_read_u32(np, "battery,full_check_count",
8632 &pdata->full_check_count);
8633 if (ret)
8634 pr_info("%s : Full check count is Empty\n", __func__);
8635
8636 ret = of_property_read_u32(np, "battery,chg_gpio_full_check",
8637 &pdata->chg_gpio_full_check);
8638 if (ret)
8639 pr_info("%s : Chg gpio full check is Empty\n", __func__);
8640
8641 ret = of_property_read_u32(np, "battery,chg_polarity_full_check",
8642 &pdata->chg_polarity_full_check);
8643 if (ret)
8644 pr_info("%s : Chg polarity full check is Empty\n", __func__);
8645
8646 ret = of_property_read_u32(np, "battery,full_condition_type",
8647 &pdata->full_condition_type);
8648 if (ret)
8649 pr_info("%s : Full condition type is Empty\n", __func__);
8650
8651 ret = of_property_read_u32(np, "battery,full_condition_soc",
8652 &pdata->full_condition_soc);
8653 if (ret)
8654 pr_info("%s : Full condition soc is Empty\n", __func__);
8655
8656 ret = of_property_read_u32(np, "battery,full_condition_vcell",
8657 &pdata->full_condition_vcell);
8658 if (ret)
8659 pr_info("%s : Full condition vcell is Empty\n", __func__);
8660
8661 ret = of_property_read_u32(np, "battery,recharge_check_count",
8662 &pdata->recharge_check_count);
8663 if (ret)
8664 pr_info("%s : Recharge check count is Empty\n", __func__);
8665
8666 ret = of_property_read_u32(np, "battery,recharge_condition_type",
8667 &pdata->recharge_condition_type);
8668 if (ret)
8669 pr_info("%s : Recharge condition type is Empty\n", __func__);
8670
8671 ret = of_property_read_u32(np, "battery,recharge_condition_soc",
8672 &pdata->recharge_condition_soc);
8673 if (ret)
8674 pr_info("%s : Recharge condition soc is Empty\n", __func__);
8675
8676 ret = of_property_read_u32(np, "battery,recharge_condition_vcell",
8677 &pdata->recharge_condition_vcell);
8678 if (ret)
8679 pr_info("%s : Recharge condition vcell is Empty\n", __func__);
8680
8681 ret = of_property_read_u32(np, "battery,charging_total_time",
8682 (unsigned int *)&pdata->charging_total_time);
8683 if (ret)
8684 pr_info("%s : Charging total time is Empty\n", __func__);
8685
8686 ret = of_property_read_u32(np, "battery,hv_charging_total_time",
8687 &pdata->hv_charging_total_time);
8688 if (ret) {
8689 pdata->hv_charging_total_time = 3 * 60 * 60;
8690 pr_info("%s : HV Charging total time is %d\n",
8691 __func__, pdata->hv_charging_total_time);
8692 }
8693
8694 ret = of_property_read_u32(np, "battery,normal_charging_total_time",
8695 &pdata->normal_charging_total_time);
8696 if (ret) {
8697 pdata->normal_charging_total_time = 5 * 60 * 60;
8698 pr_info("%s : Normal(WC) Charging total time is %d\n",
8699 __func__, pdata->normal_charging_total_time);
8700 }
8701
8702 ret = of_property_read_u32(np, "battery,usb_charging_total_time",
8703 &pdata->usb_charging_total_time);
8704 if (ret) {
8705 pdata->usb_charging_total_time = 10 * 60 * 60;
8706 pr_info("%s : USB Charging total time is %d\n",
8707 __func__, pdata->usb_charging_total_time);
8708 }
8709
8710 ret = of_property_read_u32(np, "battery,recharging_total_time",
8711 (unsigned int *)&pdata->recharging_total_time);
8712 if (ret)
8713 pr_info("%s : Recharging total time is Empty\n", __func__);
8714
8715 ret = of_property_read_u32(np, "battery,charging_reset_time",
8716 (unsigned int *)&pdata->charging_reset_time);
8717 if (ret)
8718 pr_info("%s : Charging reset time is Empty\n", __func__);
8719
8720 ret = of_property_read_u32(np, "battery,charging_reset_time",
8721 (unsigned int *)&pdata->charging_reset_time);
8722 if (ret)
8723 pr_info("%s : Charging reset time is Empty\n", __func__);
8724
8725 ret = of_property_read_u32(np, "battery,chg_float_voltage",
8726 (unsigned int *)&pdata->chg_float_voltage);
8727 if (ret) {
8728 pr_info("%s: chg_float_voltage is Empty\n", __func__);
8729 pdata->chg_float_voltage = 43500;
8730 }
8731
8732 ret = of_property_read_u32(np, "battery,chg_float_voltage_conv",
8733 &pdata->chg_float_voltage_conv);
8734 if (ret) {
8735 pr_info("%s: chg_float_voltage_conv is Empty\n", __func__);
8736 pdata->chg_float_voltage_conv = 1;
8737 }
8738
8739 ret = of_property_read_u32(np, "battery,wa_volt_recov",
8740 (unsigned int *)&pdata->wa_volt_recov);
8741 if (ret) {
8742 pdata->wa_volt_recov = 4090;
8743 pr_info("%s: wa volt recov is Empty\n", __func__);
8744 }
8745
8746 ret = of_property_read_u32(np, "battery,wa_volt_thr",
8747 (unsigned int *)&pdata->wa_volt_thr);
8748 if (ret) {
8749 pdata->wa_volt_thr = 4100;
8750 pr_info("%s: wa volt thr is Empty\n", __func__);
8751 }
8752
8753 ret = of_property_read_u32(np, "battery,wa_float_voltage",
8754 (unsigned int *)&pdata->wa_float_voltage);
8755 if (ret) {
8756 pdata->wa_float_voltage = 40500;
8757 pr_info("%s: wa float voltage is Empty\n", __func__);
8758 }
8759
8760 ret = of_property_read_u32(np, "battery,wa_fl_check_count",
8761 &pdata->wa_fl_check_count);
8762 if (ret) {
8763 pdata->wa_fl_check_count = 3;
8764 pr_info("%s : swelling fl check count is Empty\n", __func__);
8765 }
8766
8767 #if defined(CONFIG_BATTERY_SWELLING)
8768 ret = of_property_read_u32(np, "battery,chg_float_voltage",
8769 (unsigned int *)&pdata->swelling_normal_float_voltage);
8770 if (ret)
8771 pr_info("%s: chg_float_voltage is Empty\n", __func__);
8772
8773 ret = of_property_read_u32(np, "battery,swelling_high_temp_block",
8774 &temp);
8775 pdata->swelling_high_temp_block = (int)temp;
8776 if (ret)
8777 pr_info("%s: swelling high temp block is Empty\n", __func__);
8778
8779 ret = of_property_read_u32(np, "battery,swelling_high_temp_recov",
8780 &temp);
8781 pdata->swelling_high_temp_recov = (int)temp;
8782 if (ret)
8783 pr_info("%s: swelling high temp recovery is Empty\n", __func__);
8784
8785 ret = of_property_read_u32(np, "battery,swelling_wc_high_temp_recov",
8786 &temp);
8787 pdata->swelling_wc_high_temp_recov = (int)temp;
8788 if (ret) {
8789 pdata->swelling_wc_high_temp_recov = pdata->swelling_high_temp_recov;
8790 pr_info("%s: swelling wireless high temp recovery is %d\n", __func__, pdata->swelling_wc_high_temp_recov);
8791 }
8792
8793 ret = of_property_read_u32(np, "battery,swelling_low_temp_block_1st",
8794 &temp);
8795 pdata->swelling_low_temp_block_1st = (int)temp;
8796 if (ret)
8797 pr_info("%s: swelling low temp block is Empty\n", __func__);
8798
8799 ret = of_property_read_u32(np, "battery,swelling_low_temp_recov_1st",
8800 &temp);
8801 pdata->swelling_low_temp_recov_1st = (int)temp;
8802 if (ret)
8803 pr_info("%s: swelling low temp recovery is Empty\n", __func__);
8804
8805 ret = of_property_read_u32(np, "battery,swelling_low_temp_block_2nd",
8806 &temp);
8807 pdata->swelling_low_temp_block_2nd = (int)temp;
8808 if (ret)
8809 pr_info("%s: swelling low temp block is Empty\n", __func__);
8810
8811 ret = of_property_read_u32(np, "battery,swelling_low_temp_recov_2nd",
8812 &temp);
8813 pdata->swelling_low_temp_recov_2nd = (int)temp;
8814 if (ret)
8815 pr_info("%s: swelling low temp recovery 2nd is Empty\n", __func__);
8816
8817 ret = of_property_read_u32(np, "battery,swelling_low_temp_current",
8818 &pdata->swelling_low_temp_current);
8819 if (ret) {
8820 pr_info("%s: swelling_low_temp_current is Empty, Defualt value 600mA \n", __func__);
8821 pdata->swelling_low_temp_current = 600;
8822 }
8823
8824 ret = of_property_read_u32(np, "battery,swelling_low_temp_topoff",
8825 &pdata->swelling_low_temp_topoff);
8826 if (ret) {
8827 pr_info("%s: swelling_low_temp_topoff is Empty, Defualt value 200mA \n", __func__);
8828 pdata->swelling_low_temp_topoff = 200;
8829 }
8830
8831 ret = of_property_read_u32(np, "battery,swelling_high_temp_current",
8832 &pdata->swelling_high_temp_current);
8833 if (ret) {
8834 pr_info("%s: swelling_low_temp_current is Empty, Defualt value 1300mA \n", __func__);
8835 pdata->swelling_high_temp_current = 1300;
8836 }
8837
8838 ret = of_property_read_u32(np, "battery,swelling_high_temp_topoff",
8839 &pdata->swelling_high_temp_topoff);
8840 if (ret) {
8841 pr_info("%s: swelling_high_temp_topoff is Empty, Defualt value 200mA \n", __func__);
8842 pdata->swelling_high_temp_topoff = 200;
8843 }
8844
8845 ret = of_property_read_u32(np, "battery,swelling_wc_high_temp_current",
8846 &pdata->swelling_wc_high_temp_current);
8847 if (ret) {
8848 pr_info("%s: swelling_wc_high_temp_current is Empty, Defualt value 600mA \n", __func__);
8849 pdata->swelling_low_temp_current = 600;
8850 }
8851
8852 ret = of_property_read_u32(np, "battery,swelling_wc_low_temp_current",
8853 &pdata->swelling_wc_low_temp_current);
8854 if (ret) {
8855 pr_info("%s: swelling_wc_low_temp_current is Empty, Defualt value 600mA \n", __func__);
8856 pdata->swelling_low_temp_current = 600;
8857 }
8858
8859 ret = of_property_read_u32(np, "battery,swelling_drop_float_voltage",
8860 (unsigned int *)&pdata->swelling_drop_float_voltage);
8861 if (ret) {
8862 pr_info("%s: swelling drop float voltage is Empty, Default value 4250mV \n", __func__);
8863 pdata->swelling_drop_float_voltage = 4250;
8864 pdata->swelling_drop_voltage_condition = 4250;
8865 } else {
8866 pdata->swelling_drop_voltage_condition = (pdata->swelling_drop_float_voltage > 10000) ?
8867 (pdata->swelling_drop_float_voltage / 10) : (pdata->swelling_drop_float_voltage);
8868 pr_info("%s : swelling drop voltage(set : %d, condition : %d)\n", __func__,
8869 pdata->swelling_drop_float_voltage, pdata->swelling_drop_voltage_condition);
8870 }
8871
8872 ret = of_property_read_u32(np, "battery,swelling_high_rechg_voltage",
8873 (unsigned int *)&pdata->swelling_high_rechg_voltage);
8874 if (ret) {
8875 pr_info("%s: swelling_high_rechg_voltage is Empty\n", __func__);
8876 pdata->swelling_high_rechg_voltage = 4150;
8877 }
8878
8879 ret = of_property_read_u32(np, "battery,swelling_low_rechg_voltage",
8880 (unsigned int *)&pdata->swelling_low_rechg_voltage);
8881 if (ret) {
8882 pr_info("%s: swelling_low_rechg_voltage is Empty\n", __func__);
8883 pdata->swelling_low_rechg_voltage = 4000;
8884 }
8885
8886 pr_info("%s : SWELLING_HIGH_TEMP(%d) SWELLING_HIGH_TEMP_RECOVERY(%d)\n"
8887 "SWELLING_LOW_TEMP_1st(%d) SWELLING_LOW_TEMP_RECOVERY_1st(%d) "
8888 "SWELLING_LOW_TEMP_2nd(%d) SWELLING_LOW_TEMP_RECOVERY_2nd(%d) "
8889 "SWELLING_LOW_CURRENT(%d, %d), SWELLING_HIGH_CURRENT(%d, %d)\n"
8890 "SWELLING_LOW_RCHG_VOL(%d), SWELLING_HIGH_RCHG_VOL(%d)\n",
8891 __func__, pdata->swelling_high_temp_block, pdata->swelling_high_temp_recov,
8892 pdata->swelling_low_temp_block_1st, pdata->swelling_low_temp_recov_1st,
8893 pdata->swelling_low_temp_block_2nd, pdata->swelling_low_temp_recov_2nd,
8894 pdata->swelling_low_temp_current, pdata->swelling_low_temp_topoff,
8895 pdata->swelling_high_temp_current, pdata->swelling_high_temp_topoff,
8896 pdata->swelling_low_rechg_voltage, pdata->swelling_high_rechg_voltage);
8897 #endif
8898
8899 #if defined(CONFIG_CALC_TIME_TO_FULL)
8900 ret = of_property_read_u32(np, "battery,ttf_hv_12v_charge_current",
8901 &pdata->ttf_hv_12v_charge_current);
8902 if (ret) {
8903 pdata->ttf_hv_12v_charge_current =
8904 pdata->charging_current[SEC_BATTERY_CABLE_12V_TA].fast_charging_current;
8905 pr_info("%s: ttf_hv_12v_charge_current is Empty, Defualt value %d \n",
8906 __func__, pdata->ttf_hv_12v_charge_current);
8907 }
8908 ret = of_property_read_u32(np, "battery,ttf_hv_charge_current",
8909 &pdata->ttf_hv_charge_current);
8910 if (ret) {
8911 pdata->ttf_hv_charge_current =
8912 pdata->charging_current[SEC_BATTERY_CABLE_9V_TA].fast_charging_current;
8913 pr_info("%s: ttf_hv_charge_current is Empty, Defualt value %d \n",
8914 __func__, pdata->ttf_hv_charge_current);
8915 }
8916
8917 ret = of_property_read_u32(np, "battery,ttf_hv_wireless_charge_current",
8918 &pdata->ttf_hv_wireless_charge_current);
8919 if (ret) {
8920 pr_info("%s: ttf_hv_wireless_charge_current is Empty, Defualt value 0 \n", __func__);
8921 pdata->ttf_hv_wireless_charge_current =
8922 pdata->charging_current[SEC_BATTERY_CABLE_HV_WIRELESS].fast_charging_current - 300;
8923 }
8924
8925 ret = of_property_read_u32(np, "battery,ttf_wireless_charge_current",
8926 &pdata->ttf_wireless_charge_current);
8927 if (ret) {
8928 pr_info("%s: ttf_wireless_charge_current is Empty, Defualt value 0 \n", __func__);
8929 pdata->ttf_wireless_charge_current =
8930 pdata->charging_current[SEC_BATTERY_CABLE_WIRELESS].input_current_limit;
8931 }
8932 #endif
8933
8934 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
8935 /* wpc_det */
8936 ret = pdata->wpc_det = of_get_named_gpio(np, "battery,wpc_det", 0);
8937 if (ret < 0) {
8938 pr_info("%s : can't get wpc_det\n", __func__);
8939 }
8940 #endif
8941
8942 /* wpc_en */
8943 ret = pdata->wpc_en = of_get_named_gpio(np, "battery,wpc_en", 0);
8944 if (ret < 0) {
8945 pr_info("%s : can't get wpc_en\n", __func__);
8946 pdata->wpc_en = 0;
8947 }
8948 #if defined(CONFIG_BATTERY_AGE_FORECAST)
8949 p = of_get_property(np, "battery,age_data", &len);
8950 if (p) {
8951 battery->pdata->num_age_step = len / sizeof(sec_age_data_t);
8952 battery->pdata->age_data = kzalloc(len, GFP_KERNEL);
8953 ret = of_property_read_u32_array(np, "battery,age_data",
8954 (u32 *)battery->pdata->age_data, len/sizeof(u32));
8955 if (ret) {
8956 pr_err("%s failed to read battery->pdata->age_data: %d\n",
8957 __func__, ret);
8958 kfree(battery->pdata->age_data);
8959 battery->pdata->age_data = NULL;
8960 battery->pdata->num_age_step = 0;
8961 }
8962 pr_err("%s num_age_step : %d\n", __func__, battery->pdata->num_age_step);
8963 for (len = 0; len < battery->pdata->num_age_step; ++len) {
8964 pr_err("[%d/%d]cycle:%d, float:%d, full_v:%d, recharge_v:%d, soc:%d\n",
8965 len, battery->pdata->num_age_step-1,
8966 battery->pdata->age_data[len].cycle,
8967 battery->pdata->age_data[len].float_voltage,
8968 battery->pdata->age_data[len].full_condition_vcell,
8969 battery->pdata->age_data[len].recharge_condition_vcell,
8970 battery->pdata->age_data[len].full_condition_soc);
8971 }
8972 } else {
8973 battery->pdata->num_age_step = 0;
8974 pr_err("%s there is not age_data\n", __func__);
8975 }
8976 #endif
8977
8978 ret = of_property_read_u32(np, "battery,siop_input_limit_current",
8979 &pdata->siop_input_limit_current);
8980 if (ret)
8981 pdata->siop_input_limit_current = SIOP_INPUT_LIMIT_CURRENT;
8982
8983 ret = of_property_read_u32(np, "battery,siop_charging_limit_current",
8984 &pdata->siop_charging_limit_current);
8985 if (ret)
8986 pdata->siop_charging_limit_current = SIOP_CHARGING_LIMIT_CURRENT;
8987
8988 ret = of_property_read_u32(np, "battery,siop_hv_12v_input_limit_current",
8989 &pdata->siop_hv_12v_input_limit_current);
8990 if (ret)
8991 pdata->siop_hv_12v_input_limit_current = SIOP_HV_12V_INPUT_LIMIT_CURRENT;
8992
8993 ret = of_property_read_u32(np, "battery,siop_hv_12v_charging_limit_current",
8994 &pdata->siop_hv_12v_charging_limit_current);
8995 if (ret)
8996 pdata->siop_hv_12v_charging_limit_current = SIOP_HV_12V_CHARGING_LIMIT_CURRENT;
8997
8998 ret = of_property_read_u32(np, "battery,siop_hv_input_limit_current",
8999 &pdata->siop_hv_input_limit_current);
9000 if (ret)
9001 pdata->siop_hv_input_limit_current = SIOP_HV_INPUT_LIMIT_CURRENT;
9002
9003 ret = of_property_read_u32(np, "battery,siop_hv_charging_limit_current",
9004 &pdata->siop_hv_charging_limit_current);
9005 if (ret)
9006 pdata->siop_hv_charging_limit_current = SIOP_HV_CHARGING_LIMIT_CURRENT;
9007
9008 ret = of_property_read_u32(np, "battery,siop_wireless_input_limit_current",
9009 &pdata->siop_wireless_input_limit_current);
9010 if (ret)
9011 pdata->siop_wireless_input_limit_current = SIOP_WIRELESS_INPUT_LIMIT_CURRENT;
9012
9013 ret = of_property_read_u32(np, "battery,siop_wireless_charging_limit_current",
9014 &pdata->siop_wireless_charging_limit_current);
9015 if (ret)
9016 pdata->siop_wireless_charging_limit_current = SIOP_WIRELESS_CHARGING_LIMIT_CURRENT;
9017
9018 ret = of_property_read_u32(np, "battery,siop_hv_wireless_input_limit_current",
9019 &pdata->siop_hv_wireless_input_limit_current);
9020 if (ret)
9021 pdata->siop_hv_wireless_input_limit_current = SIOP_HV_WIRELESS_INPUT_LIMIT_CURRENT;
9022
9023 ret = of_property_read_u32(np, "battery,siop_hv_wireless_charging_limit_current",
9024 &pdata->siop_hv_wireless_charging_limit_current);
9025 if (ret)
9026 pdata->siop_hv_wireless_charging_limit_current = SIOP_HV_WIRELESS_CHARGING_LIMIT_CURRENT;
9027
9028 ret = of_property_read_u32(np, "battery,max_input_voltage",
9029 &pdata->max_input_voltage);
9030 if (ret)
9031 pdata->max_input_voltage = 12000;
9032
9033 ret = of_property_read_u32(np, "battery,max_input_current",
9034 &pdata->max_input_current);
9035 if (ret)
9036 pdata->max_input_current = 3000;
9037
9038 ret = of_property_read_u32(np, "battery,pd_charging_charge_power",
9039 &pdata->pd_charging_charge_power);
9040 if (ret) {
9041 pr_err("%s: pd_charging_charge_power is Empty\n", __func__);
9042 pdata->pd_charging_charge_power = 15000;
9043 }
9044
9045 ret = of_property_read_u32(np, "battery,nv_charge_power",
9046 &pdata->nv_charge_power);
9047 if (ret) {
9048 pr_err("%s: nv_charge_power is Empty\n", __func__);
9049 pdata->nv_charge_power =
9050 SEC_INPUT_VOLTAGE_5V * pdata->default_input_current;
9051 }
9052
9053 pr_info("%s: vendor : %s, technology : %d, cable_check_type : %d\n"
9054 "cable_source_type : %d, event_waiting_time : %d\n"
9055 "polling_type : %d, initial_count : %d, check_count : %d\n"
9056 "check_adc_max : %d, check_adc_min : %d\n"
9057 "ovp_uvlo_check_type : %d, thermal_source : %d\n"
9058 "temp_check_type : %d, temp_check_count : %d, nv_charge_power : %d\n",
9059 __func__,
9060 pdata->vendor, pdata->technology,pdata->cable_check_type,
9061 pdata->cable_source_type, pdata->event_waiting_time,
9062 pdata->polling_type, pdata->monitor_initial_count,
9063 pdata->check_count, pdata->check_adc_max, pdata->check_adc_min,
9064 pdata->ovp_uvlo_check_type, pdata->thermal_source,
9065 pdata->temp_check_type, pdata->temp_check_count, pdata->nv_charge_power);
9066
9067 #if defined(CONFIG_STEP_CHARGING)
9068 sec_step_charging_init(battery, dev);
9069 #else
9070 ret = of_property_read_u32(np, "battery,max_charging_current",
9071 &pdata->max_charging_current);
9072 if (ret) {
9073 pr_err("%s: max_charging_current is Empty\n", __func__);
9074 pdata->max_charging_current = 3000;
9075 }
9076
9077 #endif
9078 return 0;
9079 }
9080
9081 static void sec_bat_parse_mode_dt(struct sec_battery_info *battery)
9082 {
9083 struct device_node *np;
9084 sec_battery_platform_data_t *pdata = battery->pdata;
9085 int ret = 0;
9086 u32 temp = 0;
9087
9088 np = of_find_node_by_name(NULL, "battery");
9089 if (!np) {
9090 pr_err("%s np NULL\n", __func__);
9091 return;
9092 }
9093
9094 if (battery->store_mode) {
9095 ret = of_property_read_u32(np, "battery,store_mode_afc_input_current",
9096 &pdata->store_mode_afc_input_current);
9097 if (ret) {
9098 pr_info("%s : store_mode_afc_input_current is Empty\n", __func__);
9099 pdata->store_mode_afc_input_current = 440;
9100 }
9101
9102 ret = of_property_read_u32(np, "battery,store_mode_hv_wireless_input_current",
9103 &pdata->store_mode_hv_wireless_input_current);
9104 if (ret) {
9105 pr_info("%s : store_mode_hv_wireless_input_current is Empty\n", __func__);
9106 pdata->store_mode_hv_wireless_input_current = 400;
9107 }
9108
9109 if (pdata->wpc_temp_check) {
9110 ret = of_property_read_u32(np, "battery,wpc_store_high_temp",
9111 &temp);
9112 if (!ret)
9113 pdata->wpc_high_temp = temp;
9114
9115 ret = of_property_read_u32(np, "battery,wpc_store_high_temp_recovery",
9116 &temp);
9117 if (!ret)
9118 pdata->wpc_high_temp_recovery = temp;
9119
9120 ret = of_property_read_u32(np, "battery,wpc_store_charging_limit_current",
9121 &temp);
9122 if (!ret)
9123 pdata->wpc_charging_limit_current = temp;
9124
9125 ret = of_property_read_u32(np, "battery,wpc_store_lcd_on_high_temp",
9126 &temp);
9127 if (!ret)
9128 pdata->wpc_lcd_on_high_temp = (int)temp;
9129
9130 ret = of_property_read_u32(np, "battery,wpc_store_lcd_on_high_temp_rec",
9131 &temp);
9132 if (!ret)
9133 pdata->wpc_lcd_on_high_temp_rec = (int)temp;
9134
9135 pr_info("%s: update store_mode - wpc high_temp(t:%d, r:%d), lcd_on_high_temp(t:%d, r:%d), curr(%d)\n",
9136 __func__,
9137 pdata->wpc_high_temp, pdata->wpc_high_temp_recovery,
9138 pdata->wpc_lcd_on_high_temp, pdata->wpc_lcd_on_high_temp_rec,
9139 pdata->wpc_charging_limit_current);
9140 }
9141
9142 ret = of_property_read_u32(np, "battery,siop_store_hv_wireless_input_limit_current",
9143 &temp);
9144 if (!ret)
9145 pdata->siop_hv_wireless_input_limit_current = temp;
9146 else
9147 pdata->siop_hv_wireless_input_limit_current = SIOP_STORE_HV_WIRELESS_CHARGING_LIMIT_CURRENT;
9148 pr_info("%s: update siop_hv_wireless_input_limit_current(%d)\n",
9149 __func__, pdata->siop_hv_wireless_input_limit_current);
9150 }
9151 }
9152
9153 static void sec_bat_parse_mode_dt_work(struct work_struct *work)
9154 {
9155 struct sec_battery_info *battery = container_of(work,
9156 struct sec_battery_info, parse_mode_dt_work.work);
9157
9158 sec_bat_parse_mode_dt(battery);
9159
9160 if (is_hv_wire_type(battery->cable_type) ||
9161 is_hv_wireless_type(battery->cable_type)) {
9162 sec_bat_set_charging_current(battery);
9163 }
9164
9165 wake_unlock(&battery->parse_mode_dt_wake_lock);
9166 }
9167 #endif
9168
9169 #ifdef CONFIG_OF
9170 extern sec_battery_platform_data_t sec_battery_pdata;
9171 #endif
9172
9173 #if !defined(CONFIG_MUIC_NOTIFIER)
9174 static void cable_initial_check(struct sec_battery_info *battery)
9175 {
9176 union power_supply_propval value;
9177
9178 pr_info("%s : current_cable_type : (%d)\n", __func__, battery->cable_type);
9179
9180 if (SEC_BATTERY_CABLE_NONE != battery->cable_type) {
9181 if (battery->cable_type == SEC_BATTERY_CABLE_POWER_SHARING) {
9182 value.intval = battery->cable_type;
9183 psy_do_property("ps", set,
9184 POWER_SUPPLY_PROP_ONLINE, value);
9185 } else {
9186 value.intval = battery->cable_type;
9187 psy_do_property("battery", set,
9188 POWER_SUPPLY_PROP_ONLINE, value);
9189 }
9190 } else {
9191 psy_do_property(battery->pdata->charger_name, get,
9192 POWER_SUPPLY_PROP_ONLINE, value);
9193 if (value.intval == SEC_BATTERY_CABLE_WIRELESS) {
9194 value.intval = 1;
9195 psy_do_property("wireless", set,
9196 POWER_SUPPLY_PROP_ONLINE, value);
9197 }
9198 }
9199 }
9200 #endif
9201
9202 static void sec_bat_init_chg_work(struct work_struct *work)
9203 {
9204 struct sec_battery_info *battery = container_of(work,
9205 struct sec_battery_info, init_chg_work.work);
9206
9207 if (battery->cable_type == SEC_BATTERY_CABLE_NONE &&
9208 !(battery->misc_event & BATT_MISC_EVENT_UNDEFINED_RANGE_TYPE)) {
9209 pr_info("%s: disable charging\n", __func__);
9210 sec_bat_set_charge(battery, SEC_BAT_CHG_MODE_CHARGING_OFF);
9211 }
9212 }
9213
9214 static const struct power_supply_desc battery_power_supply_desc = {
9215 .name = "battery",
9216 .type = POWER_SUPPLY_TYPE_BATTERY,
9217 .properties = sec_battery_props,
9218 .num_properties = ARRAY_SIZE(sec_battery_props),
9219 .get_property = sec_bat_get_property,
9220 .set_property = sec_bat_set_property,
9221 };
9222
9223 static const struct power_supply_desc usb_power_supply_desc = {
9224 .name = "usb",
9225 .type = POWER_SUPPLY_TYPE_USB,
9226 .properties = sec_power_props,
9227 .num_properties = ARRAY_SIZE(sec_power_props),
9228 .get_property = sec_usb_get_property,
9229 };
9230
9231 static const struct power_supply_desc ac_power_supply_desc = {
9232 .name = "ac",
9233 .type = POWER_SUPPLY_TYPE_MAINS,
9234 .properties = sec_ac_props,
9235 .num_properties = ARRAY_SIZE(sec_ac_props),
9236 .get_property = sec_ac_get_property,
9237 };
9238
9239 static const struct power_supply_desc wireless_power_supply_desc = {
9240 .name = "wireless",
9241 .type = POWER_SUPPLY_TYPE_WIRELESS,
9242 .properties = sec_wireless_props,
9243 .num_properties = ARRAY_SIZE(sec_wireless_props),
9244 .get_property = sec_wireless_get_property,
9245 .set_property = sec_wireless_set_property,
9246 };
9247
9248 static const struct power_supply_desc ps_power_supply_desc = {
9249 .name = "ps",
9250 .type = POWER_SUPPLY_TYPE_POWER_SHARING,
9251 .properties = sec_ps_props,
9252 .num_properties = ARRAY_SIZE(sec_ps_props),
9253 .get_property = sec_ps_get_property,
9254 .set_property = sec_ps_set_property,
9255 };
9256
9257 static int sec_battery_probe(struct platform_device *pdev)
9258 {
9259 sec_battery_platform_data_t *pdata = NULL;
9260 struct sec_battery_info *battery;
9261 struct power_supply_config battery_cfg = {};
9262
9263 int ret = 0;
9264 #ifndef CONFIG_OF
9265 int i = 0;
9266 #endif
9267
9268 union power_supply_propval value = {0, };
9269
9270 dev_info(&pdev->dev,
9271 "%s: SEC Battery Driver Loading\n", __func__);
9272
9273 battery = kzalloc(sizeof(*battery), GFP_KERNEL);
9274 if (!battery)
9275 return -ENOMEM;
9276
9277 if (pdev->dev.of_node) {
9278 pdata = devm_kzalloc(&pdev->dev,
9279 sizeof(sec_battery_platform_data_t),
9280 GFP_KERNEL);
9281 if (!pdata) {
9282 dev_err(&pdev->dev, "Failed to allocate memory\n");
9283 ret = -ENOMEM;
9284 goto err_bat_free;
9285 }
9286
9287 battery->pdata = pdata;
9288
9289 if (sec_bat_parse_dt(&pdev->dev, battery)) {
9290 dev_err(&pdev->dev,
9291 "%s: Failed to get battery dt\n", __func__);
9292 ret = -EINVAL;
9293 goto err_bat_free;
9294 }
9295 } else {
9296 pdata = dev_get_platdata(&pdev->dev);
9297 battery->pdata = pdata;
9298 }
9299
9300 platform_set_drvdata(pdev, battery);
9301
9302 battery->dev = &pdev->dev;
9303
9304 mutex_init(&battery->adclock);
9305 mutex_init(&battery->iolock);
9306 mutex_init(&battery->misclock);
9307 mutex_init(&battery->batt_handlelock);
9308 mutex_init(&battery->current_eventlock);
9309 mutex_init(&battery->typec_notylock);
9310 mutex_init(&battery->wclock);
9311 #if defined(CONFIG_BATTERY_SBM_DATA)
9312 mutex_init(&battery->sbmlock);
9313 sec_bat_init_sbm(battery);
9314 #endif
9315
9316 dev_dbg(battery->dev, "%s: ADC init\n", __func__);
9317
9318 #ifdef CONFIG_OF
9319 adc_init(pdev, battery);
9320 #else
9321 for (i = 0; i < SEC_BAT_ADC_CHANNEL_NUM; i++)
9322 adc_init(pdev, pdata, i);
9323 #endif
9324 wake_lock_init(&battery->monitor_wake_lock, WAKE_LOCK_SUSPEND,
9325 "sec-battery-monitor");
9326 wake_lock_init(&battery->cable_wake_lock, WAKE_LOCK_SUSPEND,
9327 "sec-battery-cable");
9328 wake_lock_init(&battery->vbus_wake_lock, WAKE_LOCK_SUSPEND,
9329 "sec-battery-vbus");
9330 wake_lock_init(&battery->afc_wake_lock, WAKE_LOCK_SUSPEND,
9331 "sec-battery-afc");
9332 wake_lock_init(&battery->siop_level_wake_lock, WAKE_LOCK_SUSPEND,
9333 "sec-battery-siop_level");
9334 wake_lock_init(&battery->ext_event_wake_lock, WAKE_LOCK_SUSPEND,
9335 "sec-battery-ext_event");
9336 wake_lock_init(&battery->wc_headroom_wake_lock, WAKE_LOCK_SUSPEND,
9337 "sec-battery-wc_headroom");
9338 #if defined(CONFIG_UPDATE_BATTERY_DATA)
9339 wake_lock_init(&battery->batt_data_wake_lock, WAKE_LOCK_SUSPEND,
9340 "sec-battery-update-data");
9341 #endif
9342 wake_lock_init(&battery->misc_event_wake_lock, WAKE_LOCK_SUSPEND,
9343 "sec-battery-misc-event");
9344 #ifdef CONFIG_OF
9345 wake_lock_init(&battery->parse_mode_dt_wake_lock, WAKE_LOCK_SUSPEND,
9346 "sec-battery-parse_mode_dt");
9347 #endif
9348
9349 /* initialization of battery info */
9350 sec_bat_set_charging_status(battery,
9351 POWER_SUPPLY_STATUS_DISCHARGING);
9352 battery->health = POWER_SUPPLY_HEALTH_GOOD;
9353 battery->present = true;
9354 battery->is_jig_on = false;
9355 battery->wdt_kick_disable = 0;
9356
9357 battery->polling_count = 1; /* initial value = 1 */
9358 battery->polling_time = pdata->polling_time[
9359 SEC_BATTERY_POLLING_TIME_DISCHARGING];
9360 battery->polling_in_sleep = false;
9361 battery->polling_short = false;
9362
9363 battery->check_count = 0;
9364 battery->check_adc_count = 0;
9365 battery->check_adc_value = 0;
9366
9367 battery->input_current = 0;
9368 battery->charging_current = 0;
9369 battery->topoff_current = 0;
9370 battery->wpc_vout_level = WIRELESS_VOUT_10V;
9371 battery->charging_start_time = 0;
9372 battery->charging_passed_time = 0;
9373 battery->wc_heating_start_time = 0;
9374 battery->wc_heating_passed_time = 0;
9375 battery->charging_next_time = 0;
9376 battery->charging_fullcharged_time = 0;
9377 battery->siop_level = 100;
9378 battery->ext_event = BATT_EXT_EVENT_NONE;
9379 battery->wc_enable = 1;
9380 battery->wc_enable_cnt = 0;
9381 battery->wc_enable_cnt_value = 3;
9382 #if defined(CONFIG_ENG_BATTERY_CONCEPT)
9383 battery->stability_test = 0;
9384 battery->eng_not_full_status = 0;
9385 battery->temperature_test_battery = 0x7FFF;
9386 battery->temperature_test_usb = 0x7FFF;
9387 battery->temperature_test_wpc = 0x7FFF;
9388 battery->temperature_test_chg = 0x7FFF;
9389 #endif
9390 battery->ps_enable = false;
9391 battery->wc_status = SEC_WIRELESS_PAD_NONE;
9392 battery->wc_cv_mode = false;
9393 battery->wire_status = SEC_BATTERY_CABLE_NONE;
9394
9395 #if defined(CONFIG_BATTERY_SWELLING)
9396 battery->swelling_mode = SWELLING_MODE_NONE;
9397 #endif
9398 battery->charging_block = false;
9399 battery->chg_limit = false;
9400 battery->mix_limit = false;
9401 battery->vbus_limit = false;
9402 battery->usb_temp = 0;
9403 #if defined(CONFIG_ENG_BATTERY_CONCEPT) || defined(CONFIG_SEC_FACTORY)
9404 battery->cooldown_mode = true;
9405 #endif
9406 battery->skip_swelling = false;
9407 battery->led_cover = 0;
9408 battery->wa_float_cnt = 0;
9409 battery->wc_rx_phm_mode = false;
9410
9411 sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_USB_100MA, SEC_BAT_CURRENT_EVENT_USB_100MA);
9412
9413 if (lpcharge) {
9414 battery->temp_highlimit_threshold =
9415 battery->pdata->temp_highlimit_threshold_lpm;
9416 battery->temp_highlimit_recovery =
9417 battery->pdata->temp_highlimit_recovery_lpm;
9418 battery->temp_high_threshold =
9419 battery->pdata->temp_high_threshold_lpm;
9420 battery->temp_high_recovery =
9421 battery->pdata->temp_high_recovery_lpm;
9422 battery->temp_low_recovery =
9423 battery->pdata->temp_low_recovery_lpm;
9424 battery->temp_low_threshold =
9425 battery->pdata->temp_low_threshold_lpm;
9426 } else {
9427 battery->temp_highlimit_threshold =
9428 battery->pdata->temp_highlimit_threshold_normal;
9429 battery->temp_highlimit_recovery =
9430 battery->pdata->temp_highlimit_recovery_normal;
9431 battery->temp_high_threshold =
9432 battery->pdata->temp_high_threshold_normal;
9433 battery->temp_high_recovery =
9434 battery->pdata->temp_high_recovery_normal;
9435 battery->temp_low_recovery =
9436 battery->pdata->temp_low_recovery_normal;
9437 battery->temp_low_threshold =
9438 battery->pdata->temp_low_threshold_normal;
9439 }
9440
9441 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
9442 battery->is_recharging = false;
9443 battery->cable_type = SEC_BATTERY_CABLE_NONE;
9444 battery->test_mode = 0;
9445 battery->factory_mode = false;
9446 battery->store_mode = false;
9447 battery->slate_mode = false;
9448 battery->is_hc_usb = false;
9449 battery->is_sysovlo = false;
9450 battery->is_vbatovlo = false;
9451 battery->is_abnormal_temp = false;
9452
9453 battery->safety_timer_set = true;
9454 battery->stop_timer = false;
9455 battery->prev_safety_time = 0;
9456 battery->lcd_status = false;
9457
9458 #if defined(CONFIG_BATTERY_CISD)
9459 battery->usb_overheat_check = false;
9460 battery->skip_cisd = false;
9461 #endif
9462
9463 #if defined(CONFIG_BATTERY_AGE_FORECAST)
9464 battery->batt_cycle = -1;
9465 battery->pdata->age_step = 0;
9466 #endif
9467
9468 battery->health_change = false;
9469
9470 /* Check High Voltage charging option for wireless charging */
9471 /* '1' means disabling High Voltage charging */
9472 if (charging_night_mode == '1')
9473 sleep_mode = true;
9474 else
9475 sleep_mode = false;
9476
9477 /* Check High Voltage charging option for wired charging */
9478 if (get_afc_mode() == CH_MODE_AFC_DISABLE_VAL) {
9479 pr_info("HV wired charging mode is disabled\n");
9480 sec_bat_set_current_event(battery,
9481 SEC_BAT_CURRENT_EVENT_HV_DISABLE, SEC_BAT_CURRENT_EVENT_HV_DISABLE);
9482 }
9483
9484 #if defined(CONFIG_BATTERY_SBM_DATA)
9485 battery->sbm_data = false;
9486 #endif
9487
9488 #if defined(CONFIG_CALC_TIME_TO_FULL)
9489 battery->timetofull = -1;
9490 #endif
9491
9492 if (battery->pdata->charger_name == NULL)
9493 battery->pdata->charger_name = "sec-charger";
9494 if (battery->pdata->fuelgauge_name == NULL)
9495 battery->pdata->fuelgauge_name = "sec-fuelgauge";
9496
9497 /* create work queue */
9498 battery->monitor_wqueue =
9499 create_singlethread_workqueue(dev_name(&pdev->dev));
9500 if (!battery->monitor_wqueue) {
9501 dev_err(battery->dev,
9502 "%s: Fail to Create Workqueue\n", __func__);
9503 goto err_irq;
9504 }
9505
9506 INIT_DELAYED_WORK(&battery->monitor_work, sec_bat_monitor_work);
9507 INIT_DELAYED_WORK(&battery->cable_work, sec_bat_cable_work);
9508 #if defined(CONFIG_CALC_TIME_TO_FULL)
9509 INIT_DELAYED_WORK(&battery->timetofull_work, sec_bat_time_to_full_work);
9510 #endif
9511 INIT_DELAYED_WORK(&battery->slowcharging_work, sec_bat_check_slowcharging_work);
9512 INIT_DELAYED_WORK(&battery->afc_work, sec_bat_afc_work);
9513 INIT_DELAYED_WORK(&battery->ext_event_work, sec_bat_ext_event_work);
9514 INIT_DELAYED_WORK(&battery->siop_level_work, sec_bat_siop_level_work);
9515 INIT_DELAYED_WORK(&battery->wc_headroom_work, sec_bat_wc_headroom_work);
9516 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
9517 INIT_DELAYED_WORK(&battery->fw_init_work, sec_bat_fw_init_work);
9518 #endif
9519 #if defined(CONFIG_UPDATE_BATTERY_DATA)
9520 INIT_DELAYED_WORK(&battery->batt_data_work, sec_bat_update_data_work);
9521 #endif
9522 INIT_DELAYED_WORK(&battery->misc_event_work, sec_bat_misc_event_work);
9523 #ifdef CONFIG_OF
9524 INIT_DELAYED_WORK(&battery->parse_mode_dt_work, sec_bat_parse_mode_dt_work);
9525 #endif
9526 INIT_DELAYED_WORK(&battery->init_chg_work, sec_bat_init_chg_work);
9527
9528 switch (pdata->polling_type) {
9529 case SEC_BATTERY_MONITOR_WORKQUEUE:
9530 INIT_DELAYED_WORK(&battery->polling_work,
9531 sec_bat_polling_work);
9532 break;
9533 case SEC_BATTERY_MONITOR_ALARM:
9534 battery->last_poll_time = ktime_get_boottime();
9535 alarm_init(&battery->polling_alarm, ALARM_BOOTTIME,
9536 sec_bat_alarm);
9537 break;
9538 default:
9539 break;
9540 }
9541
9542 #if defined(CONFIG_BATTERY_CISD)
9543 sec_battery_cisd_init(battery);
9544 #endif
9545
9546 battery_cfg.drv_data = battery;
9547
9548 /* init power supplier framework */
9549 battery->psy_ps = power_supply_register(&pdev->dev, &ps_power_supply_desc, &battery_cfg);
9550 if (!battery->psy_ps) {
9551 dev_err(battery->dev,
9552 "%s: Failed to Register psy_ps\n", __func__);
9553 goto err_workqueue;
9554 }
9555 battery->psy_ps->supplied_to = supply_list;
9556 battery->psy_ps->num_supplicants = ARRAY_SIZE(supply_list);
9557
9558 battery->psy_wireless = power_supply_register(&pdev->dev, &wireless_power_supply_desc, &battery_cfg);
9559 if (!battery->psy_wireless) {
9560 dev_err(battery->dev,
9561 "%s: Failed to Register psy_wireless\n", __func__);
9562 goto err_supply_unreg_ps;
9563 }
9564 battery->psy_wireless->supplied_to = supply_list;
9565 battery->psy_wireless->num_supplicants = ARRAY_SIZE(supply_list);
9566
9567 battery->psy_usb = power_supply_register(&pdev->dev, &usb_power_supply_desc, &battery_cfg);
9568 if (!battery->psy_usb) {
9569 dev_err(battery->dev,
9570 "%s: Failed to Register psy_usb\n", __func__);
9571 goto err_supply_unreg_wireless;
9572 }
9573 battery->psy_usb->supplied_to = supply_list;
9574 battery->psy_usb->num_supplicants = ARRAY_SIZE(supply_list);
9575
9576 battery->psy_ac = power_supply_register(&pdev->dev, &ac_power_supply_desc, &battery_cfg);
9577 if (!battery->psy_ac) {
9578 dev_err(battery->dev,
9579 "%s: Failed to Register psy_ac\n", __func__);
9580 goto err_supply_unreg_usb;
9581 }
9582 battery->psy_ac->supplied_to = supply_list;
9583 battery->psy_ac->num_supplicants = ARRAY_SIZE(supply_list);
9584
9585 battery->psy_bat = power_supply_register(&pdev->dev, &battery_power_supply_desc, &battery_cfg);
9586 if (!battery->psy_bat) {
9587 dev_err(battery->dev,
9588 "%s: Failed to Register psy_bat\n", __func__);
9589 goto err_supply_unreg_ac;
9590 }
9591
9592 ret = sec_bat_create_attrs(&battery->psy_bat->dev);
9593 if (ret) {
9594 dev_err(battery->dev,
9595 "%s : Failed to create_attrs\n", __func__);
9596 goto err_req_irq;
9597 }
9598
9599 /* initialize battery level*/
9600 value.intval = 0;
9601 psy_do_property(battery->pdata->fuelgauge_name, get,
9602 POWER_SUPPLY_PROP_CAPACITY, value);
9603 battery->capacity = value.intval;
9604
9605 #if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
9606 /* queue_delayed_work(battery->monitor_wqueue, &battery->fw_init_work, 0); */
9607 #endif
9608
9609 /* notify wireless charger driver when sec_battery probe is done,
9610 if wireless charging is possible, POWER_SUPPLY_PROP_ONLINE of wireless property will be called. */
9611 value.intval = 0;
9612 psy_do_property(battery->pdata->wireless_charger_name, set,
9613 POWER_SUPPLY_PROP_CHARGE_TYPE, value);
9614
9615 #if defined(CONFIG_STORE_MODE) && !defined(CONFIG_SEC_FACTORY)
9616 battery->store_mode = true;
9617 sec_bat_parse_mode_dt(battery);
9618 #endif
9619
9620 #if defined(CONFIG_USB_TYPEC_MANAGER_NOTIFIER)
9621 battery->pdic_info.sink_status.rp_currentlvl = RP_CURRENT_LEVEL_NONE;
9622 manager_notifier_register(&battery->usb_typec_nb,
9623 usb_typec_handle_notification, MANAGER_NOTIFY_CCIC_BATTERY);
9624 #else
9625 #if defined(CONFIG_MUIC_NOTIFIER)
9626 muic_notifier_register(&battery->batt_nb,
9627 batt_handle_notification, MUIC_NOTIFY_DEV_CHARGER);
9628 #else
9629 cable_initial_check(battery);
9630 #endif
9631 #if defined(CONFIG_CCIC_NOTIFIER)
9632 pr_info("%s: Registering PDIC_NOTIFY.\n", __func__);
9633 pdic_notifier_register(&battery->pdic_nb,
9634 batt_pdic_handle_notification, PDIC_NOTIFY_DEV_BATTERY);
9635 #endif
9636 #endif
9637 #if defined(CONFIG_VBUS_NOTIFIER)
9638 vbus_notifier_register(&battery->vbus_nb,
9639 vbus_handle_notification, VBUS_NOTIFY_DEV_CHARGER);
9640 #endif
9641
9642 value.intval = true;
9643 psy_do_property(battery->pdata->charger_name, set,
9644 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, value);
9645
9646 /* make fg_reset true again for actual normal booting after recovery kernel is done */
9647 if (fg_reset && (bootmode == 2)) {
9648 psy_do_property(battery->pdata->fuelgauge_name, set,
9649 POWER_SUPPLY_PROP_ENERGY_NOW, value);
9650 pr_info("%s: make fg_reset true again for actual normal booting\n", __func__);
9651 }
9652
9653 if ((battery->cable_type == SEC_BATTERY_CABLE_NONE) ||
9654 (battery->cable_type == SEC_BATTERY_CABLE_PREPARE_TA)) {
9655 queue_delayed_work(battery->monitor_wqueue, &battery->init_chg_work, 0);
9656
9657 dev_info(&pdev->dev,
9658 "%s: SEC Battery Driver Monitorwork\n", __func__);
9659 wake_lock(&battery->monitor_wake_lock);
9660 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
9661 }
9662
9663 if (battery->pdata->check_battery_callback)
9664 battery->present = battery->pdata->check_battery_callback();
9665
9666 dev_info(battery->dev,
9667 "%s: SEC Battery Driver Loaded\n", __func__);
9668 return 0;
9669
9670 err_req_irq:
9671 if (battery->pdata->bat_irq)
9672 free_irq(battery->pdata->bat_irq, battery);
9673 power_supply_unregister(battery->psy_bat);
9674 err_supply_unreg_ac:
9675 power_supply_unregister(battery->psy_ac);
9676 err_supply_unreg_usb:
9677 power_supply_unregister(battery->psy_usb);
9678 err_supply_unreg_wireless:
9679 power_supply_unregister(battery->psy_wireless);
9680 err_supply_unreg_ps:
9681 power_supply_unregister(battery->psy_ps);
9682 err_workqueue:
9683 destroy_workqueue(battery->monitor_wqueue);
9684 err_irq:
9685 wake_lock_destroy(&battery->monitor_wake_lock);
9686 wake_lock_destroy(&battery->cable_wake_lock);
9687 wake_lock_destroy(&battery->vbus_wake_lock);
9688 wake_lock_destroy(&battery->afc_wake_lock);
9689 wake_lock_destroy(&battery->siop_level_wake_lock);
9690 wake_lock_destroy(&battery->ext_event_wake_lock);
9691 wake_lock_destroy(&battery->wc_headroom_wake_lock);
9692 #if defined(CONFIG_UPDATE_BATTERY_DATA)
9693 wake_lock_destroy(&battery->batt_data_wake_lock);
9694 #endif
9695 wake_lock_destroy(&battery->misc_event_wake_lock);
9696 #ifdef CONFIG_OF
9697 wake_lock_destroy(&battery->parse_mode_dt_wake_lock);
9698 #endif
9699 mutex_destroy(&battery->adclock);
9700 mutex_destroy(&battery->iolock);
9701 mutex_destroy(&battery->misclock);
9702 mutex_destroy(&battery->batt_handlelock);
9703 mutex_destroy(&battery->current_eventlock);
9704 mutex_destroy(&battery->typec_notylock);
9705 mutex_destroy(&battery->wclock);
9706 #if defined(CONFIG_BATTERY_SBM_DATA)
9707 mutex_destroy(&battery->sbmlock);
9708 sec_bat_exit_sbm(battery);
9709 #endif
9710 kfree(pdata);
9711 err_bat_free:
9712 kfree(battery);
9713
9714 return ret;
9715 }
9716
9717 static int sec_battery_remove(struct platform_device *pdev)
9718 {
9719 struct sec_battery_info *battery = platform_get_drvdata(pdev);
9720 #ifndef CONFIG_OF
9721 int i;
9722 #endif
9723
9724 dev_dbg(battery->dev, "%s: Start\n", __func__);
9725
9726 switch (battery->pdata->polling_type) {
9727 case SEC_BATTERY_MONITOR_WORKQUEUE:
9728 cancel_delayed_work(&battery->polling_work);
9729 break;
9730 case SEC_BATTERY_MONITOR_ALARM:
9731 alarm_cancel(&battery->polling_alarm);
9732 break;
9733 default:
9734 break;
9735 }
9736
9737 flush_workqueue(battery->monitor_wqueue);
9738 destroy_workqueue(battery->monitor_wqueue);
9739 wake_lock_destroy(&battery->monitor_wake_lock);
9740 wake_lock_destroy(&battery->cable_wake_lock);
9741 wake_lock_destroy(&battery->vbus_wake_lock);
9742 wake_lock_destroy(&battery->afc_wake_lock);
9743 wake_lock_destroy(&battery->siop_level_wake_lock);
9744 wake_lock_destroy(&battery->ext_event_wake_lock);
9745 wake_lock_destroy(&battery->misc_event_wake_lock);
9746 mutex_destroy(&battery->adclock);
9747 mutex_destroy(&battery->iolock);
9748 mutex_destroy(&battery->misclock);
9749 mutex_destroy(&battery->batt_handlelock);
9750 mutex_destroy(&battery->current_eventlock);
9751 mutex_destroy(&battery->typec_notylock);
9752 mutex_destroy(&battery->wclock);
9753
9754 #if defined(CONFIG_BATTERY_SBM_DATA)
9755 mutex_destroy(&battery->sbmlock);
9756 sec_bat_exit_sbm(battery);
9757 #endif
9758
9759 #ifdef CONFIG_OF
9760 adc_exit(battery);
9761 #else
9762 for (i = 0; i < SEC_BAT_ADC_CHANNEL_NUM; i++)
9763 adc_exit(battery->pdata, i);
9764 #endif
9765 power_supply_unregister(battery->psy_ps);
9766 power_supply_unregister(battery->psy_wireless);
9767 power_supply_unregister(battery->psy_ac);
9768 power_supply_unregister(battery->psy_usb);
9769 power_supply_unregister(battery->psy_bat);
9770
9771 dev_dbg(battery->dev, "%s: End\n", __func__);
9772 kfree(battery);
9773
9774 return 0;
9775 }
9776
9777 static int sec_battery_prepare(struct device *dev)
9778 {
9779 struct sec_battery_info *battery
9780 = dev_get_drvdata(dev);
9781
9782 dev_info(battery->dev, "%s: Start\n", __func__);
9783
9784 switch (battery->pdata->polling_type) {
9785 case SEC_BATTERY_MONITOR_WORKQUEUE:
9786 cancel_delayed_work(&battery->polling_work);
9787 break;
9788 case SEC_BATTERY_MONITOR_ALARM:
9789 alarm_cancel(&battery->polling_alarm);
9790 break;
9791 default:
9792 break;
9793 }
9794
9795 /* monitor_wake_lock should be unlocked before cancle monitor_work */
9796 wake_unlock(&battery->monitor_wake_lock);
9797 cancel_delayed_work_sync(&battery->monitor_work);
9798
9799 battery->polling_in_sleep = true;
9800
9801 sec_bat_set_polling(battery);
9802
9803 /* cancel work for polling
9804 * that is set in sec_bat_set_polling()
9805 * no need for polling in sleep
9806 */
9807 if (battery->pdata->polling_type ==
9808 SEC_BATTERY_MONITOR_WORKQUEUE)
9809 cancel_delayed_work(&battery->polling_work);
9810
9811 dev_info(battery->dev, "%s: End\n", __func__);
9812
9813 return 0;
9814 }
9815
9816 static int sec_battery_suspend(struct device *dev)
9817 {
9818 return 0;
9819 }
9820
9821 static int sec_battery_resume(struct device *dev)
9822 {
9823 return 0;
9824 }
9825
9826 static void sec_battery_complete(struct device *dev)
9827 {
9828 struct sec_battery_info *battery
9829 = dev_get_drvdata(dev);
9830
9831 dev_info(battery->dev, "%s: Start\n", __func__);
9832
9833 /* cancel current alarm and reset after monitor work */
9834 if (battery->pdata->polling_type == SEC_BATTERY_MONITOR_ALARM)
9835 alarm_cancel(&battery->polling_alarm);
9836
9837 wake_lock(&battery->monitor_wake_lock);
9838 queue_delayed_work(battery->monitor_wqueue,
9839 &battery->monitor_work, 0);
9840
9841 dev_info(battery->dev, "%s: End\n", __func__);
9842
9843 return;
9844 }
9845
9846 static void sec_battery_shutdown(struct platform_device *pdev)
9847 {
9848 struct sec_battery_info *battery
9849 = platform_get_drvdata(pdev);
9850
9851 switch (battery->pdata->polling_type) {
9852 case SEC_BATTERY_MONITOR_WORKQUEUE:
9853 cancel_delayed_work(&battery->polling_work);
9854 break;
9855 case SEC_BATTERY_MONITOR_ALARM:
9856 alarm_cancel(&battery->polling_alarm);
9857 break;
9858 default:
9859 break;
9860 }
9861 }
9862
9863 #ifdef CONFIG_OF
9864 static struct of_device_id sec_battery_dt_ids[] = {
9865 { .compatible = "samsung,sec-battery" },
9866 { }
9867 };
9868 MODULE_DEVICE_TABLE(of, sec_battery_dt_ids);
9869 #endif /* CONFIG_OF */
9870
9871 static const struct dev_pm_ops sec_battery_pm_ops = {
9872 .prepare = sec_battery_prepare,
9873 .suspend = sec_battery_suspend,
9874 .resume = sec_battery_resume,
9875 .complete = sec_battery_complete,
9876 };
9877
9878 static struct platform_driver sec_battery_driver = {
9879 .driver = {
9880 .name = "sec-battery",
9881 .owner = THIS_MODULE,
9882 .pm = &sec_battery_pm_ops,
9883 #ifdef CONFIG_OF
9884 .of_match_table = sec_battery_dt_ids,
9885 #endif
9886 },
9887 .probe = sec_battery_probe,
9888 .remove = sec_battery_remove,
9889 .shutdown = sec_battery_shutdown,
9890 };
9891
9892 static int __init sec_battery_init(void)
9893 {
9894 return platform_driver_register(&sec_battery_driver);
9895 }
9896
9897 static void __exit sec_battery_exit(void)
9898 {
9899 platform_driver_unregister(&sec_battery_driver);
9900 }
9901
9902 late_initcall(sec_battery_init);
9903 module_exit(sec_battery_exit);
9904
9905 MODULE_DESCRIPTION("Samsung Battery Driver");
9906 MODULE_AUTHOR("Samsung Electronics");
9907 MODULE_LICENSE("GPL");