projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import PULS_20180308
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / power / mt8127 / charging_hw_fan5405.c
CommitLineData
6fa3eb70
S		 1/*****************************************************************************
2 *
3 * Filename:
4 * ---------
5 * charging_pmic.c
6 *
7 * Project:
8 * --------
9 * ALPS_Software
10 *
11 * Description:
12 * ------------
13 * This file implements the interface between BMT and ADC scheduler.
14 *
15 * Author:
16 * -------
17 * Oscar Liu
18 *
19 *============================================================================
20 * $Revision: 1.0 $
21 * $Modtime: 11 Aug 2005 10:28:16 $
22 * $Log: //mtkvs01/vmdata/Maui_sw/archives/mcu/hal/peripheral/inc/bmt_chr_setting.h-arc $
23 * HISTORY
24 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
25 *------------------------------------------------------------------------------
26 *------------------------------------------------------------------------------
27 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
28 *============================================================================
29 ****************************************************************************/
30#include <mach/charging.h>
31#include "fan5405.h"
32#include <mach/upmu_common.h>
33#include <mach/mt_gpio.h>
34#include <mach/upmu_hw.h>
35#include <linux/xlog.h>
36#include <linux/delay.h>
37#include <mach/mt_sleep.h>
38#include <mach/mt_boot.h>
39#include <mach/system.h>
40#include <cust_charging.h>
41
42
43#ifdef CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT
44#include <mach/diso.h>
45#include "cust_diso.h"
46#include <linux/of.h>
47#include <linux/of_irq.h>
48#ifdef MTK_DISCRETE_SWITCH
49#include <mach/eint.h>
50#include <cust_eint.h>
51#include <mach/mt_gpio.h>
52#include <cust_gpio_usage.h>
53#endif
54#if !defined(MTK_AUXADC_IRQ_SUPPORT)
55#include <linux/kthread.h>
56#include <linux/wakelock.h>
57#include <linux/mutex.h>
58#include <linux/hrtimer.h>
59#include <linux/workqueue.h>
60#endif
61#endif
62
63
64 // ============================================================ //
65 //define
66 // ============================================================ //
67#define STATUS_OK 0
68#define STATUS_UNSUPPORTED -1
69#define GETARRAYNUM(array) (sizeof(array)/sizeof(array[0]))
70
71
72 // ============================================================ //
73 //global variable
74 // ============================================================ //
75static CHARGER_TYPE g_charger_type = CHARGER_UNKNOWN;
76
77#if defined(CONFIG_MTK_WIRELESS_CHARGER_SUPPORT)
78#define WIRELESS_CHARGER_EXIST_STATE 0
79int wireless_charger_gpio_number = (168 | 0x80000000);
80#endif
81
82#if 0
83#include <cust_gpio_usage.h>
84int gpio_number = GPIO_SWCHARGER_EN_PIN;
85int gpio_off_mode = GPIO_SWCHARGER_EN_PIN_M_GPIO;
86int gpio_on_mode = GPIO_SWCHARGER_EN_PIN_M_GPIO;
87#else
88int gpio_number = (19 | 0x80000000);
89int gpio_off_mode = 0;
90int gpio_on_mode = 0;
91#endif
92int gpio_off_dir = GPIO_DIR_OUT;
93int gpio_off_out = GPIO_OUT_ONE;
94int gpio_on_dir = GPIO_DIR_OUT;
95int gpio_on_out = GPIO_OUT_ZERO;
96
97kal_bool charging_type_det_done = KAL_TRUE;
98
99const kal_uint32 VBAT_CV_VTH[]=
100{
101 BATTERY_VOLT_03_500000_V, BATTERY_VOLT_03_520000_V, BATTERY_VOLT_03_540000_V, BATTERY_VOLT_03_560000_V,
102 BATTERY_VOLT_03_580000_V, BATTERY_VOLT_03_600000_V, BATTERY_VOLT_03_620000_V, BATTERY_VOLT_03_640000_V,
103 BATTERY_VOLT_03_660000_V, BATTERY_VOLT_03_680000_V, BATTERY_VOLT_03_700000_V, BATTERY_VOLT_03_720000_V,
104 BATTERY_VOLT_03_740000_V, BATTERY_VOLT_03_760000_V, BATTERY_VOLT_03_780000_V, BATTERY_VOLT_03_800000_V,
105 BATTERY_VOLT_03_820000_V, BATTERY_VOLT_03_840000_V, BATTERY_VOLT_03_860000_V, BATTERY_VOLT_03_880000_V,
106 BATTERY_VOLT_03_900000_V, BATTERY_VOLT_03_920000_V, BATTERY_VOLT_03_940000_V, BATTERY_VOLT_03_960000_V,
107 BATTERY_VOLT_03_980000_V, BATTERY_VOLT_04_000000_V, BATTERY_VOLT_04_020000_V, BATTERY_VOLT_04_040000_V,
108 BATTERY_VOLT_04_060000_V, BATTERY_VOLT_04_080000_V, BATTERY_VOLT_04_100000_V, BATTERY_VOLT_04_120000_V,
109 BATTERY_VOLT_04_140000_V, BATTERY_VOLT_04_160000_V, BATTERY_VOLT_04_180000_V, BATTERY_VOLT_04_200000_V,
110 BATTERY_VOLT_04_220000_V, BATTERY_VOLT_04_240000_V, BATTERY_VOLT_04_260000_V, BATTERY_VOLT_04_280000_V,
111 BATTERY_VOLT_04_300000_V, BATTERY_VOLT_04_320000_V, BATTERY_VOLT_04_340000_V, BATTERY_VOLT_04_360000_V,
112 BATTERY_VOLT_04_380000_V, BATTERY_VOLT_04_400000_V, BATTERY_VOLT_04_420000_V, BATTERY_VOLT_04_440000_V
113
114};
115
116const kal_uint32 CS_VTH[]=
117{
118 CHARGE_CURRENT_550_00_MA, CHARGE_CURRENT_650_00_MA, CHARGE_CURRENT_750_00_MA, CHARGE_CURRENT_850_00_MA,
119 CHARGE_CURRENT_950_00_MA, CHARGE_CURRENT_1050_00_MA, CHARGE_CURRENT_1150_00_MA, CHARGE_CURRENT_1250_00_MA
120};
121
122 const kal_uint32 INPUT_CS_VTH[]=
123 {
124 CHARGE_CURRENT_100_00_MA, CHARGE_CURRENT_500_00_MA, CHARGE_CURRENT_800_00_MA, CHARGE_CURRENT_MAX
125 };
126
127 const kal_uint32 VCDT_HV_VTH[]=
128 {
129 BATTERY_VOLT_04_200000_V, BATTERY_VOLT_04_250000_V, BATTERY_VOLT_04_300000_V, BATTERY_VOLT_04_350000_V,
130 BATTERY_VOLT_04_400000_V, BATTERY_VOLT_04_450000_V, BATTERY_VOLT_04_500000_V, BATTERY_VOLT_04_550000_V,
131 BATTERY_VOLT_04_600000_V, BATTERY_VOLT_06_000000_V, BATTERY_VOLT_06_500000_V, BATTERY_VOLT_07_000000_V,
132 BATTERY_VOLT_07_500000_V, BATTERY_VOLT_08_500000_V, BATTERY_VOLT_09_500000_V, BATTERY_VOLT_10_500000_V
133 };
134
135#ifdef CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT
136#ifndef CUST_GPIO_VIN_SEL
137#define CUST_GPIO_VIN_SEL 18
138#endif
139#if !defined(MTK_AUXADC_IRQ_SUPPORT)
140#define SW_POLLING_PERIOD 100 //100 ms
141#define MSEC_TO_NSEC(x) (x * 1000000UL)
142
143 static DEFINE_MUTEX(diso_polling_mutex);
144 static DECLARE_WAIT_QUEUE_HEAD(diso_polling_thread_wq);
145 static struct hrtimer diso_kthread_timer;
146 static kal_bool diso_thread_timeout = KAL_FALSE;
147 static struct delayed_work diso_polling_work;
148 static void diso_polling_handler(struct work_struct *work);
149 static DISO_Polling_Data DISO_Polling;
150#else
151 DISO_IRQ_Data DISO_IRQ;
152#endif
153 int g_diso_state = 0;
154 int vin_sel_gpio_number = (CUST_GPIO_VIN_SEL | 0x80000000);
155 static kal_bool g_diso_otg = KAL_FALSE;
156
157 static char *DISO_state_s[8] = {
158 "IDLE",
159 "OTG_ONLY",
160 "USB_ONLY",
161 "USB_WITH_OTG",
162 "DC_ONLY",
163 "DC_WITH_OTG",
164 "DC_WITH_USB",
165 "DC_USB_OTG",
166 };
167#endif
168
169
170 // ============================================================ //
171 // function prototype
172 // ============================================================ //
173
174
175 // ============================================================ //
176 //extern variable
177 // ============================================================ //
178
179 // ============================================================ //
180 //extern function
181 // ============================================================ //
182 extern void do_chrdet_int_task(void);
183 extern kal_uint32 upmu_get_reg_value(kal_uint32 reg);
184 extern bool mt_usb_is_device(void);
185 extern void Charger_Detect_Init(void);
186 extern void Charger_Detect_Release(void);
187 extern void mt_power_off(void);
188
189 static kal_uint32 charging_error = false;
190 static kal_uint32 charging_get_error_state(void);
191 static kal_uint32 charging_set_error_state(void *data);
192 // ============================================================ //
193 kal_uint32 charging_value_to_parameter(const kal_uint32 *parameter, const kal_uint32 array_size, const kal_uint32 val)
194{
195 if (val < array_size)
196 {
197 return parameter[val];
198 }
199 else
200 {
201 battery_xlog_printk(BAT_LOG_CRTI, "Can't find the parameter \r\n");
202 return parameter[0];
203 }
204}
205
206
207 kal_uint32 charging_parameter_to_value(const kal_uint32 *parameter, const kal_uint32 array_size, const kal_uint32 val)
208{
209 kal_uint32 i;
210
211 for(i=0;i<array_size;i++)
212 {
213 if (val == *(parameter + i))
214 {
215 return i;
216 }
217 }
218
219 battery_xlog_printk(BAT_LOG_CRTI, "NO register value match \r\n");
220 //TODO: ASSERT(0); // not find the value
221 return 0;
222}
223
224
225 static kal_uint32 bmt_find_closest_level(const kal_uint32 *pList,kal_uint32 number,kal_uint32 level)
226 {
227 kal_uint32 i;
228 kal_uint32 max_value_in_last_element;
229
230 if(pList[0] < pList[1])
231 max_value_in_last_element = KAL_TRUE;
232 else
233 max_value_in_last_element = KAL_FALSE;
234
235 if(max_value_in_last_element == KAL_TRUE)
236 {
237 for(i = (number-1); i != 0; i--) //max value in the last element
238 {
239 if(pList[i] <= level)
240 {
241 return pList[i];
242 }
243 }
244
245 battery_xlog_printk(BAT_LOG_CRTI, "Can't find closest level, small value first \r\n");
246 return pList[0];
247 //return CHARGE_CURRENT_0_00_MA;
248 }
249 else
250 {
251 for(i = 0; i< number; i++) // max value in the first element
252 {
253 if(pList[i] <= level)
254 {
255 return pList[i];
256 }
257 }
258
259 battery_xlog_printk(BAT_LOG_CRTI, "Can't find closest level, large value first \r\n");
260 return pList[number -1];
261 //return CHARGE_CURRENT_0_00_MA;
262 }
263 }
264
265
266static void hw_bc11_dump_register(void)
267{
268 kal_uint32 reg_val = 0;
269 kal_uint32 reg_num = CHR_CON18;
270 kal_uint32 i = 0;
271
272 for(i=reg_num ; i<=CHR_CON19 ; i+=2)
273 {
274 reg_val = upmu_get_reg_value(i);
275 battery_xlog_printk(BAT_LOG_FULL, "Chr Reg[0x%x]=0x%x \r\n", i, reg_val);
276 }
277}
278
279
280 static void hw_bc11_init(void)
281 {
282 msleep(300);
283 Charger_Detect_Init();
284
285 //RG_BC11_BIAS_EN=1
286 upmu_set_rg_bc11_bias_en(0x1);
287 //RG_BC11_VSRC_EN[1:0]=00
288 upmu_set_rg_bc11_vsrc_en(0x0);
289 //RG_BC11_VREF_VTH = [1:0]=00
290 upmu_set_rg_bc11_vref_vth(0x0);
291 //RG_BC11_CMP_EN[1.0] = 00
292 upmu_set_rg_bc11_cmp_en(0x0);
293 //RG_BC11_IPU_EN[1.0] = 00
294 upmu_set_rg_bc11_ipu_en(0x0);
295 //RG_BC11_IPD_EN[1.0] = 00
296 upmu_set_rg_bc11_ipd_en(0x0);
297 //BC11_RST=1
298 upmu_set_rg_bc11_rst(0x1);
299 //BC11_BB_CTRL=1
300 upmu_set_rg_bc11_bb_ctrl(0x1);
301
302 //msleep(10);
303 mdelay(50);
304
305 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
306 {
307 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_init() \r\n");
308 hw_bc11_dump_register();
309 }
310
311 }
312
313
314 static U32 hw_bc11_DCD(void)
315 {
316 U32 wChargerAvail = 0;
317
318 //RG_BC11_IPU_EN[1.0] = 10
319 upmu_set_rg_bc11_ipu_en(0x2);
320 //RG_BC11_IPD_EN[1.0] = 01
321 upmu_set_rg_bc11_ipd_en(0x1);
322 //RG_BC11_VREF_VTH = [1:0]=01
323 upmu_set_rg_bc11_vref_vth(0x1);
324 //RG_BC11_CMP_EN[1.0] = 10
325 upmu_set_rg_bc11_cmp_en(0x2);
326
327 //msleep(20);
328 mdelay(80);
329
330 wChargerAvail = upmu_get_rgs_bc11_cmp_out();
331
332 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
333 {
334 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_DCD() \r\n");
335 hw_bc11_dump_register();
336 }
337
338 //RG_BC11_IPU_EN[1.0] = 00
339 upmu_set_rg_bc11_ipu_en(0x0);
340 //RG_BC11_IPD_EN[1.0] = 00
341 upmu_set_rg_bc11_ipd_en(0x0);
342 //RG_BC11_CMP_EN[1.0] = 00
343 upmu_set_rg_bc11_cmp_en(0x0);
344 //RG_BC11_VREF_VTH = [1:0]=00
345 upmu_set_rg_bc11_vref_vth(0x0);
346
347 return wChargerAvail;
348 }
349
350
351 static U32 hw_bc11_stepA1(void)
352 {
353 U32 wChargerAvail = 0;
354
355 //RG_BC11_IPU_EN[1.0] = 10
356 upmu_set_rg_bc11_ipu_en(0x2);
357 //RG_BC11_VREF_VTH = [1:0]=10
358 upmu_set_rg_bc11_vref_vth(0x2);
359 //RG_BC11_CMP_EN[1.0] = 10
360 upmu_set_rg_bc11_cmp_en(0x2);
361
362 //msleep(80);
363 mdelay(80);
364
365 wChargerAvail = upmu_get_rgs_bc11_cmp_out();
366
367 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
368 {
369 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_stepA1() \r\n");
370 hw_bc11_dump_register();
371 }
372
373 //RG_BC11_IPU_EN[1.0] = 00
374 upmu_set_rg_bc11_ipu_en(0x0);
375 //RG_BC11_CMP_EN[1.0] = 00
376 upmu_set_rg_bc11_cmp_en(0x0);
377
378 return wChargerAvail;
379 }
380
381
382 static U32 hw_bc11_stepB1(void)
383 {
384 U32 wChargerAvail = 0;
385
386 //RG_BC11_IPU_EN[1.0] = 01
387 //upmu_set_rg_bc11_ipu_en(0x1);
388 upmu_set_rg_bc11_ipd_en(0x1);
389 //RG_BC11_VREF_VTH = [1:0]=10
390 //upmu_set_rg_bc11_vref_vth(0x2);
391 upmu_set_rg_bc11_vref_vth(0x0);
392 //RG_BC11_CMP_EN[1.0] = 01
393 upmu_set_rg_bc11_cmp_en(0x1);
394
395 //msleep(80);
396 mdelay(80);
397
398 wChargerAvail = upmu_get_rgs_bc11_cmp_out();
399
400 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
401 {
402 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_stepB1() \r\n");
403 hw_bc11_dump_register();
404 }
405
406 //RG_BC11_IPU_EN[1.0] = 00
407 upmu_set_rg_bc11_ipu_en(0x0);
408 //RG_BC11_CMP_EN[1.0] = 00
409 upmu_set_rg_bc11_cmp_en(0x0);
410 //RG_BC11_VREF_VTH = [1:0]=00
411 upmu_set_rg_bc11_vref_vth(0x0);
412
413 return wChargerAvail;
414 }
415
416
417 static U32 hw_bc11_stepC1(void)
418 {
419 U32 wChargerAvail = 0;
420
421 //RG_BC11_IPU_EN[1.0] = 01
422 upmu_set_rg_bc11_ipu_en(0x1);
423 //RG_BC11_VREF_VTH = [1:0]=10
424 upmu_set_rg_bc11_vref_vth(0x2);
425 //RG_BC11_CMP_EN[1.0] = 01
426 upmu_set_rg_bc11_cmp_en(0x1);
427
428 //msleep(80);
429 mdelay(80);
430
431 wChargerAvail = upmu_get_rgs_bc11_cmp_out();
432
433 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
434 {
435 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_stepC1() \r\n");
436 hw_bc11_dump_register();
437 }
438
439 //RG_BC11_IPU_EN[1.0] = 00
440 upmu_set_rg_bc11_ipu_en(0x0);
441 //RG_BC11_CMP_EN[1.0] = 00
442 upmu_set_rg_bc11_cmp_en(0x0);
443 //RG_BC11_VREF_VTH = [1:0]=00
444 upmu_set_rg_bc11_vref_vth(0x0);
445
446 return wChargerAvail;
447 }
448
449
450 static U32 hw_bc11_stepA2(void)
451 {
452 U32 wChargerAvail = 0;
453
454 //RG_BC11_VSRC_EN[1.0] = 10
455 upmu_set_rg_bc11_vsrc_en(0x2);
456 //RG_BC11_IPD_EN[1:0] = 01
457 upmu_set_rg_bc11_ipd_en(0x1);
458 //RG_BC11_VREF_VTH = [1:0]=00
459 upmu_set_rg_bc11_vref_vth(0x0);
460 //RG_BC11_CMP_EN[1.0] = 01
461 upmu_set_rg_bc11_cmp_en(0x1);
462
463 //msleep(80);
464 mdelay(80);
465
466 wChargerAvail = upmu_get_rgs_bc11_cmp_out();
467
468 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
469 {
470 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_stepA2() \r\n");
471 hw_bc11_dump_register();
472 }
473
474 //RG_BC11_VSRC_EN[1:0]=00
475 upmu_set_rg_bc11_vsrc_en(0x0);
476 //RG_BC11_IPD_EN[1.0] = 00
477 upmu_set_rg_bc11_ipd_en(0x0);
478 //RG_BC11_CMP_EN[1.0] = 00
479 upmu_set_rg_bc11_cmp_en(0x0);
480
481 return wChargerAvail;
482 }
483
484
485 static U32 hw_bc11_stepB2(void)
486 {
487 U32 wChargerAvail = 0;
488
489 //RG_BC11_IPU_EN[1:0]=10
490 upmu_set_rg_bc11_ipu_en(0x2);
491 //RG_BC11_VREF_VTH = [1:0]=10
492 upmu_set_rg_bc11_vref_vth(0x1);
493 //RG_BC11_CMP_EN[1.0] = 01
494 upmu_set_rg_bc11_cmp_en(0x1);
495
496 //msleep(80);
497 mdelay(80);
498
499 wChargerAvail = upmu_get_rgs_bc11_cmp_out();
500
501 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
502 {
503 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_stepB2() \r\n");
504 hw_bc11_dump_register();
505 }
506
507 //RG_BC11_IPU_EN[1.0] = 00
508 upmu_set_rg_bc11_ipu_en(0x0);
509 //RG_BC11_CMP_EN[1.0] = 00
510 upmu_set_rg_bc11_cmp_en(0x0);
511 //RG_BC11_VREF_VTH = [1:0]=00
512 upmu_set_rg_bc11_vref_vth(0x0);
513
514 return wChargerAvail;
515 }
516
517
518 static void hw_bc11_done(void)
519 {
520 //RG_BC11_VSRC_EN[1:0]=00
521 upmu_set_rg_bc11_vsrc_en(0x0);
522 //RG_BC11_VREF_VTH = [1:0]=0
523 upmu_set_rg_bc11_vref_vth(0x0);
524 //RG_BC11_CMP_EN[1.0] = 00
525 upmu_set_rg_bc11_cmp_en(0x0);
526 //RG_BC11_IPU_EN[1.0] = 00
527 upmu_set_rg_bc11_ipu_en(0x0);
528 //RG_BC11_IPD_EN[1.0] = 00
529 upmu_set_rg_bc11_ipd_en(0x0);
530 //RG_BC11_BIAS_EN=0
531 upmu_set_rg_bc11_bias_en(0x0);
532
533 Charger_Detect_Release();
534
535 if(Enable_BATDRV_LOG == BAT_LOG_FULL)
536 {
537 battery_xlog_printk(BAT_LOG_FULL, "hw_bc11_done() \r\n");
538 hw_bc11_dump_register();
539 }
540
541 }
542
543
544 static kal_uint32 charging_hw_init(void *data)
545 {
546 kal_uint32 status = STATUS_OK;
547 static bool charging_init_flag = KAL_FALSE;
548
549#ifdef CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT
550 mt_set_gpio_mode(vin_sel_gpio_number,0); // 0:GPIO mode
551 mt_set_gpio_dir(vin_sel_gpio_number,0); // 0: input, 1: output
552#endif
553
554 mt_set_gpio_mode(gpio_number,gpio_on_mode);
555 mt_set_gpio_dir(gpio_number,gpio_on_dir);
556 mt_set_gpio_out(gpio_number,gpio_on_out);
557#if defined(CONFIG_MTK_WIRELESS_CHARGER_SUPPORT)
558 mt_set_gpio_mode(wireless_charger_gpio_number,0); // 0:GPIO mode
559 mt_set_gpio_dir(wireless_charger_gpio_number,0); // 0: input, 1: output
560#endif
561
562 battery_xlog_printk(BAT_LOG_FULL, "gpio_number=0x%x,gpio_on_mode=%d,gpio_off_mode=%d\n", gpio_number, gpio_on_mode, gpio_off_mode);
563 upmu_set_rg_usbdl_set(0); //force leave USBDL mode
564 upmu_set_rg_usbdl_rst(1); //force leave USBDL mode
565
566 #if defined(HIGH_BATTERY_VOLTAGE_SUPPORT)
4b9e9796 567 fan5405_reg_config_interface(0x06,0x78); // ISAFE = 1250mA, VSAFE = 4.36V
6fa3eb70
S		 568 #else
569 fan5405_reg_config_interface(0x06,0x70);
570 #endif
571
572#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT) && defined(MTK_LOAD_SWITCH_FPF3040)
573 fan5405_reg_config_interface(0x01,0xbc); //TE=1, CE=1, HZ_MODE=0, OPA_MODE=0
574#else
575 fan5405_reg_config_interface(0x01,0xb8); //TE=1, CE=0, HZ_MODE=0, OPA_MODE=0
576#endif
577
578 fan5405_reg_config_interface(0x00,0xC0); //kick chip watch dog
579 fan5405_reg_config_interface(0x05,0x03);
580 if ( !charging_init_flag ) {
581 fan5405_reg_config_interface(0x04,0x1C); //243mA
582 charging_init_flag = KAL_TRUE;
583 }
584 return status;
585 }
586
587
588 static kal_uint32 charging_dump_register(void *data)
589 {
590 kal_uint32 status = STATUS_OK;
591
592 fan5405_dump_register();
593
594 return status;
595 }
596
597
598 static kal_uint32 charging_enable(void *data)
599 {
600 kal_uint32 status = STATUS_OK;
601 kal_uint32 enable = *(kal_uint32*)(data);
602
603 if(KAL_TRUE == enable)
604 {
605 fan5405_set_ce(0);
606 fan5405_set_hz_mode(0);
607 fan5405_set_opa_mode(0);
608 }
609 else
610 {
611
612#if defined(CONFIG_USB_MTK_HDRC_HCD)
613 if(mt_usb_is_device())
614#endif
615 {
616 mt_set_gpio_mode(gpio_number,gpio_off_mode);
617 mt_set_gpio_dir(gpio_number,gpio_off_dir);
618 mt_set_gpio_out(gpio_number,gpio_off_out);
619
620 fan5405_set_ce(1);
621 }
622 }
623
624 return status;
625 }
626
627
628 static kal_uint32 charging_set_cv_voltage(void *data)
629 {
630 kal_uint32 status = STATUS_OK;
631 kal_uint16 register_value;
632
633 register_value = charging_parameter_to_value(VBAT_CV_VTH, GETARRAYNUM(VBAT_CV_VTH) ,*(kal_uint32 *)(data));
4b9e9796 634
6fa3eb70
S		 635 fan5405_set_oreg(register_value);
636
637 return status;
638 }
639
640
641 static kal_uint32 charging_get_current(void *data)
642 {
643 kal_uint32 status = STATUS_OK;
644 kal_uint32 array_size;
645 kal_uint8 reg_value;
646
647 //Get current level
648 array_size = GETARRAYNUM(CS_VTH);
649 fan5405_read_interface(0x1, &reg_value, 0x3, 0x6); //IINLIM
650 *(kal_uint32 *)data = charging_value_to_parameter(CS_VTH,array_size,reg_value);
651
652 return status;
653 }
654
655
656
657 static kal_uint32 charging_set_current(void *data)
658 {
659 kal_uint32 status = STATUS_OK;
660 kal_uint32 set_chr_current;
661 kal_uint32 array_size;
662 kal_uint32 register_value;
663 kal_uint32 current_value = *(kal_uint32 *)data;
664
665 if(current_value <= CHARGE_CURRENT_350_00_MA)
666 {
667 fan5405_set_io_level(1);
668 }
669 else
670 {
671 fan5405_set_io_level(0);
672 array_size = GETARRAYNUM(CS_VTH);
673 set_chr_current = bmt_find_closest_level(CS_VTH, array_size, current_value);
674 register_value = charging_parameter_to_value(CS_VTH, array_size ,set_chr_current);
675 fan5405_set_iocharge(register_value);
676 }
677 return status;
678 }
679
680
681 static kal_uint32 charging_set_input_current(void *data)
682 {
683 kal_uint32 status = STATUS_OK;
684 kal_uint32 set_chr_current;
685 kal_uint32 array_size;
686 kal_uint32 register_value;
687
688 if(*(kal_uint32 *)data > CHARGE_CURRENT_500_00_MA)
689 {
690 register_value = 0x3;
691 }
692 else
693 {
694 array_size = GETARRAYNUM(INPUT_CS_VTH);
695 set_chr_current = bmt_find_closest_level(INPUT_CS_VTH, array_size, *(kal_uint32 *)data);
696 register_value = charging_parameter_to_value(INPUT_CS_VTH, array_size ,set_chr_current);
697 }
698
699 fan5405_set_input_charging_current(register_value);
700
701 return status;
702 }
703
704
705 static kal_uint32 charging_get_charging_status(void *data)
706 {
707 kal_uint32 status = STATUS_OK;
708 kal_uint32 ret_val;
709
710 ret_val = fan5405_get_chip_status();
711
712 if(ret_val == 0x2)
713 *(kal_uint32 *)data = KAL_TRUE;
714 else
715 *(kal_uint32 *)data = KAL_FALSE;
716
717 return status;
718 }
719
720
721 static kal_uint32 charging_reset_watch_dog_timer(void *data)
722 {
723 kal_uint32 status = STATUS_OK;
724
725 fan5405_set_tmr_rst(1);
726
727 return status;
728 }
729
730
731 static kal_uint32 charging_set_hv_threshold(void *data)
732 {
733 kal_uint32 status = STATUS_OK;
734
735 kal_uint32 set_hv_voltage;
736 kal_uint32 array_size;
737 kal_uint16 register_value;
738 kal_uint32 voltage = *(kal_uint32*)(data);
739
740 array_size = GETARRAYNUM(VCDT_HV_VTH);
741 set_hv_voltage = bmt_find_closest_level(VCDT_HV_VTH, array_size, voltage);
742 register_value = charging_parameter_to_value(VCDT_HV_VTH, array_size ,set_hv_voltage);
743 upmu_set_rg_vcdt_hv_vth(register_value);
744
745 return status;
746 }
747
748
749 static kal_uint32 charging_get_hv_status(void *data)
750 {
751 kal_uint32 status = STATUS_OK;
752
753 *(kal_bool*)(data) = upmu_get_rgs_vcdt_hv_det();
754
755 return status;
756 }
757
758
759 static kal_uint32 charging_get_battery_status(void *data)
760 {
761 kal_uint32 status = STATUS_OK;
762
763 upmu_set_baton_tdet_en(1);
764 upmu_set_rg_baton_en(1);
765 *(kal_bool*)(data) = upmu_get_rgs_baton_undet();
766
767 return status;
768 }
769
770
771static kal_uint32 charging_get_charger_det_status(void *data)
772{
773 kal_uint32 status = STATUS_OK;
774 kal_uint32 val = 0;
775
776#if defined(CONFIG_POWER_EXT) || defined(CONFIG_MTK_FPGA)
777 val = 1;
778 battery_xlog_printk(BAT_LOG_CRTI,"[charging_get_charger_det_status] charger exist for bring up.\n");
779#else
780 #if !defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
781 val = upmu_get_rgs_chrdet();
782 #else
783 if(((g_diso_state >> 1) & 0x3) != 0x0 || (upmu_get_rgs_chrdet() && !g_diso_otg))
784 val = KAL_TRUE;
785 else
786 val = KAL_FALSE;
787 #endif
788
789#endif
790
791 *(kal_bool*)(data) = val;
792 if(val == 0)
793 g_charger_type = CHARGER_UNKNOWN;
794
795 return status;
796}
797
798
799kal_bool charging_type_detection_done(void)
800{
801 return charging_type_det_done;
802}
803
804
805extern CHARGER_TYPE hw_charger_type_detection(void);
806 static kal_uint32 charging_get_charger_type(void *data)
807 {
808 kal_uint32 status = STATUS_OK;
809 CHARGER_TYPE charger_type = CHARGER_UNKNOWN;
810#if defined(CONFIG_POWER_EXT)
811 *(CHARGER_TYPE*)(data) = STANDARD_HOST;
812#else
813
814#if defined(CONFIG_MTK_WIRELESS_CHARGER_SUPPORT)
815 int wireless_state = 0;
816 wireless_state = mt_get_gpio_in(wireless_charger_gpio_number);
817 if(wireless_state == WIRELESS_CHARGER_EXIST_STATE)
818 {
819 *(CHARGER_TYPE*)(data) = WIRELESS_CHARGER;
820 battery_xlog_printk(BAT_LOG_CRTI, "WIRELESS_CHARGER!\r\n");
821 return status;
822 }
823#endif
824 if(g_charger_type!=CHARGER_UNKNOWN && g_charger_type!=WIRELESS_CHARGER)
825 {
826 *(CHARGER_TYPE*)(data) = g_charger_type;
827 battery_xlog_printk(BAT_LOG_CRTI, "return %d!\r\n", g_charger_type);
828 return status;
829 }
830
831 charging_type_det_done = KAL_FALSE;
832
833#if 1
834 charger_type = hw_charger_type_detection();
835 battery_xlog_printk(BAT_LOG_CRTI, "charging_get_charger_type = %d\r\n", charger_type);
836
837 *(CHARGER_TYPE*)(data) = charger_type;
838#endif
839#if 0
840 /********* Step initial ***************/
841 hw_bc11_init();
842
843 /********* Step DCD ***************/
844 if(1 == hw_bc11_DCD())
845 {
846 /********* Step A1 ***************/
847 if(1 == hw_bc11_stepA1())
848 {
849 /********* Step B1 ***************/
850 if(1 == hw_bc11_stepB1())
851 {
852 //*(CHARGER_TYPE*)(data) = NONSTANDARD_CHARGER;
853 //battery_xlog_printk(BAT_LOG_CRTI, "step B1 : Non STANDARD CHARGER!\r\n");
854 *(CHARGER_TYPE*)(data) = APPLE_2_1A_CHARGER;
855 battery_xlog_printk(BAT_LOG_CRTI, "step B1 : Apple 2.1A CHARGER!\r\n");
856 }
857 else
858 {
859 //*(CHARGER_TYPE*)(data) = APPLE_2_1A_CHARGER;
860 //battery_xlog_printk(BAT_LOG_CRTI, "step B1 : Apple 2.1A CHARGER!\r\n");
861 *(CHARGER_TYPE*)(data) = NONSTANDARD_CHARGER;
862 battery_xlog_printk(BAT_LOG_CRTI, "step B1 : Non STANDARD CHARGER!\r\n");
863 }
864 }
865 else
866 {
867 /********* Step C1 ***************/
868 if(1 == hw_bc11_stepC1())
869 {
870 *(CHARGER_TYPE*)(data) = APPLE_1_0A_CHARGER;
871 battery_xlog_printk(BAT_LOG_CRTI, "step C1 : Apple 1A CHARGER!\r\n");
872 }
873 else
874 {
875 *(CHARGER_TYPE*)(data) = APPLE_0_5A_CHARGER;
876 battery_xlog_printk(BAT_LOG_CRTI, "step C1 : Apple 0.5A CHARGER!\r\n");
877 }
878 }
879
880 }
881 else
882 {
883 /********* Step A2 ***************/
884 if(1 == hw_bc11_stepA2())
885 {
886 /********* Step B2 ***************/
887 if(1 == hw_bc11_stepB2())
888 {
889 *(CHARGER_TYPE*)(data) = STANDARD_CHARGER;
890 battery_xlog_printk(BAT_LOG_CRTI, "step B2 : STANDARD CHARGER!\r\n");
891 }
892 else
893 {
894 *(CHARGER_TYPE*)(data) = CHARGING_HOST;
895 battery_xlog_printk(BAT_LOG_CRTI, "step B2 : Charging Host!\r\n");
896 }
897 }
898 else
899 {
900 *(CHARGER_TYPE*)(data) = STANDARD_HOST;
901 battery_xlog_printk(BAT_LOG_CRTI, "step A2 : Standard USB Host!\r\n");
902 }
903
904 }
905
906 /********* Finally setting *******************************/
907 hw_bc11_done();
908
909 charging_type_det_done = KAL_TRUE;
910
911 g_charger_type = *(CHARGER_TYPE*)(data);
912#endif
913 charging_type_det_done = KAL_TRUE;
914
915 g_charger_type = *(CHARGER_TYPE*)(data);
916#endif
917 return status;
918}
919
920static kal_uint32 charging_get_is_pcm_timer_trigger(void *data)
921{
922 kal_uint32 status = STATUS_OK;
923
924 if(slp_get_wake_reason() == WR_PCM_TIMER)
925 *(kal_bool*)(data) = KAL_TRUE;
926 else
927 *(kal_bool*)(data) = KAL_FALSE;
928
929 battery_xlog_printk(BAT_LOG_CRTI, "slp_get_wake_reason=%d\n", slp_get_wake_reason());
930
931 return status;
932}
933
934static kal_uint32 charging_set_platform_reset(void *data)
935{
936 kal_uint32 status = STATUS_OK;
937
938 battery_xlog_printk(BAT_LOG_CRTI, "charging_set_platform_reset\n");
939
940 arch_reset(0,NULL);
941
942 return status;
943}
944
945static kal_uint32 charging_get_platfrom_boot_mode(void *data)
946{
947 kal_uint32 status = STATUS_OK;
948
949 *(kal_uint32*)(data) = get_boot_mode();
950
951 battery_xlog_printk(BAT_LOG_CRTI, "get_boot_mode=%d\n", get_boot_mode());
952
953 return status;
954}
955
956static kal_uint32 charging_set_power_off(void *data)
957{
958 kal_uint32 status = STATUS_OK;
959
960 battery_xlog_printk(BAT_LOG_CRTI, "charging_set_power_off\n");
961 mt_power_off();
962
963 return status;
964}
965
966static kal_uint32 charging_get_power_source(void *data)
967{
968 kal_uint32 status = STATUS_OK;
969
970 #if 0 //#if defined(MTK_POWER_EXT_DETECT)
971 if (MT_BOARD_PHONE == mt_get_board_type())
972 *(kal_bool *)data = KAL_FALSE;
973 else
974 *(kal_bool *)data = KAL_TRUE;
975 #else
976 *(kal_bool *)data = KAL_FALSE;
977 #endif
978
979 return status;
980}
981
982static kal_uint32 charging_get_csdac_full_flag(void *data)
983{
984 return STATUS_UNSUPPORTED;
985}
986
987static kal_uint32 charging_set_ta_current_pattern(void *data)
988{
989 return STATUS_UNSUPPORTED;
990}
991
992 #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
993 void set_diso_otg(bool enable)
994 {
995 g_diso_otg = enable;
996 }
997 void set_vusb_auxadc_irq(bool enable, bool flag)
998 {
999 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1000 hrtimer_cancel(&diso_kthread_timer);
1001
1002 DISO_Polling.reset_polling = KAL_TRUE;
1003 DISO_Polling.vusb_polling_measure.notify_irq_en = enable;
1004 DISO_Polling.vusb_polling_measure.notify_irq = flag;
1005
1006 hrtimer_start(&diso_kthread_timer, ktime_set(0, MSEC_TO_NSEC(SW_POLLING_PERIOD)), HRTIMER_MODE_REL);
1007 #else
1008 kal_uint16 threshold = 0;
1009 if (enable) {
1010 if (flag == 0)
1011 threshold = DISO_IRQ.vusb_measure_channel.falling_threshold;
1012 else
1013 threshold = DISO_IRQ.vusb_measure_channel.rising_threshold;
1014
1015 threshold = (threshold *R_DISO_VBUS_PULL_DOWN)/(R_DISO_VBUS_PULL_DOWN + R_DISO_VBUS_PULL_UP);
1016 mt_auxadc_enableBackgroundDection(DISO_IRQ.vusb_measure_channel.number, threshold, \
1017 DISO_IRQ.vusb_measure_channel.period, DISO_IRQ.vusb_measure_channel.debounce, flag);
1018 } else {
1019 mt_auxadc_disableBackgroundDection(DISO_IRQ.vusb_measure_channel.number);
1020 }
1021 #endif
1022 battery_xlog_printk(BAT_LOG_FULL, " [%s] enable: %d, flag: %d!\n", __func__, enable, flag);
1023 }
1024
1025 void set_vdc_auxadc_irq(bool enable, bool flag)
1026 {
1027 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1028 hrtimer_cancel(&diso_kthread_timer);
1029
1030 DISO_Polling.reset_polling = KAL_TRUE;
1031 DISO_Polling.vdc_polling_measure.notify_irq_en = enable;
1032 DISO_Polling.vdc_polling_measure.notify_irq = flag;
1033
1034 hrtimer_start(&diso_kthread_timer, ktime_set(0, MSEC_TO_NSEC(SW_POLLING_PERIOD)), HRTIMER_MODE_REL);
1035 #else
1036 kal_uint16 threshold = 0;
1037 if(enable) {
1038 if(flag == 0)
1039 threshold = DISO_IRQ.vdc_measure_channel.falling_threshold;
1040 else
1041 threshold = DISO_IRQ.vdc_measure_channel.rising_threshold;
1042
1043 threshold = (threshold *R_DISO_DC_PULL_DOWN)/(R_DISO_DC_PULL_DOWN + R_DISO_DC_PULL_UP);
1044 mt_auxadc_enableBackgroundDection(DISO_IRQ.vdc_measure_channel.number, threshold, \
1045 DISO_IRQ.vdc_measure_channel.period, DISO_IRQ.vdc_measure_channel.debounce, flag);
1046 } else {
1047 mt_auxadc_disableBackgroundDection(DISO_IRQ.vdc_measure_channel.number);
1048 }
1049 #endif
1050 battery_xlog_printk(BAT_LOG_FULL, " [%s] enable: %d, flag: %d!\n", __func__, enable, flag);
1051 }
1052
1053 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1054 static void diso_polling_handler(struct work_struct *work)
1055 {
1056 int trigger_channel = -1;
1057 int trigger_flag = -1;
1058
1059 if(DISO_Polling.vdc_polling_measure.notify_irq_en)
1060 trigger_channel = AP_AUXADC_DISO_VDC_CHANNEL;
1061 else if(DISO_Polling.vusb_polling_measure.notify_irq_en)
1062 trigger_channel = AP_AUXADC_DISO_VUSB_CHANNEL;
1063
1064 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]auxadc handler triggered\n" );
1065 switch(trigger_channel)
1066 {
1067 case AP_AUXADC_DISO_VDC_CHANNEL:
1068 trigger_flag = DISO_Polling.vdc_polling_measure.notify_irq;
1069 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]VDC IRQ triggered, channel ==%d, flag ==%d\n", trigger_channel, trigger_flag );
1070 #ifdef MTK_DISCRETE_SWITCH /*for DSC DC plugin handle */
1071 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1072 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1073 set_vusb_auxadc_irq(DISO_IRQ_ENABLE, DISO_IRQ_FALLING);
1074 if (trigger_flag == DISO_IRQ_RISING) {
1075 DISO_data.diso_state.pre_vusb_state = DISO_ONLINE;
1076 DISO_data.diso_state.pre_vdc_state = DISO_OFFLINE;
1077 DISO_data.diso_state.pre_otg_state = DISO_OFFLINE;
1078 DISO_data.diso_state.cur_vusb_state = DISO_ONLINE;
1079 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1080 DISO_data.diso_state.cur_otg_state = DISO_OFFLINE;
1081 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[2]);
1082 }
1083 #else //for load switch OTG leakage handle
1084 set_vdc_auxadc_irq(DISO_IRQ_ENABLE, (~trigger_flag) & 0x1);
1085 if (trigger_flag == DISO_IRQ_RISING) {
1086 DISO_data.diso_state.pre_vusb_state = DISO_OFFLINE;
1087 DISO_data.diso_state.pre_vdc_state = DISO_OFFLINE;
1088 DISO_data.diso_state.pre_otg_state = DISO_ONLINE;
1089 DISO_data.diso_state.cur_vusb_state = DISO_OFFLINE;
1090 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1091 DISO_data.diso_state.cur_otg_state = DISO_ONLINE;
1092 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[5]);
1093 } else if (trigger_flag == DISO_IRQ_FALLING) {
1094 DISO_data.diso_state.pre_vusb_state = DISO_OFFLINE;
1095 DISO_data.diso_state.pre_vdc_state = DISO_ONLINE;
1096 DISO_data.diso_state.pre_otg_state = DISO_ONLINE;
1097 DISO_data.diso_state.cur_vusb_state = DISO_OFFLINE;
1098 DISO_data.diso_state.cur_vdc_state = DISO_OFFLINE;
1099 DISO_data.diso_state.cur_otg_state = DISO_ONLINE;
1100 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[1]);
1101 }
1102 else
1103 battery_xlog_printk(BAT_LOG_CRTI, "[%s] wrong trigger flag!\n",__func__);
1104 #endif
1105 break;
1106 case AP_AUXADC_DISO_VUSB_CHANNEL:
1107 trigger_flag = DISO_Polling.vusb_polling_measure.notify_irq;
1108 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]VUSB IRQ triggered, channel ==%d, flag ==%d\n", trigger_channel, trigger_flag);
1109 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1110 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1111 if(trigger_flag == DISO_IRQ_FALLING) {
1112 DISO_data.diso_state.pre_vusb_state = DISO_ONLINE;
1113 DISO_data.diso_state.pre_vdc_state = DISO_ONLINE;
1114 DISO_data.diso_state.pre_otg_state = DISO_OFFLINE;
1115 DISO_data.diso_state.cur_vusb_state = DISO_OFFLINE;
1116 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1117 DISO_data.diso_state.cur_otg_state = DISO_OFFLINE;
1118 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[4]);
1119 } else if (trigger_flag == DISO_IRQ_RISING) {
1120 DISO_data.diso_state.pre_vusb_state = DISO_OFFLINE;
1121 DISO_data.diso_state.pre_vdc_state = DISO_ONLINE;
1122 DISO_data.diso_state.pre_otg_state = DISO_OFFLINE;
1123 DISO_data.diso_state.cur_vusb_state = DISO_ONLINE;
1124 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1125 DISO_data.diso_state.cur_otg_state = DISO_OFFLINE;
1126 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[6]);
1127 }
1128 else
1129 battery_xlog_printk(BAT_LOG_CRTI, "[%s] wrong trigger flag!\n",__func__);
1130 set_vusb_auxadc_irq(DISO_IRQ_ENABLE, (~trigger_flag)&0x1);
1131 break;
1132 default:
1133 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1134 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1135 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]VUSB auxadc IRQ triggered ERROR OR TEST\n");
1136 return; /* in error or unexecpt state just return */
1137 }
1138
1139 g_diso_state = *(int*)&DISO_data.diso_state;
1140 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]g_diso_state: 0x%x\n", g_diso_state);
1141 DISO_data.irq_callback_func(0, NULL);
1142
1143 return ;
1144 }
1145 #else
1146 static irqreturn_t diso_auxadc_irq_handler(int irq, void *dev_id)
1147 {
1148 int trigger_channel = -1;
1149 int trigger_flag = -1;
1150 trigger_channel = mt_auxadc_getCurrentChannel();
1151 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]auxadc handler triggered\n" );
1152 switch(trigger_channel)
1153 {
1154 case AP_AUXADC_DISO_VDC_CHANNEL:
1155 trigger_flag = mt_auxadc_getCurrentTrigger();
1156 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]VDC IRQ triggered, channel ==%d, flag ==%d\n", trigger_channel, trigger_flag );
1157 #ifdef MTK_DISCRETE_SWITCH /*for DSC DC plugin handle */
1158 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1159 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1160 set_vusb_auxadc_irq(DISO_IRQ_ENABLE, DISO_IRQ_FALLING);
1161 if (trigger_flag == DISO_IRQ_RISING) {
1162 DISO_data.diso_state.pre_vusb_state = DISO_ONLINE;
1163 DISO_data.diso_state.pre_vdc_state = DISO_OFFLINE;
1164 DISO_data.diso_state.pre_otg_state = DISO_OFFLINE;
1165 DISO_data.diso_state.cur_vusb_state = DISO_ONLINE;
1166 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1167 DISO_data.diso_state.cur_otg_state = DISO_OFFLINE;
1168 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[2]);
1169 }
1170 #else //for load switch OTG leakage handle
1171 set_vdc_auxadc_irq(DISO_IRQ_ENABLE, (~trigger_flag) & 0x1);
1172 if (trigger_flag == DISO_IRQ_RISING) {
1173 DISO_data.diso_state.pre_vusb_state = DISO_OFFLINE;
1174 DISO_data.diso_state.pre_vdc_state = DISO_OFFLINE;
1175 DISO_data.diso_state.pre_otg_state = DISO_ONLINE;
1176 DISO_data.diso_state.cur_vusb_state = DISO_OFFLINE;
1177 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1178 DISO_data.diso_state.cur_otg_state = DISO_ONLINE;
1179 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[5]);
1180 } else {
1181 DISO_data.diso_state.pre_vusb_state = DISO_OFFLINE;
1182 DISO_data.diso_state.pre_vdc_state = DISO_ONLINE;
1183 DISO_data.diso_state.pre_otg_state = DISO_ONLINE;
1184 DISO_data.diso_state.cur_vusb_state = DISO_OFFLINE;
1185 DISO_data.diso_state.cur_vdc_state = DISO_OFFLINE;
1186 DISO_data.diso_state.cur_otg_state = DISO_ONLINE;
1187 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[1]);
1188 }
1189 #endif
1190 break;
1191 case AP_AUXADC_DISO_VUSB_CHANNEL:
1192 trigger_flag = mt_auxadc_getCurrentTrigger();
1193 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]VUSB IRQ triggered, channel ==%d, flag ==%d\n", trigger_channel, trigger_flag);
1194 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1195 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1196 if(trigger_flag == DISO_IRQ_FALLING) {
1197 DISO_data.diso_state.pre_vusb_state = DISO_ONLINE;
1198 DISO_data.diso_state.pre_vdc_state = DISO_ONLINE;
1199 DISO_data.diso_state.pre_otg_state = DISO_OFFLINE;
1200 DISO_data.diso_state.cur_vusb_state = DISO_OFFLINE;
1201 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1202 DISO_data.diso_state.cur_otg_state = DISO_OFFLINE;
1203 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[4]);
1204 } else {
1205 DISO_data.diso_state.pre_vusb_state = DISO_OFFLINE;
1206 DISO_data.diso_state.pre_vdc_state = DISO_ONLINE;
1207 DISO_data.diso_state.pre_otg_state = DISO_OFFLINE;
1208 DISO_data.diso_state.cur_vusb_state = DISO_ONLINE;
1209 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1210 DISO_data.diso_state.cur_otg_state = DISO_OFFLINE;
1211 battery_xlog_printk(BAT_LOG_CRTI, " cur diso_state is %s!\n",DISO_state_s[6]);
1212 }
1213
1214 set_vusb_auxadc_irq(DISO_IRQ_ENABLE, (~trigger_flag)&0x1);
1215 break;
1216 default:
1217 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1218 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1219 battery_xlog_printk(BAT_LOG_CRTI, "[DISO]VUSB auxadc IRQ triggered ERROR OR TEST\n");
1220 return IRQ_HANDLED; /* in error or unexecpt state just return */
1221 }
1222 g_diso_state = *(int*)&DISO_data.diso_state;
1223 return IRQ_WAKE_THREAD;
1224 }
1225 #endif
1226
1227 #if defined(MTK_DISCRETE_SWITCH) && defined(MTK_DSC_USE_EINT)
1228 void vdc_eint_handler()
1229 {
1230 battery_xlog_printk(BAT_LOG_CRTI, "[diso_eint] vdc eint irq triger\n");
1231 DISO_data.diso_state.cur_vdc_state = DISO_ONLINE;
1232 mt_eint_mask(CUST_EINT_VDC_NUM);
1233 do_chrdet_int_task();
1234 }
1235 #endif
1236
1237 static kal_uint32 diso_get_current_voltage(int Channel)
1238 {
1239 int ret = 0, data[4], i, ret_value = 0, ret_temp = 0, times = 5;
1240
1241 if( IMM_IsAdcInitReady() == 0 ) {
1242 battery_xlog_printk(BAT_LOG_CRTI, "[DISO] AUXADC is not ready");
1243 return 0;
1244 }
1245
1246 i = times;
1247 while (i--)
1248 {
1249 ret_value = IMM_GetOneChannelValue(Channel, data, &ret_temp);
1250 if(ret_value == 0) {
1251 ret += ret_temp;
1252 } else {
1253 times = times > 1 ? times - 1 : 1;
1254 battery_xlog_printk(BAT_LOG_CRTI, "[diso_get_current_voltage] ret_value=%d, times=%d\n",
1255 ret_value, times);
1256 }
1257 }
1258
1259 ret = ret*1500/4096 ;
1260 ret = ret/times;
1261
1262 return ret;
1263 }
1264
1265 static void _get_diso_interrupt_state(void)
1266 {
1267 int vol = 0;
1268 int diso_state =0;
1269 int check_times = 30;
1270 kal_bool vin_state = KAL_FALSE;
1271
1272 #ifndef VIN_SEL_FLAG
1273 mdelay(AUXADC_CHANNEL_DELAY_PERIOD);
1274 #endif
1275
1276 vol = diso_get_current_voltage(AP_AUXADC_DISO_VDC_CHANNEL);
1277 vol =(R_DISO_DC_PULL_UP + R_DISO_DC_PULL_DOWN)*100*vol/(R_DISO_DC_PULL_DOWN)/100;
1278 battery_xlog_printk(BAT_LOG_CRTI, "[DISO] Current DC voltage mV = %d\n", vol);
1279
1280 #ifdef VIN_SEL_FLAG
1281 /* set gpio mode for kpoc issue as DWS has no default setting */
1282 mt_set_gpio_mode(vin_sel_gpio_number,0); // 0:GPIO mode
1283 mt_set_gpio_dir(vin_sel_gpio_number,0); // 0: input, 1: output
1284
1285 if (vol > VDC_MIN_VOLTAGE/1000 && vol < VDC_MAX_VOLTAGE/1000) {
1286 /* make sure load switch already switch done */
1287 do{
1288 check_times--;
1289 #ifdef VIN_SEL_FLAG_DEFAULT_LOW
1290 vin_state = mt_get_gpio_in(vin_sel_gpio_number);
1291 #else
1292 vin_state = mt_get_gpio_in(vin_sel_gpio_number);
1293 vin_state = (~vin_state) & 0x1;
1294 #endif
1295 if(!vin_state)
1296 mdelay(5);
1297 } while ((!vin_state) && check_times);
1298 battery_xlog_printk(BAT_LOG_CRTI, "[DISO] i==%d gpio_state= %d\n",
1299 check_times, mt_get_gpio_in(vin_sel_gpio_number));
1300
1301 if (0 == check_times)
1302 diso_state &= ~0x4; //SET DC bit as 0
1303 else
1304 diso_state |= 0x4; //SET DC bit as 1
1305 } else {
1306 diso_state &= ~0x4; //SET DC bit as 0
1307 }
1308 #else
1309 mdelay(SWITCH_RISING_TIMING + LOAD_SWITCH_TIMING_MARGIN); /* force delay for switching as no flag for check switching done */
1310 if (vol > VDC_MIN_VOLTAGE/1000 && vol < VDC_MAX_VOLTAGE/1000)
1311 diso_state |= 0x4; //SET DC bit as 1
1312 else
1313 diso_state &= ~0x4; //SET DC bit as 0
1314 #endif
1315
1316
1317 vol = diso_get_current_voltage(AP_AUXADC_DISO_VUSB_CHANNEL);
1318 vol =(R_DISO_VBUS_PULL_UP + R_DISO_VBUS_PULL_DOWN)*100*vol/(R_DISO_VBUS_PULL_DOWN)/100;
1319 battery_xlog_printk(BAT_LOG_CRTI, "[DISO] Current VBUS voltage mV = %d\n",vol);
1320
1321 if (vol > VBUS_MIN_VOLTAGE/1000 && vol < VBUS_MAX_VOLTAGE/1000) {
1322 if(!mt_usb_is_device()) {
1323 diso_state |= 0x1; //SET OTG bit as 1
1324 diso_state &= ~0x2; //SET VBUS bit as 0
1325 } else {
1326 diso_state &= ~0x1; //SET OTG bit as 0
1327 diso_state |= 0x2; //SET VBUS bit as 1;
1328 }
1329
1330 } else {
1331 diso_state &= 0x4; //SET OTG and VBUS bit as 0
1332 }
1333 battery_xlog_printk(BAT_LOG_CRTI, "[DISO] DISO_STATE==0x%x \n",diso_state);
1334 g_diso_state = diso_state;
1335 return;
1336 }
1337 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1338 int _get_irq_direction(int pre_vol, int cur_vol)
1339 {
1340 int ret = -1;
1341
1342 //threshold 1000mv
1343 if((cur_vol - pre_vol) > 1000)
1344 ret = DISO_IRQ_RISING;
1345 else if((pre_vol - cur_vol) > 1000)
1346 ret = DISO_IRQ_FALLING;
1347
1348 return ret;
1349 }
1350
1351 static void _get_polling_state(void)
1352 {
1353 int vdc_vol = 0, vusb_vol = 0;
1354 int vdc_vol_dir = -1;
1355 int vusb_vol_dir = -1;
1356
1357 DISO_polling_channel* VDC_Polling = &DISO_Polling.vdc_polling_measure;
1358 DISO_polling_channel* VUSB_Polling = &DISO_Polling.vusb_polling_measure;
1359
1360 vdc_vol = diso_get_current_voltage(AP_AUXADC_DISO_VDC_CHANNEL);
1361 vdc_vol =(R_DISO_DC_PULL_UP + R_DISO_DC_PULL_DOWN)*100*vdc_vol/(R_DISO_DC_PULL_DOWN)/100;
1362
1363 vusb_vol = diso_get_current_voltage(AP_AUXADC_DISO_VUSB_CHANNEL);
1364 vusb_vol =(R_DISO_VBUS_PULL_UP + R_DISO_VBUS_PULL_DOWN)*100*vusb_vol/(R_DISO_VBUS_PULL_DOWN)/100;
1365
1366 VDC_Polling->preVoltage = VDC_Polling->curVoltage;
1367 VUSB_Polling->preVoltage = VUSB_Polling->curVoltage;
1368 VDC_Polling->curVoltage = vdc_vol;
1369 VUSB_Polling->curVoltage = vusb_vol;
1370
1371 if (DISO_Polling.reset_polling)
1372 {
1373 DISO_Polling.reset_polling = KAL_FALSE;
1374 VDC_Polling->preVoltage = vdc_vol;
1375 VUSB_Polling->preVoltage = vusb_vol;
1376
1377 if(vdc_vol > 1000)
1378 vdc_vol_dir = DISO_IRQ_RISING;
1379 else
1380 vdc_vol_dir = DISO_IRQ_FALLING;
1381
1382 if(vusb_vol > 1000)
1383 vusb_vol_dir = DISO_IRQ_RISING;
1384 else
1385 vusb_vol_dir = DISO_IRQ_FALLING;
1386 }
1387 else
1388 {
1389 //get voltage direction
1390 vdc_vol_dir = _get_irq_direction(VDC_Polling->preVoltage, VDC_Polling->curVoltage);
1391 vusb_vol_dir = _get_irq_direction(VUSB_Polling->preVoltage, VUSB_Polling->curVoltage);
1392 }
1393
1394 if(VDC_Polling->notify_irq_en &&
1395 (vdc_vol_dir == VDC_Polling->notify_irq)) {
1396 schedule_delayed_work(&diso_polling_work, 10*HZ/1000); //10ms
1397 battery_xlog_printk(BAT_LOG_CRTI, "[%s] ready to trig VDC irq, irq: %d\n",
1398 __func__,VDC_Polling->notify_irq);
1399 } else if(VUSB_Polling->notify_irq_en &&
1400 (vusb_vol_dir == VUSB_Polling->notify_irq)) {
1401 schedule_delayed_work(&diso_polling_work, 10*HZ/1000);
1402 battery_xlog_printk(BAT_LOG_CRTI, "[%s] ready to trig VUSB irq, irq: %d\n",
1403 __func__, VUSB_Polling->notify_irq);
1404 } else if((vdc_vol == 0) && (vusb_vol == 0)) {
1405 VDC_Polling->notify_irq_en = 0;
1406 VUSB_Polling->notify_irq_en = 0;
1407 }
1408
1409 return;
1410 }
1411
1412 enum hrtimer_restart diso_kthread_hrtimer_func(struct hrtimer *timer)
1413 {
1414 diso_thread_timeout = KAL_TRUE;
1415 wake_up(&diso_polling_thread_wq);
1416
1417 return HRTIMER_NORESTART;
1418 }
1419
1420 int diso_thread_kthread(void *x)
1421 {
1422 /* Run on a process content */
1423 while (1) {
1424 wait_event(diso_polling_thread_wq, (diso_thread_timeout == KAL_TRUE));
1425
1426 diso_thread_timeout = KAL_FALSE;
1427
1428 mutex_lock(&diso_polling_mutex);
1429
1430 _get_polling_state();
1431
1432 if (DISO_Polling.vdc_polling_measure.notify_irq_en ||
1433 DISO_Polling.vusb_polling_measure.notify_irq_en)
1434 hrtimer_start(&diso_kthread_timer,ktime_set(0, MSEC_TO_NSEC(SW_POLLING_PERIOD)),HRTIMER_MODE_REL);
1435 else
1436 hrtimer_cancel(&diso_kthread_timer);
1437
1438 mutex_unlock(&diso_polling_mutex);
1439 }
1440
1441 return 0;
1442 }
1443 #endif
1444 #endif
1445
1446
1447 static kal_uint32 charging_get_error_state(void)
1448 {
1449 return charging_error;
1450 }
1451
1452 static kal_uint32 charging_set_error_state(void *data)
1453 {
1454 kal_uint32 status = STATUS_OK;
1455 charging_error = *(kal_uint32*)(data);
1456
1457 return status;
1458 }
1459
1460
1461 static kal_uint32 charging_diso_init(void *data)
1462 {
1463 kal_uint32 status = STATUS_OK;
1464
1465#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
1466 DISO_ChargerStruct *pDISO_data = (DISO_ChargerStruct *)data;
1467
1468 /* Initialization DISO Struct */
1469 pDISO_data->diso_state.cur_otg_state = DISO_OFFLINE;
1470 pDISO_data->diso_state.cur_vusb_state = DISO_OFFLINE;
1471 pDISO_data->diso_state.cur_vdc_state = DISO_OFFLINE;
1472
1473 pDISO_data->diso_state.pre_otg_state = DISO_OFFLINE;
1474 pDISO_data->diso_state.pre_vusb_state = DISO_OFFLINE;
1475 pDISO_data->diso_state.pre_vdc_state = DISO_OFFLINE;
1476
1477 pDISO_data->chr_get_diso_state = KAL_FALSE;
1478 pDISO_data->hv_voltage = VBUS_MAX_VOLTAGE;
1479
1480 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1481 hrtimer_init(&diso_kthread_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1482 diso_kthread_timer.function = diso_kthread_hrtimer_func;
1483 INIT_DELAYED_WORK(&diso_polling_work, diso_polling_handler);
1484
1485 kthread_run(diso_thread_kthread, NULL, "diso_thread_kthread");
1486 battery_xlog_printk(BAT_LOG_CRTI, "[%s] done\n", __func__);
1487 #else
1488 struct device_node *node;
1489 int ret;
1490
1491 //Initial AuxADC IRQ
1492 DISO_data.irq_line_number = LOWBATTERY_IRQ_ID;
1493 DISO_IRQ.vdc_measure_channel.number = AP_AUXADC_DISO_VDC_CHANNEL;
1494 DISO_IRQ.vusb_measure_channel.number = AP_AUXADC_DISO_VUSB_CHANNEL;
1495 DISO_IRQ.vdc_measure_channel.period = AUXADC_CHANNEL_DELAY_PERIOD;
1496 DISO_IRQ.vusb_measure_channel.period = AUXADC_CHANNEL_DELAY_PERIOD;
1497 DISO_IRQ.vdc_measure_channel.debounce = AUXADC_CHANNEL_DEBOUNCE;
1498 DISO_IRQ.vusb_measure_channel.debounce = AUXADC_CHANNEL_DEBOUNCE;
1499
1500 /* use default threshold voltage, if use high voltage,maybe refine*/
1501 DISO_IRQ.vusb_measure_channel.falling_threshold = VBUS_MIN_VOLTAGE/1000;
1502 DISO_IRQ.vdc_measure_channel.falling_threshold = VDC_MIN_VOLTAGE/1000;
1503 DISO_IRQ.vusb_measure_channel.rising_threshold = VBUS_MIN_VOLTAGE/1000;
1504 DISO_IRQ.vdc_measure_channel.rising_threshold = VDC_MIN_VOLTAGE/1000;
1505
1506 mt_irq_set_sens(pDISO_data->irq_line_number, MT_EDGE_SENSITIVE);
1507 mt_irq_set_polarity(pDISO_data->irq_line_number, MT_POLARITY_LOW);
1508
1509 ret = request_threaded_irq(pDISO_data->irq_line_number, diso_auxadc_irq_handler, \
1510 pDISO_data->irq_callback_func, IRQF_ONESHOT , "DISO_ADC_IRQ", NULL);
1511
1512 if (ret) {
1513 battery_xlog_printk(BAT_LOG_CRTI, "[diso_adc]: request_irq failed.\n");
1514 } else {
1515 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1516 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1517 battery_xlog_printk(BAT_LOG_CRTI, "[diso_adc]: diso_init success.\n");
1518 }
1519 #endif
1520
1521 #if defined(MTK_DISCRETE_SWITCH) && defined(MTK_DSC_USE_EINT)
1522 battery_xlog_printk(BAT_LOG_CRTI, "[diso_eint]vdc eint irq registitation\n");
1523 mt_eint_set_hw_debounce(CUST_EINT_VDC_NUM, CUST_EINT_VDC_DEBOUNCE_CN);
1524 mt_eint_registration(CUST_EINT_VDC_NUM, CUST_EINTF_TRIGGER_LOW, vdc_eint_handler, 0);
1525 mt_eint_mask(CUST_EINT_VDC_NUM);
1526 #endif
1527#endif
1528
1529 return status;
1530 }
1531
1532 static kal_uint32 charging_get_diso_state(void *data)
1533 {
1534 kal_uint32 status = STATUS_OK;
1535
1536#if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
1537 int diso_state = 0x0;
1538 DISO_ChargerStruct *pDISO_data = (DISO_ChargerStruct *)data;
1539
1540 _get_diso_interrupt_state();
1541 diso_state = g_diso_state;
1542 battery_xlog_printk(BAT_LOG_CRTI, "[do_chrdet_int_task] current diso state is %s!\n", DISO_state_s[diso_state]);
1543 if(((diso_state >> 1) & 0x3) != 0x0)
1544 {
1545 switch (diso_state){
1546 case USB_ONLY:
1547 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1548 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1549 #ifdef MTK_DISCRETE_SWITCH
1550 #ifdef MTK_DSC_USE_EINT
1551 mt_eint_unmask(CUST_EINT_VDC_NUM);
1552 #else
1553 set_vdc_auxadc_irq(DISO_IRQ_ENABLE, 1);
1554 #endif
1555 #endif
1556 pDISO_data->diso_state.cur_vusb_state = DISO_ONLINE;
1557 pDISO_data->diso_state.cur_vdc_state = DISO_OFFLINE;
1558 pDISO_data->diso_state.cur_otg_state = DISO_OFFLINE;
1559 break;
1560 case DC_ONLY:
1561 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1562 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1563 set_vusb_auxadc_irq(DISO_IRQ_ENABLE, DISO_IRQ_RISING);
1564 pDISO_data->diso_state.cur_vusb_state = DISO_OFFLINE;
1565 pDISO_data->diso_state.cur_vdc_state = DISO_ONLINE;
1566 pDISO_data->diso_state.cur_otg_state = DISO_OFFLINE;
1567 break;
1568 case DC_WITH_USB:
1569 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1570 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1571 set_vusb_auxadc_irq(DISO_IRQ_ENABLE,DISO_IRQ_FALLING);
1572 pDISO_data->diso_state.cur_vusb_state = DISO_ONLINE;
1573 pDISO_data->diso_state.cur_vdc_state = DISO_ONLINE;
1574 pDISO_data->diso_state.cur_otg_state = DISO_OFFLINE;
1575 break;
1576 case DC_WITH_OTG:
1577 set_vdc_auxadc_irq(DISO_IRQ_DISABLE, 0);
1578 set_vusb_auxadc_irq(DISO_IRQ_DISABLE, 0);
1579 pDISO_data->diso_state.cur_vusb_state = DISO_OFFLINE;
1580 pDISO_data->diso_state.cur_vdc_state = DISO_ONLINE;
1581 pDISO_data->diso_state.cur_otg_state = DISO_ONLINE;
1582 break;
1583 default: // OTG only also can trigger vcdt IRQ
1584 pDISO_data->diso_state.cur_vusb_state = DISO_OFFLINE;
1585 pDISO_data->diso_state.cur_vdc_state = DISO_OFFLINE;
1586 pDISO_data->diso_state.cur_otg_state = DISO_ONLINE;
1587 battery_xlog_printk(BAT_LOG_CRTI, " switch load vcdt irq triggerd by OTG Boost!\n");
1588 break; // OTG plugin no need battery sync action
1589 }
1590 }
1591
1592 if (DISO_ONLINE == pDISO_data->diso_state.cur_vdc_state)
1593 pDISO_data->hv_voltage = VDC_MAX_VOLTAGE;
1594 else
1595 pDISO_data->hv_voltage = VBUS_MAX_VOLTAGE;
1596#endif
1597
1598 return status;
1599 }
1600
1601
1602 static kal_uint32 (* const charging_func[CHARGING_CMD_NUMBER])(void *data)=
1603 {
1604 charging_hw_init
1605 ,charging_dump_register
1606 ,charging_enable
1607 ,charging_set_cv_voltage
1608 ,charging_get_current
1609 ,charging_set_current
1610 ,charging_set_input_current
1611 ,charging_get_charging_status
1612 ,charging_reset_watch_dog_timer
1613 ,charging_set_hv_threshold
1614 ,charging_get_hv_status
1615 ,charging_get_battery_status
1616 ,charging_get_charger_det_status
1617 ,charging_get_charger_type
1618 ,charging_get_is_pcm_timer_trigger
1619 ,charging_set_platform_reset
1620 ,charging_get_platfrom_boot_mode
1621 ,charging_set_power_off
1622 ,charging_get_power_source
1623 ,charging_get_csdac_full_flag
1624 ,charging_set_ta_current_pattern
1625 ,charging_set_error_state
1626 ,charging_diso_init
1627 ,charging_get_diso_state
1628 };
1629
1630
1631 /*
1632 * FUNCTION
1633 * Internal_chr_control_handler
1634 *
1635 * DESCRIPTION
1636 * This function is called to set the charger hw
1637 *
1638 * CALLS
1639 *
1640 * PARAMETERS
1641 * None
1642 *
1643 * RETURNS
1644 *
1645 *
1646 * GLOBALS AFFECTED
1647 * None
1648 */
1649 kal_int32 chr_control_interface(CHARGING_CTRL_CMD cmd, void *data)
1650 {
1651 kal_int32 status;
1652 if(cmd < CHARGING_CMD_NUMBER)
1653 status = charging_func[cmd](data);
1654 else
1655 return STATUS_UNSUPPORTED;
1656
1657 return status;
1658 }
1659
1660
kernel source for telekom puls (alcatel/mediatek)