void bmt_enable_sleepmode(kal_bool enable)
{
if (KAL_TRUE==enable)
{
bmt_sleepmode=KAL_TRUE;
#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
kal_cancel_timer(bmt_sw_polling_timerId);
#endif //#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepEnable(bmt_sm_handle);
#endif
drv_trace0(TRACE_GROUP_10, BMT_SW_ENABLE_SLEEP_MODE);
}
else
{
bmt_sleepmode=KAL_FALSE;
#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
kal_set_timer(bmt_sw_polling_timerId, (kal_timer_func_ptr)bmt_sw_polling_ov, NULL,43 , 0);
#endif //#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
#ifdef MTK_SLEEP_ENABLE
L1SM_SleepDisable(bmt_sm_handle);
#endif
drv_trace0(TRACE_GROUP_10, BMT_SW_DISABLE_SLEEP_MODE);
}
}
void bmt_set_customized_current(CHR_DET_TYPE_ENUM charger_type)
{
PMU_CHR_CURRENT_ENUM chr_current = PMU_CHARGE_CURRENT_0_00_MA;
drv_trace0(TRACE_GROUP_10, BMT_SET_CUSTOMIZED_CURRENT_TRC);
switch (charger_type)
{
case PW_AC_CHR:
chr_current = CHR_AC_CHARGE_CURRENT;
drv_trace0(TRACE_GROUP_10, BMT_SET_AC_CHARGE_CURRENT_TRC);
break;
#if defined(__USB_ENABLE__)
case PW_USB_CHR:
chr_current = bmt_usb_chr_current;
drv_trace0(TRACE_GROUP_10, BMT_SET_USB_CHARGE_CURRENT_TRC);
#endif //#if defined(__USB_ENABLE__)
break;
case PW_AC_NON_STD_CHR:
chr_current = PMU_CHARGE_CURRENT_450_00_MA;
break;
default:
ASSERT(0);
break;
}
bmt_find_and_set_the_nearest_current(chr_current);
}
void bmt_high_vchg_adjust_safetytimer(kal_int32 Cur_VCHG)
{
kal_int32 i;
CHR_DET_TYPE_ENUM chr_type;
chr_type = bmt_get_chr_type();
drv_trace1(TRACE_GROUP_9, BMT_HIGH_VCHG_CURRENT_VCHG_TRC, Cur_VCHG);
// Cur_VCHG > S/W OVP
if(Cur_VCHG > bmt_charging_para.HIGH_VCHG_TABLE[VCHG_VOL_LEVEL - 1][0])
{
bmt_total_charge_time = 0;
drv_trace0(TRACE_GROUP_9, BMT_HIGH_VCHG_TOO_HIGH_TRC);
}
else if(Cur_VCHG < bmt_charging_para.HIGH_VCHG_TABLE[0][0])
{
drv_trace1(TRACE_GROUP_9, BMT_HIGH_VCHG_LOWEST_THRESHOLD_TRC, bmt_charging_para.HIGH_VCHG_TABLE[0][0]);
bmt_total_charge_time = bmt_charging_para.HIGH_VCHG_TABLE[0][2];
}
else
{
for(i = (VCHG_VOL_LEVEL - 1); i > 0; i--)
{
drv_trace1(TRACE_GROUP_9, BMT_HIGH_VCHG_UPPER_THRESHOLD_TRC, bmt_charging_para.HIGH_VCHG_TABLE[i][0]);
drv_trace1(TRACE_GROUP_9, BMT_HIGH_VCHG_LOWER_THRESHOLD_TRC, bmt_charging_para.HIGH_VCHG_TABLE[i-1][0]);
if((Cur_VCHG < bmt_charging_para.HIGH_VCHG_TABLE[i][0]) && (Cur_VCHG >= bmt_charging_para.HIGH_VCHG_TABLE[i-1][0]))
{
bmt_total_charge_time = bmt_charging_para.HIGH_VCHG_TABLE[i][2];
drv_trace1(TRACE_GROUP_9, BMT_HIGH_VCHG_TABLE_INDEX_TRC, i);
break;
}
}
}
drv_trace1(TRACE_GROUP_9, BMT_CURRENT_PMIC_STATE_TRC, BMT.pmictrl_state);
if((chr_type != PW_USB_CHR) && (chr_type !=PW_USB_CHARGING_HOST_CHR))
{
drv_trace0(TRACE_GROUP_9, BMT_AC_IN_TRC);
}
else
{
drv_trace0(TRACE_GROUP_9, BMT_USB_IN_TRC);
bmt_total_charge_time = bmt_charging_para.bmt_total_charge_time;
}
}
VIDEO_DECODER_CODEC_ERROR_T H264HwDecoderCloseAdapt(void)
{
kal_bool fgCacheable;
drv_trace0(TRACE_GROUP_8, H264HWDEC_CLOSE);
if (rH264HwDecCtrl.fgExtMemReplaceIntMem)
{
if (rH264HwDecCtrl.fgExtMemReplaceIntMemSwitch)
{
fgCacheable = VideoCommIsExtBufferCacheable((kal_uint32)rH264HwDecCtrl.u4IntMemAddr, rH264HwDecCtrl.u4IntMemAlignSize);
if (fgCacheable == KAL_FALSE)
{
VideoCommExtBufferCacheableSwitch(rH264HwDecCtrl.u4IntMemAddr, rH264HwDecCtrl.u4IntMemAlignSize, VIDEO_CACHEABLE);
}
else
{
//switched internal memory to cacheable???
ASSERT(0);
}
}
VideoDecoderFree((void *)rH264HwDecCtrl.u4IntMemOriginalAddr);
}
return VIDEO_DECODER_CODEC_ERROR_NONE;
}
/* clear tx buffer */
static void USB2UART_ClrTxBuffer(UART_PORT port, module_type ownerid)
{
kal_uint32 savedMask;
#ifndef __PRODUCTION_RELEASE__
if(ownerid != USB2UARTPort.ownerid)
{
EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);
}
#endif
drv_trace0(TRACE_FUNC, USBACM_CLEAR_TX_BUF);
// kal_prompt_trace(MOD_USB, "clrTx\n");
/* stop dma channel if current status is CDC ACM*/
if ( (gUsbDevice.device_type == USB_CDC_ACM) && (USB2UARTPort.initialized == KAL_TRUE)
&&(gUsbDevice.nDevState==DEVSTATE_CONFIG))
{
USB_Stop_DMA_Channel(g_UsbACM.txpipe->byEP, USB_TX_EP_TYPE);
}
savedMask = SaveAndSetIRQMask();
USB2UARTPort.Tx_Buffer.Write = 0;
USB2UARTPort.Tx_Buffer.Read = 0;
g_UsbACM.send_Txilm = KAL_TRUE;
RestoreIRQMask(savedMask);
drv_trace1(TRACE_FUNC, USBACM_CLEAR_TX_BUF_READY_TO_READ_FLAG, ownerid);
// kal_prompt_trace(MOD_USB, "clr RDY W %d", ownerid);
}
void _VideoDecodeCheckStackTCM(void)
{
#if defined(MT6225)||defined(MT6235)||defined(MT6235B)||defined(MT6236)||defined(MT6236B)||defined(MT6253)||defined(MT6253T)
drv_trace0(TRACE_GROUP_10, VCODEC_STACK_NO_TCM);
ASSERT(0);
#endif
}
void bmt_charge_clear_wdt(void *parameter)
{
DCL_STATUS status;
SGPT_CTRL_START_T start;
// Clear charge WDT
drv_trace0(TRACE_GROUP_10, BMT_CHARGING_WDT_CLR_TRC);
DclPMU_Control(bmt_PmuHandler, CHR_SET_WDT_CLEAR, NULL);
if (bmt_wdt_handle != 0xFF)
{
start.u2Tick=BMT_CHARGE_CLEAR_WDT_PERIOD;
start.pfCallback=bmt_charge_clear_wdt;
start.vPara=NULL;
//this is for handle type transfer between new and old API.
status = DclSGPT_Control(bmt_wdt_handle, SGPT_CMD_START,(DCL_CTRL_DATA_T*)&start);
if(status != STATUS_OK)
{
ASSERT(0);
}
}
}
VIDEO_DECODER_CODEC_ERROR_T H264HwDecoderDeInitAdapt(void)
{
if ( rH264HwDecCtrl.fgIsCodecInit != KAL_TRUE )
{
ASSERT(0);
return VIDEO_DECODER_CODEC_ERROR;
}
drv_trace0(TRACE_GROUP_8, H264HWDEC_DEINIT);
VideoH264DecClose();
rH264HwDecCtrl.fgIsCodecInit = KAL_FALSE;
rH264HwDecCtrl.fgEOF = KAL_FALSE;
rH264HwDecCtrl.fgFrmBufferSwitch = KAL_FALSE;
rH264HwDecCtrl.u2FrameHeight = 0;
rH264HwDecCtrl.u2FrameWidth = 0;
rH264HwDecCtrl.u4BufferSize = 0;
rH264HwDecCtrl.u4BitRate = 0;
rH264HwDecCtrl.u4FrameRate = 0;
rH264HwDecCtrl.u4OutRIdx = 0;
rH264HwDecCtrl.u4OutWIdx = 0;
if (rH264HwDecCtrl.u4ExtMemAddr)
{
VideoDecoderFree((void *)rH264HwDecCtrl.u4ExtMemAddr);
rH264HwDecCtrl.u4ExtMemAddr = 0;
}
return VIDEO_DECODER_CODEC_ERROR_NONE;
}
/*
* FUNCTION
* e_compass_start_cali
*
* DESCRIPTION
* This function is to start calibration
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*/
void e_compass_sensor_start_cali(void)
{
drv_trace0(TRACE_GROUP_10, EC_CALIBRATION_START);
e_compass_enable_driver(KAL_FALSE);
e_compass_sensor_data.cali_state = E_COMPASS_SENSOR_START_CALI;
e_compass_enable_driver(KAL_TRUE);
}
/*
* FUNCTION
* bmt_stop_stoptimer
*
* DESCRIPTION
* This function is to stop the bmt_stop timer in bmt task.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_stop_stoptimer(void)
{
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_STOP_TIMER_STOP_TRC);
#endif
drv_trace0(TRACE_GROUP_10, BMT_STOP_TIMER_STOP_TRC);
stack_stop_timer(timer_stopcharge);
}
/*
* FUNCTION
* bmt_set_guardtimer
*
* DESCRIPTION
* This function is to initialize the bmt_stop timer in bmt task.
*
* CALLS
*
* PARAMETERS
* tick: timer tick(1 tick=4.615ms)
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_set_guardtimer(kal_uint32 tick)
{
#ifdef BMT_KAL_DEBUG
kal_trace(TRACE_FUNC, BMT_STOP_TIMER_START_TRC);
#endif
drv_trace0(TRACE_GROUP_10, BMT_STOP_TIMER_START_TRC);
stack_start_timer(timer_guardcharge, 0, tick);
}
/*************************************************************************
* FUNCTION
* e_compass_sensor_manual_init
*
* DESCRIPTION
* This function is to configure sensor middleware manually, end user must keep handset horizontal.
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void e_compass_sensor_manual_init(void)
{
drv_trace0(TRACE_GROUP_10, EC_MIDDLEWARE_MANUAL_INIT);
e_compass_enable_driver(KAL_FALSE);
/* sensor middleware init */
e_compass_sensor_custom_fp->ec_middleware_init();
e_compass_enable_driver(KAL_TRUE);
}
static void bmt_top_off_timer_callback(void* msg_ptr)
{
drv_trace0(TRACE_GROUP_10, BMT_TOP_OFF_TIMER_EXPIRE_TRC);
bmt_event_scheduler_id[BMT_TOP_OFF_TIMER] = 0;
bmt_CtrlCharge((kal_uint8)KAL_TRUE);
BMT.bat_state = CHR_BATFULL;
bmt_stop_timer(BMT_STOP_CHARGE_TIMER);
bmt_stop_timer(BMT_CHARGE_TIMEOUT_TIMER);
bmt_set_timer(BMT_STOP_CHARGE_TIMER,STOPTIMER_TIMEOUT_TICK);
bmt_sendMes2UEM(BMT_CHARGE_COMPLETE);
drv_trace0(TRACE_GROUP_10, BMT_CHR_BATFULL_CHANGE_TRC);
bmt_timer_config(bmt_charging_para.TOPOFF_TON*CHARGING_TIME_UNIT);
}
static void bmt_stop_charge_timer_callback(void* msg_ptr)
{
drv_trace0(TRACE_GROUP_10, BMT_STOP_TIMER_EXPIRE_TRC);
bmt_event_scheduler_id[BMT_STOP_CHARGE_TIMER] = 0;
bmt_ChrStop();
bmt_enable_sleepmode(KAL_TRUE);
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncDeInit(void)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
_MPEG4HWEncControlDeInit();
drv_trace0(TRACE_GROUP_10, MPEG4HWENC_DEINIT);
return eRet;
}
/*
* FUNCTION
* e_compass_sensor_cancel_cali
*
* DESCRIPTION
* This function is to cancel calibration
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*/
void e_compass_sensor_cancel_cali(void)
{
drv_trace0(TRACE_GROUP_10, EC_CALIBRATION_ABORT);
e_compass_enable_driver(KAL_FALSE);
/* end user cancel calibration */
if (E_COMPASS_SENSOR_START_CALI == e_compass_sensor_data.cali_state)
{
/* calibration is on-going, we can cancel */
e_compass_sensor_data.cali_state = E_COMPASS_SENSOR_CALI_ABORTED;
}
/* else we do nothing. Driver might have finished calibration */
e_compass_enable_driver(KAL_TRUE);
}
MEDIA_STATUS_CODE VideoH264DecClose(void)
{
drv_trace0(TRACE_GROUP_10,OPEN_API_ENTERVIDEOH264DECCLOSE);
VideoH264DecOutputPic((kal_uint32)H264SW_OPENAPI_EOF);
if ( rH264SwCtrl.fgIsCodecInit == KAL_TRUE )
{
drv_trace0(TRACE_GROUP_8, H264DEC_DEINIT);
H264SwDecRelease(rH264SwCtrl.prH264DecInst);
}
drv_trace0(TRACE_GROUP_8, H264DEC_CLOSE);
if (rH264SwCtrl.pAdmId)
{
kal_adm_delete(rH264SwCtrl.pAdmId);
rH264SwCtrl.pAdmId = NULL;
}
rH264SwCtrl.fgBsBufferCacheable = KAL_FALSE;
rH264SwCtrl.fgFrmBufferCacheable = KAL_FALSE;
rH264SwCtrl.fgFrmBufferSwitch = KAL_FALSE;
rH264SwCtrl.fgIsCodecInit = KAL_FALSE;
rH264SwCtrl.u2FrameHeight = 0;
rH264SwCtrl.u2FrameWidth = 0;
rH264SwCtrl.u2RealHeight = 0;
rH264SwCtrl.u2RealWidth = 0;
rH264SwCtrl.u4BufferSize = 0;
rH264SwCtrl.pfnSetFrameUnReference = NULL;
rH264SwCtrl.pfnOutputOneFrame = NULL;
rH264SwCtrl.pfnGetYUVBuffer = NULL;
#if defined(__MTK_TARGET__)
#if defined(MT6236) || defined(MT6236B)
DCM_Unload(DYNAMIC_CODE_264DEC_S);
#endif
#endif
return MEDIA_STATUS_OK;
}
/* clear tx isr buffer */
void USB2UART_Clear_Tx_ISR_Buffer(void)
{
kal_uint32 savedMask;
drv_trace0(TRACE_FUNC, USBACM_CLEAR_TX_ISR_BUF);
// kal_prompt_trace(MOD_USB, "clrTxISR");
savedMask = SaveAndSetIRQMask();
USB2UARTPort.Tx_Buffer_ISR.Write = 0;
USB2UARTPort.Tx_Buffer_ISR.Read = 0;
USB_Stop_DMA_Channel(g_UsbACM.txpipe->byEP, USB_TX_EP_TYPE);
RestoreIRQMask(savedMask);
}
/*
* FUNCTION
* bmt_charge_end
*
* DESCRIPTION
* This function is to stop charging when charger is plugged out
* or serious error in charging stage.
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_charge_end(void)
{
#if defined(__EVB__) && defined(__MTK_INTERNAL__)
/* under construction !*/
#elif defined(__DRV_BMT_NO_CHARGING__)
return;
#else//#if defined(__EVB__)
DCL_STATUS adc_status;
//#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
// kal_cancel_timer(bmt_sw_polling_timerId);
//#endif //#ifdef __DRV_BMT_SW_POLLING_CHARGER_OV__
#if defined(__DRV_BMT_ULTRA_LOW_COST_CHARGER__)
bmt_chr_force_enable(KAL_FALSE);
#endif
BMT.pmictrl_state = PMIC_CHARGEOFF;
BMT.VBAT_UEM= VBAT_UEM_CHR_OUT_FIRST;
BMT_Charge(KAL_FALSE);
adc_status = DclSADC_Control(bmt_adc_handle, ADC_CMD_STOP_MEASURE, NULL);
if(adc_status != STATUS_OK)
{
ASSERT(0);
}
bmt_stop_stoptimer();
stack_stop_timer(&ChargeTimeout_timer);
#ifdef __BMT_CHARGE_GUARD_TIME__
bmt_stop_guardtimer();
#endif
#if defined(__DRV_BMT_ESTIMATIVE_TIMER_ON_TOPOFF__)
bmt_stop_estimativetimer();
#endif //#if defined(__DRV_BMT_ESTIMATIVE_TIMER_ON_TOPOFF__)
drv_trace1(TRACE_GROUP_10, BMT_SAFETY_TIMER_STOP_TRC, BMT_TOTAL_CHARGE_TIME);
SaftyTimer_Flag = BMT_SAFETY_TIMER_OFF;
// #ifdef MTK_SLEEP_ENABLE
// L1SM_SleepEnable(bmt_sm_handle);
// #endif
bmt_enable_sleepmode(KAL_TRUE);
#if defined(PMIC_CHARGE_WDT) // Defined in pmic_features.h
bmt_charge_enable_wdt(KAL_FALSE);
#endif // #if defined(PMIC_CHARGE_WDT)
drv_trace0(TRACE_GROUP_10, BMT_CHARGING_END_TRC);
// DclSADC_Close(adc_handle);
#endif//#if defined(__EVB__)
}
/*
* FUNCTION
* bmt_ChrStop
*
* DESCRIPTION
* This function is called if charge is complete and run after 30 min
*
* CALLS
*
* PARAMETERS
* None
*
* RETURNS
* None
*
*/
static void bmt_ChrStop(void) /*30 min*/
{
DCL_STATUS adc_status;
drv_trace0(TRACE_STATE, BMT_MEASURE_STOP_TRC);
bmt_CtrlCharge((kal_uint8)KAL_FALSE); //Stop Charge!!
BMT.highfull = 1;
adc_status = DclSADC_Control(bmt_adc_handle, ADC_CMD_STOP_MEASURE, NULL);
if(adc_status != STATUS_OK)
{
ASSERT(0);
}
bmt_timer_config(bmt_charging_para.BATFULL_TOFF*CHARGING_TIME_UNIT);
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncClose(void)
{
VIDEO_ENCODER_CODEC_ERROR_T eRet = VIDEO_ENCODER_CODEC_ERROR_NONE;
MPEG4_ENCORE_MEM_INFO *rMPEG4Mem = &rMPEG4HWEncCtrl.rMPEG4Mem;
ASSERT(rpMPEG4HWEncDriver);
rpMPEG4HWEncDriver->close();
VideoEncoderFreeAligned(rMPEG4Mem->ext_mem_addr);
VideoEncoderFreeAligned(rMPEG4Mem->res_mem_addr);
drv_trace0(TRACE_GROUP_10, MPEG4HWENC_CLOSE);
return eRet;
}
/*
* FUNCTION
* bmt_CtrlCharge
*
* DESCRIPTION
* This function is called to control the SW of charge
*
* CALLS
*
* PARAMETERS
* ON: 1, charge on 0, charge off
* VBAT: the measured voltage of battery.
*
* RETURNS
* None
*
* GLOBALS AFFECTED
* None
*/
void bmt_CtrlCharge(kal_uint8 ON)
{
kal_bool chr_enable;
kal_bool ChrCtrl;
drv_trace1(TRACE_GROUP_1, BMT_CTRL_CHARGE_TRC, ON);
// If bat_state is HOLD, we do NOT enable chr_en
if ( (BMT.bat_state == CHR_HOLD) || (BMT.bat_state == CHR_ERROR) )
{
BMT.pmictrl_state = PMIC_CHARGEOFF;
chr_enable = KAL_FALSE;
bmt_charging_control_handler(BMT_CHARGING_CMD_CHARGING_ENABLE, &chr_enable);
return;
}
if ((kal_bool)ON == KAL_TRUE)
{
if (BMT.pmictrl_state == PMIC_CHARGEOFF)
{
BMT.pmictrl_state = PMIC_CHARGEON;
// Fast plug in/out may cause HW disable current level, but SW do not receive interrupt.
// Under such scenario the current level will incorrect.
// Enforce set correct current level every time charge ON.
bmt_set_chr_current();
ChrCtrl = KAL_TRUE;
bmt_charging_control_handler(BMT_CHARGING_CMD_CHARGING_ENABLE, &ChrCtrl);
}
else
{
bmt_charging_control_handler(BMT_CHARGING_CMD_WDT_CLEAR,NULL);
drv_trace0(TRACE_GROUP_6, BMT_CHARGING_ALREADY_ON_TRC);
}
}
else
{
BMT.pmictrl_state = PMIC_CHARGEOFF;
ChrCtrl = KAL_FALSE;
bmt_charging_control_handler(BMT_CHARGING_CMD_CHARGING_ENABLE, &ChrCtrl);
}
}
void ctp_cypress_cy8ctma340_power(kal_bool ON)
{
static kal_bool power_status = KAL_FALSE;
kal_bool sleep, wakeup;
if(ON == power_status) //do not turn on/off pmu ldo again.
return;
power_status = ON;
if(gpio_ctp_power_enable_pin != 0xFF)
{
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_SET_DIR_OUT, NULL);
}
if(gpio_ctp_reset_pin != 0xFF)
{
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_SET_DIR_OUT, NULL);
}
if(ON)
{
wakeup = CTP_I2C_write_byte(HST_MODE_ADDR, HST_MODE_NORMAL); //toggle the controller.
if(gpio_ctp_power_enable_pin != 0xFF)
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_WRITE_HIGH, NULL);
ctp_i2c_udelay(1000);
if(gpio_ctp_reset_pin != 0xFF)
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_WRITE_LOW, NULL);
ctp_i2c_udelay(10000);
if(gpio_ctp_reset_pin != 0xFF)
DclGPIO_Control(ctp_gpio_reset_handle, GPIO_CMD_WRITE_HIGH, NULL);
drv_trace2(TRACE_GROUP_10, CTP_CAPACITIVE_POWER, ON, wakeup);
}
else
{
sleep = CTP_I2C_write_byte(HST_MODE_ADDR, HST_MODE_DEEP_SLEEP); //toggle the controller.
drv_trace2(TRACE_GROUP_10, CTP_CAPACITIVE_POWER, ON, sleep);
if(!sleep)
{
if(gpio_ctp_power_enable_pin != 0xFF)
DclGPIO_Control(ctp_gpio_power_handle, GPIO_CMD_WRITE_LOW, NULL);
drv_trace0(TRACE_GROUP_10, CTP_CAPACITIVE_POWER_DOWN);
}
}
ctp_i2c_power_on(ON, CTP_I2C_LDO, 0);
}
kal_bool ctp_cypress_cy8ctma340_get_data(TouchPanelMultipleEventStruct *tpes)
{
kal_bool i2c_ret;
kal_uint8 reg[2];
kal_uint32 model = 0;
ASSERT(tpes);
tpes->time_stamp = (kal_uint16)L1I_GetTimeStamp();
tpes->padding = CTP_PATTERN;
i2c_ret = CTP_I2C_read(TT_MODE_ADDR, reg, 2);
if(i2c_ret == KAL_FALSE)
{
ctp_cypress_cy8ctma340_toggle();
return KAL_FALSE;
}
if(reg[0] & TT_MODE_BUFFER_INVALID)
{
drv_trace0(TRACE_GROUP_10, CTP_CAPACITIVE_GET_DATA_INVALID);
ctp_cypress_cy8ctma340_toggle();
return KAL_FALSE;
}
model = (kal_uint32)(reg[1] & TT_STAT_NUMBER_TOUCH);
drv_trace1(TRACE_GROUP_10, CTP_CAPACITIVE_MODEL, model);
if(model > 4) //cypress only support 4 fingers
{
ctp_cypress_cy8ctma340_toggle();
return KAL_FALSE;
}
tpes->model = (kal_uint16)model; //read out all touch points coordinates.
if(model == 0)
{
ctp_cypress_cy8ctma340_toggle();
return KAL_FALSE;
}
ctp_read_all_point(tpes, model);
ctp_cypress_cy8ctma340_toggle();
return KAL_TRUE;
}
/*************************************************************************
* FUNCTION
* e_compass_sensor_power_on
*
* DESCRIPTION
* This function is to turn on sensor
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void e_compass_sensor_power_on(void)
{
static kal_bool is_middleware_init = KAL_FALSE;
drv_trace0(TRACE_GROUP_10, EC_CALIBRATION_POWERON);
if (KAL_FALSE == is_middleware_init)
{
/* we just need to initialize middleware once */
e_compass_sensor_custom_fp->ec_init_calibrated_data(&e_compass_calibrated_data);
is_middleware_init = KAL_TRUE;
}
e_compass_sensor_custom_fp->ec_turn_on(1);
/* we start timer, after timer expired, it will invoke e_compass_sensor_power_on_callback
because sensor need some time to be ready after power on */
kal_set_timer(e_compass_power_on_timer_id,(kal_timer_func_ptr)e_compass_sensor_power_on_callback,NULL,
e_compass_sensor_custom_dp->poweron_delay,0);
}
void bmt_sw_polling_ov(void *timer_param)
{
PMU_CTRL_CHR_GET_VCDT_HV_DET chr_hv_det;
DclPMU_Control(bmt_PmuHandler, CHR_GET_VCDT_HV_DET, (DCL_CTRL_DATA_T *)&chr_hv_det);
if (chr_hv_det.HV_deteted)
{
drv_trace0(TRACE_GROUP_10, BMT_SW_POLLING_CHARGER_OV_TRC);
BMT_Charge(KAL_FALSE);
}
else
{
DclPMU_Control(bmt_PmuHandler, CHR_SET_WDT_CLEAR, NULL);
}
kal_set_timer(bmt_sw_polling_timerId, (kal_timer_func_ptr)bmt_sw_polling_ov, NULL,43 , 0); //200ms
}
static void bmt_sw_polling_charger_ov(void *timer_param)
{
DCL_BOOL charge_en = KAL_FALSE;
DCL_BOOL hv_status;
bmt_charging_control_handler(BMT_CHARGING_CMD_GET_HV_STATUS, &hv_status);
if (DCL_TRUE == hv_status)
{
bmt_charging_control_handler(BMT_CHARGING_CMD_CHARGING_ENABLE, &charge_en);
drv_trace0(TRACE_GROUP_10, BMT_SW_POLLING_CHARGER_OV_TRC);
}
else
{
bmt_charging_control_handler(BMT_CHARGING_CMD_WDT_CLEAR,NULL);
}
kal_set_timer(bmt_sw_polling_timerId, (kal_timer_func_ptr)bmt_sw_polling_charger_ov, NULL, KAL_TICKS_200_MSEC , 0);
}
VIDEO_DECODER_CODEC_ERROR_T H264HwDecoderOpenAdapt(void)
{
OPEN_API_MEM_INFO_T rMem;
drv_trace0(TRACE_GROUP_8, H264HWDEC_OPEN);
VideoH264DecGetParam(OPEN_API_PARAM_MEM_INFO, &rMem, sizeof(OPEN_API_MEM_INFO_T));
rH264HwDecCtrl.fgBsBufferCacheable = (rMem.isBsCacheable == 1) ? KAL_TRUE : KAL_FALSE;
rH264HwDecCtrl.fgFrmBufferCacheable = (rMem.isFrameCacheable == 1) ? KAL_TRUE : KAL_FALSE;
if (VideoDecoderCheckIntBuffer() != KAL_TRUE)
{
rH264HwDecCtrl.u4IntMemOriginalAddr = (kal_uint32)VideoDecoderMalloc(rMem.u4IntMemSize + CPU_CACHE_LINE_SIZE*2);
if (rH264HwDecCtrl.u4IntMemOriginalAddr == 0)
{
ASSERT(0);
}
rH264HwDecCtrl.fgExtMemReplaceIntMem = KAL_TRUE;
rH264HwDecCtrl.u4IntMemAlignSize = H264_HW_ROUND_UP_TO_POWER_OF_TWO(rMem.u4IntMemSize, CPU_CACHE_LINE_SIZE);
rH264HwDecCtrl.u4IntMemAddr = H264_HW_ROUND_UP_TO_POWER_OF_TWO(rH264HwDecCtrl.u4IntMemOriginalAddr, CPU_CACHE_LINE_SIZE);
/* Should switch to non-cache */
if (VideoCommIsExtBufferCacheable((kal_uint32)rH264HwDecCtrl.u4IntMemAddr, rH264HwDecCtrl.u4IntMemAlignSize) == KAL_FALSE)
{
/* External memory allocated from common part is NON-CACHEABLE */
rH264HwDecCtrl.fgExtMemReplaceIntMemSwitch = KAL_FALSE;
}
else
{
rH264HwDecCtrl.fgExtMemReplaceIntMemSwitch = KAL_TRUE;
rH264HwDecCtrl.u4IntMemAddr = VideoCommExtBufferCacheableSwitch(rH264HwDecCtrl.u4IntMemAddr,
rH264HwDecCtrl.u4IntMemAlignSize, VIDEO_NON_CACHEABLE);
}
}
else
{
rH264HwDecCtrl.u4IntMemAddr = VideoDecoderIntBuffer(rMem.u4IntMemSize);
rH264HwDecCtrl.fgExtMemReplaceIntMem = KAL_FALSE;
}
return VIDEO_DECODER_CODEC_ERROR_NONE;
}
VIDEO_ENCODER_CODEC_ERROR_T MPEG4HWEncInit(void)
{
CUSTOM_VENC_ERROR_T ret;
kal_uint32 u4val;
_MPEG4HWEncControlInit();
ASSERT(rpMPEG4HWEncDriver);
ASSERT(rMPEG4HWEncCtrl.u4FrameRate);
ret = CustomVenc_Ctrl(CUSTOM_VENC_OP_GET_BIT_RATE, NULL, 0, &u4val, sizeof(kal_uint32));
ASSERT(ret == CUSTOM_VENC_ERROR_NONE);
MPEG4HWEncSetParameter(VENC_PARAM_BITRATE, &u4val);
rpMPEG4HWEncDriver->init();
drv_trace0(TRACE_GROUP_10, MPEG4HWENC_INIT);
return VIDEO_ENCODER_CODEC_ERROR_NONE;
}
/* Note that this is called periodically when ms is active */
void USB_Host_Ms_State_Main(kal_uint8 ms_index)
{
kal_bool result;
// SGPT_CTRL_START_T start;
if(g_UsbHostMs[ms_index].dev_attatch == KAL_TRUE)
{
result = USB_Host_Ms_Check_All_Media(ms_index);
}
else
{
result = KAL_FALSE;
USB_Dbg_Trace(USB_HOST_MS_STATE_MAIN_FALSE, 0, 0);
}
drv_trace1(TRACE_FUNC, (kal_uint32)USB_HOST_MS_CHECK_MEDIA_STATE, g_UsbHostMs[ms_index].media_state_change);
USB_Dbg_Trace(USB_HOST_MS_REPORT_MEDIA_STATE, g_UsbHostMs[ms_index].media_state_change, (kal_uint32)g_UsbHostMs[ms_index].b_sending_change_ilm);
if(result == KAL_TRUE)
{
if((g_UsbHostMs[ms_index].media_state_change != 0)&&(g_UsbHostMs[ms_index].b_sending_change_ilm == KAL_FALSE))
{
/* Send message to FMT task about card state change */
USB_Host_Ms_Check_Media_State(ms_index);
}
/* start timer to start query device state */
USB_GPTI_StartItem(g_UsbHostMs[ms_index].gpt_handle, USB_HOST_MS_QUERY_PERIOD,USB_Host_Ms_State_Timeout, &g_UsbHostMs[ms_index]);
// start.u2Tick =USB_HOST_MS_QUERY_PERIOD;
// start.pfCallback = USB_Host_Ms_State_Timeout;
// start.vPara = &g_UsbHostMs[ms_index];
// DclSGPT_Control((DCL_HANDLE)(g_UsbHostMs[ms_index].gpt_handle), SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start);
}
else
{
drv_trace0(TRACE_FUNC, (kal_uint32)USB_HOST_MS_STATE_MAIN_FAIL);
}
}