1 /*****************************************************************************
13 * This file implements the interface between BMT and ADC scheduler.
19 *============================================================================
21 * $Modtime: 11 Aug 2005 10:28:16 $
22 * $Log: //mtkvs01/vmdata/Maui_sw/archives/mcu/hal/peripheral/inc/bmt_chr_setting.h-arc $
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>
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>
43 #ifdef CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT
44 #include <mach/diso.h>
45 #include "cust_diso.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>
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>
64 // ============================================================ //
66 // ============================================================ //
68 #define STATUS_UNSUPPORTED -1
69 #define GETARRAYNUM(array) (sizeof(array)/sizeof(array[0]))
72 // ============================================================ //
74 // ============================================================ //
75 static CHARGER_TYPE g_charger_type
= CHARGER_UNKNOWN
;
77 #if defined(CONFIG_MTK_WIRELESS_CHARGER_SUPPORT)
78 #define WIRELESS_CHARGER_EXIST_STATE 0
79 int wireless_charger_gpio_number
= (168 | 0x80000000);
83 #include <cust_gpio_usage.h>
84 int gpio_number
= GPIO_SWCHARGER_EN_PIN
;
85 int gpio_off_mode
= GPIO_SWCHARGER_EN_PIN_M_GPIO
;
86 int gpio_on_mode
= GPIO_SWCHARGER_EN_PIN_M_GPIO
;
88 int gpio_number
= (19 | 0x80000000);
89 int gpio_off_mode
= 0;
92 int gpio_off_dir
= GPIO_DIR_OUT
;
93 int gpio_off_out
= GPIO_OUT_ONE
;
94 int gpio_on_dir
= GPIO_DIR_OUT
;
95 int gpio_on_out
= GPIO_OUT_ZERO
;
97 kal_bool charging_type_det_done
= KAL_TRUE
;
99 const kal_uint32 VBAT_CV_VTH
[]=
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
116 const kal_uint32 CS_VTH
[]=
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
122 const kal_uint32 INPUT_CS_VTH
[]=
124 CHARGE_CURRENT_100_00_MA
, CHARGE_CURRENT_500_00_MA
, CHARGE_CURRENT_800_00_MA
, CHARGE_CURRENT_MAX
127 const kal_uint32 VCDT_HV_VTH
[]=
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
135 #ifdef CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT
136 #ifndef CUST_GPIO_VIN_SEL
137 #define CUST_GPIO_VIN_SEL 18
139 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
140 #define SW_POLLING_PERIOD 100 //100 ms
141 #define MSEC_TO_NSEC(x) (x * 1000000UL)
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
;
151 DISO_IRQ_Data DISO_IRQ
;
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
;
157 static char *DISO_state_s
[8] = {
170 // ============================================================ //
171 // function prototype
172 // ============================================================ //
175 // ============================================================ //
177 // ============================================================ //
179 // ============================================================ //
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);
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
)
195 if (val
< array_size
)
197 return parameter
[val
];
201 battery_xlog_printk(BAT_LOG_CRTI
, "Can't find the parameter \r\n");
207 kal_uint32
charging_parameter_to_value(const kal_uint32
*parameter
, const kal_uint32 array_size
, const kal_uint32 val
)
211 for(i
=0;i
<array_size
;i
++)
213 if (val
== *(parameter
+ i
))
219 battery_xlog_printk(BAT_LOG_CRTI
, "NO register value match \r\n");
220 //TODO: ASSERT(0); // not find the value
225 static kal_uint32
bmt_find_closest_level(const kal_uint32
*pList
,kal_uint32 number
,kal_uint32 level
)
228 kal_uint32 max_value_in_last_element
;
230 if(pList
[0] < pList
[1])
231 max_value_in_last_element
= KAL_TRUE
;
233 max_value_in_last_element
= KAL_FALSE
;
235 if(max_value_in_last_element
== KAL_TRUE
)
237 for(i
= (number
-1); i
!= 0; i
--) //max value in the last element
239 if(pList
[i
] <= level
)
245 battery_xlog_printk(BAT_LOG_CRTI
, "Can't find closest level, small value first \r\n");
247 //return CHARGE_CURRENT_0_00_MA;
251 for(i
= 0; i
< number
; i
++) // max value in the first element
253 if(pList
[i
] <= level
)
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;
266 static void hw_bc11_dump_register(void)
268 kal_uint32 reg_val
= 0;
269 kal_uint32 reg_num
= CHR_CON18
;
272 for(i
=reg_num
; i
<=CHR_CON19
; i
+=2)
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
);
280 static void hw_bc11_init(void)
283 Charger_Detect_Init();
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);
298 upmu_set_rg_bc11_rst(0x1);
300 upmu_set_rg_bc11_bb_ctrl(0x1);
305 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
307 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_init() \r\n");
308 hw_bc11_dump_register();
314 static U32
hw_bc11_DCD(void)
316 U32 wChargerAvail
= 0;
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);
330 wChargerAvail
= upmu_get_rgs_bc11_cmp_out();
332 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
334 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_DCD() \r\n");
335 hw_bc11_dump_register();
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);
347 return wChargerAvail
;
351 static U32
hw_bc11_stepA1(void)
353 U32 wChargerAvail
= 0;
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);
365 wChargerAvail
= upmu_get_rgs_bc11_cmp_out();
367 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
369 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_stepA1() \r\n");
370 hw_bc11_dump_register();
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);
378 return wChargerAvail
;
382 static U32
hw_bc11_stepB1(void)
384 U32 wChargerAvail
= 0;
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);
398 wChargerAvail
= upmu_get_rgs_bc11_cmp_out();
400 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
402 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_stepB1() \r\n");
403 hw_bc11_dump_register();
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);
413 return wChargerAvail
;
417 static U32
hw_bc11_stepC1(void)
419 U32 wChargerAvail
= 0;
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);
431 wChargerAvail
= upmu_get_rgs_bc11_cmp_out();
433 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
435 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_stepC1() \r\n");
436 hw_bc11_dump_register();
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);
446 return wChargerAvail
;
450 static U32
hw_bc11_stepA2(void)
452 U32 wChargerAvail
= 0;
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);
466 wChargerAvail
= upmu_get_rgs_bc11_cmp_out();
468 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
470 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_stepA2() \r\n");
471 hw_bc11_dump_register();
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);
481 return wChargerAvail
;
485 static U32
hw_bc11_stepB2(void)
487 U32 wChargerAvail
= 0;
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);
499 wChargerAvail
= upmu_get_rgs_bc11_cmp_out();
501 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
503 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_stepB2() \r\n");
504 hw_bc11_dump_register();
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);
514 return wChargerAvail
;
518 static void hw_bc11_done(void)
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);
531 upmu_set_rg_bc11_bias_en(0x0);
533 Charger_Detect_Release();
535 if(Enable_BATDRV_LOG
== BAT_LOG_FULL
)
537 battery_xlog_printk(BAT_LOG_FULL
, "hw_bc11_done() \r\n");
538 hw_bc11_dump_register();
544 static kal_uint32
charging_hw_init(void *data
)
546 kal_uint32 status
= STATUS_OK
;
547 static bool charging_init_flag
= KAL_FALSE
;
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
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
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
566 #if defined(HIGH_BATTERY_VOLTAGE_SUPPORT)
567 fan5405_reg_config_interface(0x06,0x78); // ISAFE = 1250mA, VSAFE = 4.36V
569 fan5405_reg_config_interface(0x06,0x70);
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
575 fan5405_reg_config_interface(0x01,0xb8); //TE=1, CE=0, HZ_MODE=0, OPA_MODE=0
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
;
588 static kal_uint32
charging_dump_register(void *data
)
590 kal_uint32 status
= STATUS_OK
;
592 fan5405_dump_register();
598 static kal_uint32
charging_enable(void *data
)
600 kal_uint32 status
= STATUS_OK
;
601 kal_uint32 enable
= *(kal_uint32
*)(data
);
603 if(KAL_TRUE
== enable
)
606 fan5405_set_hz_mode(0);
607 fan5405_set_opa_mode(0);
612 #if defined(CONFIG_USB_MTK_HDRC_HCD)
613 if(mt_usb_is_device())
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
);
628 static kal_uint32
charging_set_cv_voltage(void *data
)
630 kal_uint32 status
= STATUS_OK
;
631 kal_uint16 register_value
;
633 register_value
= charging_parameter_to_value(VBAT_CV_VTH
, GETARRAYNUM(VBAT_CV_VTH
) ,*(kal_uint32
*)(data
));
635 fan5405_set_oreg(register_value
);
641 static kal_uint32
charging_get_current(void *data
)
643 kal_uint32 status
= STATUS_OK
;
644 kal_uint32 array_size
;
648 array_size
= GETARRAYNUM(CS_VTH
);
649 fan5405_read_interface(0x1, ®_value
, 0x3, 0x6); //IINLIM
650 *(kal_uint32
*)data
= charging_value_to_parameter(CS_VTH
,array_size
,reg_value
);
657 static kal_uint32
charging_set_current(void *data
)
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
;
665 if(current_value
<= CHARGE_CURRENT_350_00_MA
)
667 fan5405_set_io_level(1);
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
);
681 static kal_uint32
charging_set_input_current(void *data
)
683 kal_uint32 status
= STATUS_OK
;
684 kal_uint32 set_chr_current
;
685 kal_uint32 array_size
;
686 kal_uint32 register_value
;
688 if(*(kal_uint32
*)data
> CHARGE_CURRENT_500_00_MA
)
690 register_value
= 0x3;
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
);
699 fan5405_set_input_charging_current(register_value
);
705 static kal_uint32
charging_get_charging_status(void *data
)
707 kal_uint32 status
= STATUS_OK
;
710 ret_val
= fan5405_get_chip_status();
713 *(kal_uint32
*)data
= KAL_TRUE
;
715 *(kal_uint32
*)data
= KAL_FALSE
;
721 static kal_uint32
charging_reset_watch_dog_timer(void *data
)
723 kal_uint32 status
= STATUS_OK
;
725 fan5405_set_tmr_rst(1);
731 static kal_uint32
charging_set_hv_threshold(void *data
)
733 kal_uint32 status
= STATUS_OK
;
735 kal_uint32 set_hv_voltage
;
736 kal_uint32 array_size
;
737 kal_uint16 register_value
;
738 kal_uint32 voltage
= *(kal_uint32
*)(data
);
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
);
749 static kal_uint32
charging_get_hv_status(void *data
)
751 kal_uint32 status
= STATUS_OK
;
753 *(kal_bool
*)(data
) = upmu_get_rgs_vcdt_hv_det();
759 static kal_uint32
charging_get_battery_status(void *data
)
761 kal_uint32 status
= STATUS_OK
;
763 upmu_set_baton_tdet_en(1);
764 upmu_set_rg_baton_en(1);
765 *(kal_bool
*)(data
) = upmu_get_rgs_baton_undet();
771 static kal_uint32
charging_get_charger_det_status(void *data
)
773 kal_uint32 status
= STATUS_OK
;
776 #if defined(CONFIG_POWER_EXT) || defined(CONFIG_MTK_FPGA)
778 battery_xlog_printk(BAT_LOG_CRTI
,"[charging_get_charger_det_status] charger exist for bring up.\n");
780 #if !defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
781 val
= upmu_get_rgs_chrdet();
783 if(((g_diso_state
>> 1) & 0x3) != 0x0 || (upmu_get_rgs_chrdet() && !g_diso_otg
))
791 *(kal_bool
*)(data
) = val
;
793 g_charger_type
= CHARGER_UNKNOWN
;
799 kal_bool
charging_type_detection_done(void)
801 return charging_type_det_done
;
805 extern CHARGER_TYPE
hw_charger_type_detection(void);
806 static kal_uint32
charging_get_charger_type(void *data
)
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
;
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
)
819 *(CHARGER_TYPE
*)(data
) = WIRELESS_CHARGER
;
820 battery_xlog_printk(BAT_LOG_CRTI
, "WIRELESS_CHARGER!\r\n");
824 if(g_charger_type
!=CHARGER_UNKNOWN
&& g_charger_type
!=WIRELESS_CHARGER
)
826 *(CHARGER_TYPE
*)(data
) = g_charger_type
;
827 battery_xlog_printk(BAT_LOG_CRTI
, "return %d!\r\n", g_charger_type
);
831 charging_type_det_done
= KAL_FALSE
;
834 charger_type
= hw_charger_type_detection();
835 battery_xlog_printk(BAT_LOG_CRTI
, "charging_get_charger_type = %d\r\n", charger_type
);
837 *(CHARGER_TYPE
*)(data
) = charger_type
;
840 /********* Step initial ***************/
843 /********* Step DCD ***************/
844 if(1 == hw_bc11_DCD())
846 /********* Step A1 ***************/
847 if(1 == hw_bc11_stepA1())
849 /********* Step B1 ***************/
850 if(1 == hw_bc11_stepB1())
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");
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");
867 /********* Step C1 ***************/
868 if(1 == hw_bc11_stepC1())
870 *(CHARGER_TYPE
*)(data
) = APPLE_1_0A_CHARGER
;
871 battery_xlog_printk(BAT_LOG_CRTI
, "step C1 : Apple 1A CHARGER!\r\n");
875 *(CHARGER_TYPE
*)(data
) = APPLE_0_5A_CHARGER
;
876 battery_xlog_printk(BAT_LOG_CRTI
, "step C1 : Apple 0.5A CHARGER!\r\n");
883 /********* Step A2 ***************/
884 if(1 == hw_bc11_stepA2())
886 /********* Step B2 ***************/
887 if(1 == hw_bc11_stepB2())
889 *(CHARGER_TYPE
*)(data
) = STANDARD_CHARGER
;
890 battery_xlog_printk(BAT_LOG_CRTI
, "step B2 : STANDARD CHARGER!\r\n");
894 *(CHARGER_TYPE
*)(data
) = CHARGING_HOST
;
895 battery_xlog_printk(BAT_LOG_CRTI
, "step B2 : Charging Host!\r\n");
900 *(CHARGER_TYPE
*)(data
) = STANDARD_HOST
;
901 battery_xlog_printk(BAT_LOG_CRTI
, "step A2 : Standard USB Host!\r\n");
906 /********* Finally setting *******************************/
909 charging_type_det_done
= KAL_TRUE
;
911 g_charger_type
= *(CHARGER_TYPE
*)(data
);
913 charging_type_det_done
= KAL_TRUE
;
915 g_charger_type
= *(CHARGER_TYPE
*)(data
);
920 static kal_uint32
charging_get_is_pcm_timer_trigger(void *data
)
922 kal_uint32 status
= STATUS_OK
;
924 if(slp_get_wake_reason() == WR_PCM_TIMER
)
925 *(kal_bool
*)(data
) = KAL_TRUE
;
927 *(kal_bool
*)(data
) = KAL_FALSE
;
929 battery_xlog_printk(BAT_LOG_CRTI
, "slp_get_wake_reason=%d\n", slp_get_wake_reason());
934 static kal_uint32
charging_set_platform_reset(void *data
)
936 kal_uint32 status
= STATUS_OK
;
938 battery_xlog_printk(BAT_LOG_CRTI
, "charging_set_platform_reset\n");
945 static kal_uint32
charging_get_platfrom_boot_mode(void *data
)
947 kal_uint32 status
= STATUS_OK
;
949 *(kal_uint32
*)(data
) = get_boot_mode();
951 battery_xlog_printk(BAT_LOG_CRTI
, "get_boot_mode=%d\n", get_boot_mode());
956 static kal_uint32
charging_set_power_off(void *data
)
958 kal_uint32 status
= STATUS_OK
;
960 battery_xlog_printk(BAT_LOG_CRTI
, "charging_set_power_off\n");
966 static kal_uint32
charging_get_power_source(void *data
)
968 kal_uint32 status
= STATUS_OK
;
970 #if 0 //#if defined(MTK_POWER_EXT_DETECT)
971 if (MT_BOARD_PHONE
== mt_get_board_type())
972 *(kal_bool
*)data
= KAL_FALSE
;
974 *(kal_bool
*)data
= KAL_TRUE
;
976 *(kal_bool
*)data
= KAL_FALSE
;
982 static kal_uint32
charging_get_csdac_full_flag(void *data
)
984 return STATUS_UNSUPPORTED
;
987 static kal_uint32
charging_set_ta_current_pattern(void *data
)
989 return STATUS_UNSUPPORTED
;
992 #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
993 void set_diso_otg(bool enable
)
997 void set_vusb_auxadc_irq(bool enable
, bool flag
)
999 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1000 hrtimer_cancel(&diso_kthread_timer
);
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
;
1006 hrtimer_start(&diso_kthread_timer
, ktime_set(0, MSEC_TO_NSEC(SW_POLLING_PERIOD
)), HRTIMER_MODE_REL
);
1008 kal_uint16 threshold
= 0;
1011 threshold
= DISO_IRQ
.vusb_measure_channel
.falling_threshold
;
1013 threshold
= DISO_IRQ
.vusb_measure_channel
.rising_threshold
;
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
);
1019 mt_auxadc_disableBackgroundDection(DISO_IRQ
.vusb_measure_channel
.number
);
1022 battery_xlog_printk(BAT_LOG_FULL
, " [%s] enable: %d, flag: %d!\n", __func__
, enable
, flag
);
1025 void set_vdc_auxadc_irq(bool enable
, bool flag
)
1027 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1028 hrtimer_cancel(&diso_kthread_timer
);
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
;
1034 hrtimer_start(&diso_kthread_timer
, ktime_set(0, MSEC_TO_NSEC(SW_POLLING_PERIOD
)), HRTIMER_MODE_REL
);
1036 kal_uint16 threshold
= 0;
1039 threshold
= DISO_IRQ
.vdc_measure_channel
.falling_threshold
;
1041 threshold
= DISO_IRQ
.vdc_measure_channel
.rising_threshold
;
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
);
1047 mt_auxadc_disableBackgroundDection(DISO_IRQ
.vdc_measure_channel
.number
);
1050 battery_xlog_printk(BAT_LOG_FULL
, " [%s] enable: %d, flag: %d!\n", __func__
, enable
, flag
);
1053 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1054 static void diso_polling_handler(struct work_struct
*work
)
1056 int trigger_channel
= -1;
1057 int trigger_flag
= -1;
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
;
1064 battery_xlog_printk(BAT_LOG_CRTI
, "[DISO]auxadc handler triggered\n" );
1065 switch(trigger_channel
)
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]);
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]);
1103 battery_xlog_printk(BAT_LOG_CRTI
, "[%s] wrong trigger flag!\n",__func__
);
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]);
1129 battery_xlog_printk(BAT_LOG_CRTI
, "[%s] wrong trigger flag!\n",__func__
);
1130 set_vusb_auxadc_irq(DISO_IRQ_ENABLE
, (~trigger_flag
)&0x1);
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 */
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
);
1146 static irqreturn_t
diso_auxadc_irq_handler(int irq
, void *dev_id
)
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
)
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]);
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]);
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]);
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]);
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]);
1214 set_vusb_auxadc_irq(DISO_IRQ_ENABLE
, (~trigger_flag
)&0x1);
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 */
1222 g_diso_state
= *(int*)&DISO_data
.diso_state
;
1223 return IRQ_WAKE_THREAD
;
1227 #if defined(MTK_DISCRETE_SWITCH) && defined(MTK_DSC_USE_EINT)
1228 void vdc_eint_handler()
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();
1237 static kal_uint32
diso_get_current_voltage(int Channel
)
1239 int ret
= 0, data
[4], i
, ret_value
= 0, ret_temp
= 0, times
= 5;
1241 if( IMM_IsAdcInitReady() == 0 ) {
1242 battery_xlog_printk(BAT_LOG_CRTI
, "[DISO] AUXADC is not ready");
1249 ret_value
= IMM_GetOneChannelValue(Channel
, data
, &ret_temp
);
1250 if(ret_value
== 0) {
1253 times
= times
> 1 ? times
- 1 : 1;
1254 battery_xlog_printk(BAT_LOG_CRTI
, "[diso_get_current_voltage] ret_value=%d, times=%d\n",
1259 ret
= ret
*1500/4096 ;
1265 static void _get_diso_interrupt_state(void)
1269 int check_times
= 30;
1270 kal_bool vin_state
= KAL_FALSE
;
1272 #ifndef VIN_SEL_FLAG
1273 mdelay(AUXADC_CHANNEL_DELAY_PERIOD
);
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
);
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
1285 if (vol
> VDC_MIN_VOLTAGE
/1000 && vol
< VDC_MAX_VOLTAGE
/1000) {
1286 /* make sure load switch already switch done */
1289 #ifdef VIN_SEL_FLAG_DEFAULT_LOW
1290 vin_state
= mt_get_gpio_in(vin_sel_gpio_number
);
1292 vin_state
= mt_get_gpio_in(vin_sel_gpio_number
);
1293 vin_state
= (~vin_state
) & 0x1;
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
));
1301 if (0 == check_times
)
1302 diso_state
&= ~0x4; //SET DC bit as 0
1304 diso_state
|= 0x4; //SET DC bit as 1
1306 diso_state
&= ~0x4; //SET DC bit as 0
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
1313 diso_state
&= ~0x4; //SET DC bit as 0
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
);
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
1326 diso_state
&= ~0x1; //SET OTG bit as 0
1327 diso_state
|= 0x2; //SET VBUS bit as 1;
1331 diso_state
&= 0x4; //SET OTG and VBUS bit as 0
1333 battery_xlog_printk(BAT_LOG_CRTI
, "[DISO] DISO_STATE==0x%x \n",diso_state
);
1334 g_diso_state
= diso_state
;
1337 #if !defined(MTK_AUXADC_IRQ_SUPPORT)
1338 int _get_irq_direction(int pre_vol
, int cur_vol
)
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
;
1351 static void _get_polling_state(void)
1353 int vdc_vol
= 0, vusb_vol
= 0;
1354 int vdc_vol_dir
= -1;
1355 int vusb_vol_dir
= -1;
1357 DISO_polling_channel
* VDC_Polling
= &DISO_Polling
.vdc_polling_measure
;
1358 DISO_polling_channel
* VUSB_Polling
= &DISO_Polling
.vusb_polling_measure
;
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;
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;
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
;
1371 if (DISO_Polling
.reset_polling
)
1373 DISO_Polling
.reset_polling
= KAL_FALSE
;
1374 VDC_Polling
->preVoltage
= vdc_vol
;
1375 VUSB_Polling
->preVoltage
= vusb_vol
;
1378 vdc_vol_dir
= DISO_IRQ_RISING
;
1380 vdc_vol_dir
= DISO_IRQ_FALLING
;
1383 vusb_vol_dir
= DISO_IRQ_RISING
;
1385 vusb_vol_dir
= DISO_IRQ_FALLING
;
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
);
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;
1412 enum hrtimer_restart
diso_kthread_hrtimer_func(struct hrtimer
*timer
)
1414 diso_thread_timeout
= KAL_TRUE
;
1415 wake_up(&diso_polling_thread_wq
);
1417 return HRTIMER_NORESTART
;
1420 int diso_thread_kthread(void *x
)
1422 /* Run on a process content */
1424 wait_event(diso_polling_thread_wq
, (diso_thread_timeout
== KAL_TRUE
));
1426 diso_thread_timeout
= KAL_FALSE
;
1428 mutex_lock(&diso_polling_mutex
);
1430 _get_polling_state();
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
);
1436 hrtimer_cancel(&diso_kthread_timer
);
1438 mutex_unlock(&diso_polling_mutex
);
1447 static kal_uint32
charging_get_error_state(void)
1449 return charging_error
;
1452 static kal_uint32
charging_set_error_state(void *data
)
1454 kal_uint32 status
= STATUS_OK
;
1455 charging_error
= *(kal_uint32
*)(data
);
1461 static kal_uint32
charging_diso_init(void *data
)
1463 kal_uint32 status
= STATUS_OK
;
1465 #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
1466 DISO_ChargerStruct
*pDISO_data
= (DISO_ChargerStruct
*)data
;
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
;
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
;
1477 pDISO_data
->chr_get_diso_state
= KAL_FALSE
;
1478 pDISO_data
->hv_voltage
= VBUS_MAX_VOLTAGE
;
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
);
1485 kthread_run(diso_thread_kthread
, NULL
, "diso_thread_kthread");
1486 battery_xlog_printk(BAT_LOG_CRTI
, "[%s] done\n", __func__
);
1488 struct device_node
*node
;
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
;
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;
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
);
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
);
1513 battery_xlog_printk(BAT_LOG_CRTI
, "[diso_adc]: request_irq failed.\n");
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");
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
);
1532 static kal_uint32
charging_get_diso_state(void *data
)
1534 kal_uint32 status
= STATUS_OK
;
1536 #if defined(CONFIG_MTK_DUAL_INPUT_CHARGER_SUPPORT)
1537 int diso_state
= 0x0;
1538 DISO_ChargerStruct
*pDISO_data
= (DISO_ChargerStruct
*)data
;
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)
1545 switch (diso_state
){
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
);
1553 set_vdc_auxadc_irq(DISO_IRQ_ENABLE
, 1);
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
;
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
;
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
;
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
;
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
1592 if (DISO_ONLINE
== pDISO_data
->diso_state
.cur_vdc_state
)
1593 pDISO_data
->hv_voltage
= VDC_MAX_VOLTAGE
;
1595 pDISO_data
->hv_voltage
= VBUS_MAX_VOLTAGE
;
1602 static kal_uint32 (* const charging_func
[CHARGING_CMD_NUMBER
])(void *data
)=
1605 ,charging_dump_register
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
1627 ,charging_get_diso_state
1633 * Internal_chr_control_handler
1636 * This function is called to set the charger hw
1649 kal_int32
chr_control_interface(CHARGING_CTRL_CMD cmd
, void *data
)
1652 if(cmd
< CHARGING_CMD_NUMBER
)
1653 status
= charging_func
[cmd
](data
);
1655 return STATUS_UNSUPPORTED
;