/*****************************************************************************
* FUNCTION
* nvram_suspend_handler
* DESCRIPTION
* This is the handler to handle MSG_ID_NVRAM_SUSPEND_REQ
* After nvram receive this request, it will be suspend forever now.
* PARAMETERS
* ilm_ptr [IN] the message content
* RETURNS
* void
*****************************************************************************/
void nvram_suspend_handler(ilm_struct *ilm_ptr)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
nvram_suspend_req_struct *nvram_suspend_req = (nvram_suspend_req_struct*) ilm_ptr->local_para_ptr;
nvram_suspend_cnf_struct *nvram_suspend_cnf;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
nvram_suspend_cnf = (nvram_suspend_cnf_struct*) construct_local_para(sizeof(nvram_suspend_cnf_struct), TD_CTRL);
nvram_suspend_cnf->result = NVRAM_ERRNO_SUCCESS;
nvram_send_ilm(ilm_ptr->src_mod_id, MSG_ID_NVRAM_SUSPEND_CNF, nvram_suspend_cnf, NULL);
if (nvram_suspend_req == NULL || nvram_suspend_req->suspend_time == 0)
{
while(1)
{
kal_sleep_task(100);
}
}
else
{
kal_sleep_task(nvram_suspend_req->suspend_time);
}
return;
}
static void ktStop_nonblocking( void *data )
{
if (keytone.state == TONE_STATE_NONE)
return;
if( !L1Audio_CheckFlag( keytone.aud_id ) )
return;
keytone.isReentrance = true;
if (keytone.state == TONE_STATE_INIT) {
L1Audio_InProcCall( ktStopInMedTask, keytone.seqNum, 0 );
kal_sleep_task( 2 );
}
if (keytone.state == TONE_STATE_PLAY) {
keytone.state = TONE_STATE_STOP;
L1Audio_PutMessageAndWait(MSG_L1AUDIO2FAS_AUDIO_PLAYBACK_OFF, keytone.fc_aud_id, 0, false);
}
if (keytone.state == TONE_STATE_STOP) {
L1Audio_InProcCall( ktStopInMedTask, keytone.seqNum, 0 );
kal_sleep_task( 2 );
return;
}
if (keytone.state == TONE_STATE_IDLE) {
keytone.state = TONE_STATE_UNHOOKING;
L1Audio_FC_UnHookHandler_WithoutWaitingSend(keytone.fc_aud_id, 0);
}
if (keytone.state == TONE_STATE_UNHOOKING) {
L1Audio_InProcCall( ktStopInMedTask, keytone.seqNum, 0 );
kal_sleep_task( 2 );
return;
}
if (keytone.state == TONE_STATE_UNHOOKED) {
keytone.state = TONE_STATE_NONE;
L1Audio_FC_UnHookHandler_WithoutWaitingClear(keytone.fc_aud_id, 0);
keytone.fc_aud_id = 0xFFFF;
}
AM_KeyToneOff();
L1Audio_ClearFlag( keytone.aud_id );
keytone.seqNum++;
}
static void dtmf_mcu_Destroy(kal_uint32 arg1, void* arg2)
{
kal_bool fIsAudioRunning = false;//PcmSink_IsAudioRuning() || PcmSink_IsMixerRuning();
kal_trace( TRACE_GROUP_AUD_PLAYBACK, MCU_DTMF_DESTROY, DTMF_SW.pHandle, DTMF_SW.fNewDTMF, DTMF_SW.fEnding, DTMF_SW.fForceStop);
if(DTMF_SW.pHandle == NULL)
{
return;
}
if((DTMF_SW.fNewDTMF == KAL_FALSE && DTMF_SW.fEnding == KAL_TRUE) || DTMF_SW.fForceStop)
{
{
{
// void AM_SWToneOff( void );
// AM_SWToneOff();
}
}
DTMF_SW.pHandle = NULL;
L1Audio_ClearFlag( DTMF_SW.uAudId);
L1Audio_FreeAudioID(DTMF_SW.uAudId);
audio_free_mem( (void **) &DTMF_SW.RingBuffer.rb_base);//
DTMF_SW.RingBuffer.rb_base = NULL;
if(fIsAudioRunning)
{
////! PcmSink_Mute(KAL_TRUE, PCMSINK_MUTE_TONE);
kal_sleep_task(uDtmfMuteLength3);
}
if(DTMF_SW.fIsKeytonePlaying)
{
////! PcmSink_StopSound(PCM_FUNC_KEYTONE);
}
else if(DTMF_SW.fIsTonePlaying)
{
////! PcmSink_StopSound(PCM_FUNC_TONE);
}
else
{
ASSERT(0);
}
memset(&DTMF_SW, 0, sizeof(DTMF_SW));
if(fIsAudioRunning)
{
kal_sleep_task(uDtmfMuteLength4);
}
////! PcmSink_DepopUnMute( NULL );
////! PcmSink_Mute(KAL_FALSE, PCMSINK_MUTE_TONE);
}
}
static void pcmStrmCloseDevice( MHdl *hdl )
{
uint16 I, ctl;
pcmStrmMediaHdl *ihdl = (pcmStrmMediaHdl *)hdl;
for ( I = 0; ; I++ ) {
ctl = *DSP_PCM_CTRL;
if ( ctl == 0 ) // DSP returns to idle state
break;
if ( ctl == 8 ) {
*DSP_PCM_CTRL = WAV_ABORT_STATE; // give ABORT command to the DSP
kal_trace( TRACE_STATE, L1AUDIO_STOP_STATE );
}
ASSERT_REBOOT( I < 40 );
kal_sleep_task( 2 );
}
kal_trace( TRACE_STATE, L1AUDIO_IDLE_STATE );
#if defined(MT6205B)
if( ihdl->pcmStrm.freqType == 0x20 ) // sampling frequency: 16k
AM_PCM16K_PlaybackOff( true );
else // sampling frequency: 8k
AM_PCM8K_PlaybackOff( true );
#else
#if !defined(__BT_AUDIO_VIA_SCO__)
if ( ihdl->pcmStrm.is8KVoice )
AM_PCM8K_PlaybackOff( true );
else
#endif
AM_AudioPlaybackOff( true );
#endif
mhdlAllowSleep( hdl );
}
static void I2S_RecordOff()
{
kal_uint32 I=0;
i2s.state = I2S_RECORD_STATE_READY;
kal_sleep_task(9); //flush the last frame //(1152*1000)/(32000*4.615)=
kal_trace( TRACE_FUNC, L1AUDIO_I2S_REC_OFF );
#if !defined(__AUDIO_RECORD_COMPONENT_SUPPORT__)
HOST_APM_UnRegister(APM_TASKID_I2S_RECORD);
while(i2s.pEnchdl != NULL)
{
kal_sleep_task(1);
I++;
ASSERT(I<80);
}
#endif
}
void SerialCommCAMReset(void)
{ // For EV200 only, solve a hardware bug
init_isp_if();
kal_sleep_task(4);
power_off_isp();
SerialCommPullHigh();
}
void DSP_BGSND_Stop(void)
{
kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_Stop] Enter");
DSP_BGSnd.state = DSP_BGSND_STATE_STOPPING;
{ //turn off DSP BGSND
uint32 I;
if(SAL_Bgsnd_IsRunning())
SAL_Bgsnd_SetFinal();
for ( I = 0; ; I++ ) {
if ( SAL_Bgsnd_IsIdle()) /* DSP returns to idle state */
break;
ASSERT_REBOOT( I < 20 );
kal_sleep_task( 2 );
}
AM_SND_PlaybackOff( true );
}
#ifdef DSP_BGS_UP_DOWN_INT_SEPERATE
L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL);
L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_UL);
#else
L1Audio_UnhookHisrHandler(D2C_SOUND_EFFECT_INT_ID_DL);
#endif
DSP_BGSnd.state = DSP_BGSND_STATE_IDLE;
kal_prompt_trace(MOD_L1SP, "[DSP_BGSND_Stop] Leave");
}
//-----------------------------------------------------------------------------
int gps_soc_request_abort(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
if (gps_soc_transaction.socket_id >= 0)
{
ilm_struct *ilm_send = NULL;
int ret;
ret = soc_close(gps_soc_transaction.socket_id);
gps_soc_log("soc_close result: %d", ret);
kal_sleep_task(250);
soc_close_nwk_account_by_id(MOD_GPS_TCPIP, gps_soc_transaction.nwt_acount_id);
/* close socket and disconnect bearer here */
ilm_send = allocate_ilm(MOD_GPS_TCPIP);
ilm_send->msg_id = MSG_ID_APP_SOC_DEACTIVATE_REQ;
ilm_send->peer_buff_ptr = NULL;
ilm_send->local_para_ptr = NULL;
SEND_ILM(MOD_GPS_TCPIP, MOD_SOC, SOC_APP_SAP, ilm_send);
}
gps_soc_transaction.post_retry_counter = 0;
gps_soc_stop_timer();
return 0;
}
void multiple_sim_test()
{
kal_uint32 testIndex = 0;
sim_MT6302_init();
init_all_cb2();
while(1){
switch( (testIndex % SIM_TEST_FUNCTION_NUMBER_MAX)){
case 0:
sim_test_function_sim3();
break;
case 1:
sim_test_reset_phone(SIM_ICC_APPLICATION_PHONE1);
break;
case 2:
sim_test_reset_phone(SIM_ICC_APPLICATION_PHONE2);
break;
case 3:
sim_test_phone_selectGSM(SIM_ICC_APPLICATION_PHONE1);
break;
case 4:
sim_test_phone_selectGSM(SIM_ICC_APPLICATION_PHONE1);
break;
default:
ASSERT(0);
}
testIndex ++;
kal_sleep_task(20);
}
}
kal_bool ccci_ipc_it_send_msg(void *p_param, kal_char *p_ret_err_str, kal_uint32 *p_ret_err_str_sz){
kal_uint32 err_str_len = *p_ret_err_str_sz;
ipc_ilm_t *ilm_ptr = NULL;
kal_int32 ret = KAL_TRUE;
ccci_ipc_ch.it_mode = CCCI_IPC_IT_DISABLE;
/* allocate and fill cross message structure */
ilm_ptr = ipc_msgsvc_allocate_ilm(MOD_L4C);
ilm_ptr->src_mod_id = MOD_L4C;
ilm_ptr->dest_mod_id = APMOD_AGPS;
ilm_ptr->msg_id = (kal_uint32)IPC_EL1_MSG_ID_BEGIN;
ilm_ptr->peer_buff_ptr = NULL; /* no peer message */
ilm_ptr->local_para_ptr = (local_para_struct*) NULL;
ilm_ptr->sap_id = MMI_L4C_SAP;
ret = ipc_msgsvc_send_ext_queue(ilm_ptr);
if (ret == KAL_FALSE){
*p_ret_err_str_sz = snprintf(p_ret_err_str, err_str_len,
"error test\n"
);
return KAL_FALSE;
}
kal_sleep_task(KAL_TICKS_1_SEC);
return KAL_TRUE;
}
void Del_PcmEx_Start(void (*pcmNway_dl_hdlr)(void), void (*pcmNway_ul_hdlr)(void),
uint32 cfgUL1, uint32 cfgUL2, uint32 cfgUL3, uint32 cfgUL4, uint32 cfgDL)
{
uint32 I;
kal_bool flag;
// prevent re-entry!!
ASSERT(PNW_STATE_IDLE == pcmEx.state);
pcmEx.aud_id = L1Audio_GetAudioID();
L1Audio_SetFlag( pcmEx.aud_id ); /*Be careful.Before Locking SleepMode, to access DSP sherrif tasks much time. So access DSP must be after SetFlag*/
// band and am type setting
pcmEx.bandInfo = PCMEX_BAND_DYNAMIC;
pcmEx.am_type = AM_PCMEX_TYPE_DEDICATION;
// pcmEx.dspPcmExMicLen = 0;
// pcmEx.dspPcmExSpkLen = 0;
pcmEx.cfgUL1 = cfgUL1;
pcmEx.cfgUL2 = cfgUL2;
pcmEx.cfgUL3 = cfgUL3;
pcmEx.cfgUL4 = cfgUL4;
pcmEx.cfgDL = cfgDL;
pcmEx.pnw_dl_hdlr = pcmNway_dl_hdlr;
pcmEx.pnw_ul_hdlr = pcmNway_ul_hdlr;
L1Audio_HookHisrHandler(DP_D2C_PCM_EX_DL,(L1Audio_EventHandler)pcmEx_hisrDlHdlr, 0);
L1Audio_HookHisrHandler(DP_D2C_PCM_EX_UL,(L1Audio_EventHandler)pcmEx_hisrUlHdlr, 0);
// check DSP state and turn on
ASSERT(SAL_PcmEx_CheckStateUL(SAL_PCMEX_TYPE_PNW, SAL_PCMEX_OFF) && SAL_PcmEx_CheckStateDL(SAL_PCMEX_TYPE_PNW, SAL_PCMEX_OFF));
AM_PCM_EX_On(pcmEx.am_type, (uint32)(&pcmEx));//to config pnw
SAL_PcmEx_SetStateUL(SAL_PCMEX_TYPE_PNW, SAL_PCMEX_ON);
SAL_PcmEx_SetStateDL(SAL_PCMEX_TYPE_PNW, SAL_PCMEX_ON);
// wait for ready
for(I = 0; ;I ++){
kal_bool is_ready = true;
if( (pcmEx.cfgDL & (USE_D2M_PATH+USE_M2D_PATH)) && (!SAL_PcmEx_CheckStateDL(SAL_PCMEX_TYPE_PNW, SAL_PCMEX_RDY)))
is_ready &= false;
if( (pcmEx.cfgUL1 & (USE_D2M_PATH+USE_M2D_PATH)) && (!SAL_PcmEx_CheckStateUL(SAL_PCMEX_TYPE_PNW, SAL_PCMEX_RDY)))
is_ready &= false;
if(is_ready)
break;
#ifndef L1D_TEST
ASSERT(I < 22); // wait 200ms
kal_sleep_task(2);
#endif
}
pcmEx.state = PNW_STATE_RUN;
/* the end of configure the SAL */
}
kal_int32 init_gt818_download_module( kal_uint16 cur_ver, kal_uint8 *firmware_ptr )
{
kal_int32 ret = 0;
outbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN );
inbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN );
dbgbuf = (kal_char *)get_ctrl_buffer( MAX_BUFFER_LEN );
if ( ( outbuf == NULL ) ||
( inbuf == NULL ) ||
( dbgbuf == NULL ) )
{
EXT_ASSERT(0, (kal_uint32)outbuf, (kal_uint32)inbuf, (kal_uint32)dbgbuf);
return 0;
}
CTP_DWN_DEBUG_LINE_TRACE();
//rst_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_SHUTDN_PIN);
//int_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_INT_PIN);
int_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_eint_pin);
rst_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_reset_pin);
DclGPIO_Control(rst_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_0, NULL);
DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_OUT, NULL);
ret = gt818_downloader_probe( cur_ver, firmware_ptr );
//DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_IN, NULL);
//DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_1, NULL);
DclGPIO_Control(int_handle, GPIO_CMD_WRITE_HIGH, NULL);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_LOW, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(120);
free_ctrl_buffer( outbuf );
free_ctrl_buffer( inbuf );
free_ctrl_buffer( dbgbuf );
if ( downloader_errno )
EXT_ASSERT( 0, downloader_errno, 0, 0 );
return ret;
}
void noke_drv_horse_race_light(int lights)
{
int para = ( lights & HORSE_RACE_MASK )| ( noke_drv_pre_light_parameter & (~HORSE_RACE_MASK));
//noke_dbg_printf("\r Hongzhe.liu: noke_drv_horse_race_light = 0x%04x \n", lights);
if( (lights != 0x0000 && para != 0x0000 ) || (lights == 0x0000 && para == 0x0000 ))
noke_drv_horse_race_set( para );
kal_sleep_task(10);
}
static kal_uint8 gt818_reset( void )
{
kal_uint8 ret = 1;
kal_uint8 retry_count = 0;
outbuf[0] = 1;
outbuf[1] = 1;
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_LOW, NULL);
kal_sleep_task(5);
DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);
kal_sleep_task(120);
search_i2c:
//gt818_i2c_write( guitar_i2c_address, 0x00FF, outbuf, 1 );
//kal_sleep_task( 12 );
gt818_i2c_read( guitar_i2c_address, 0x00FF, inbuf, 1 );
if ( inbuf[0] != 0x55 )
{
drv_trace2( TRACE_GROUP_7, CTP_GOODIX_DWN_REGISTER_TRACE, 0x00FF, inbuf[0] );
kal_sleep_task(10);
if ( retry_count < 10 )
{
retry_count++;
goto search_i2c;
}
else
{
ASSERT(0);
}
}
drv_trace1( TRACE_GROUP_7, CTP_GOODIX_DWN_DETECT_ADDR_TRACE, guitar_i2c_address );
kal_sleep_task(120);
return ret;
}
Media_Status GenCompStop( MHdl *hdl )
{
MHPB_Internal *ihdl = (MHPB_Internal *)hdl;
kal_int32 I,J;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_STOP, hdl->mediaType, hdl->state,0,0,0,0);
if( hdl->state == COMPONENT_STATE_PAUSE || hdl->state == COMPONENT_STATE_IDLE )
return MEDIA_SUCCESS;
Media_A2V_REMOVE_MEDIA_END_CALLBACK(GenCompStop);
// Stop component
for(I = (ihdl->numComp-1); I>=0; I-- )
{
ihdl->NodeArray[I].curHdl->Stop(ihdl->NodeArray[I].curHdl);
}
for(I = (ihdl->numComp-1); I>=0; I-- )
{
ACU_FlushBufferQueue( (AudComHdl *)ihdl->NodeArray[I].curHdl );
}
ACU_SendEndCommandl( ihdl );
for (J = 0; ; J++) {
if (ihdl->endflag){
break;
}
kal_sleep_task( 1 );
}
#if defined(__BES_TS_SUPPORT__)
BesTS_FreeAudioHandle();
#endif
#if defined(__AUDIO_DSP_LOWPOWER_V2__)
if (ihdl->pstFSAL) {
if(AUDLP_Check_LowPower_Status())
AUDLP_Mode(KAL_FALSE, 1);
}
#endif
// Change status
hdl->state = COMPONENT_STATE_IDLE;
if (ihdl->region != DPMGR_NOT_MATCH) {
// Unload code
DPMGR_Unload(ihdl->region);
ihdl->region = DPMGR_NOT_MATCH;
}
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_STOP_FINISH, hdl->mediaType, hdl->state, 0,0,0,0,0);
return MEDIA_SUCCESS;
}
AudChip_Status ExtAudChip_Play(AudChipControl *audCtrl)
{
uint16 repeats;
Rohm8788_TurnOnClock();
AFE_TurnOnExtAmplifier();
RegWrite(REG_SEQU_CTRL, 0x00); // release standby mode
kal_sleep_task(3);
RegWrite(REG_SEQU_CTRL, 0x80); // enter normal mode
if(fmp_open(&fmp_work, NULL)!=0)
{
ExtAudChip_NotifyError();
ExtAudChip_ReturnFail;
}
switch(audCtrl->format){
case MEDIA_FORMAT_SMF:
if(fmp_cmd_setdata(&fmp_work, (uint8 *)audCtrl->melody_data, audCtrl->data_length, FMTID_SMF)!=0)
{
ExtAudChip_NotifyError();
ExtAudChip_ReturnFail;
}
if(audCtrl->repeat_times == 0)
repeats = 1;
else
repeats = 0;
break;
case MEDIA_FORMAT_IMELODY:
if(fmp_cmd_setdata(&fmp_work, (uint8 *)audCtrl->melody_data, audCtrl->data_length, FMTID_IMELODY)!=0)
{
ExtAudChip_NotifyError();
ExtAudChip_ReturnFail;
}
if(audCtrl->repeat_times == 0)
repeats = 1;
else
repeats = 0;
break;
}
if(fmp_cmd_play(&fmp_work, repeats)!=0)
{
ExtAudChip_NotifyError();
ExtAudChip_ReturnFail;
}
RegWrite(REG_MIDI_WAVEVOL, rohm_volume);
ExtAudChip_ReturnSuccess;
}
kal_bool IspWaitIspDone(ISP_OPERATION_STATE_ENUM IspState, kal_uint16 loop, kal_uint16 unit)
{
volatile kal_uint32 i=0;
while(KAL_FALSE==IspDoneFlag)
{
i++;
kal_sleep_task(unit);
if(i>loop) break;
}
if(i>loop)
return KAL_FALSE;
else
return KAL_TRUE;
}
static Media_Status GenCompRecStop( MHdl *hdl )
{
MHPB_Internal *ihdl = (MHPB_Internal *)hdl;
kal_int32 J;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_STOP, hdl->mediaType, hdl->state,0,0,0,0);
if( hdl->state == COMPONENT_STATE_PAUSE || hdl->state == COMPONENT_STATE_IDLE )
return MEDIA_SUCCESS;
{
AcHdlNode *pNode = ihdl->pNodeStart;
kal_uint8 *pWrite;
kal_uint32 uWriteLen;
while (pNode) {
for (J=4; J>=0; J--) {
ACU_SendProcessCommandl( (AudComHdlInt *)pNode->curHdl );
}
pNode->curHdl->Stop( pNode->curHdl );
// Flush: Push to next component
ACU_GetWriteBuffer(pNode->curHdl, &pWrite, &uWriteLen);
if (uWriteLen)
ACU_WriteDataDone_ImmediateCallback(pNode->curHdl, 0);
pNode = pNode->pNextNode;
}
pNode = ihdl->pNodeEnd;
while (pNode) {
ACU_FlushBufferQueue( pNode->curHdl );
pNode = pNode->pPrevNode;
}
}
ACU_SendEndCommandl( ihdl );
for (J = 0; ; J++) {
if (ihdl->endflag){
break;
}
kal_sleep_task( 1 );
}
// Change status
hdl->state = COMPONENT_STATE_IDLE;
kal_trace( TRACE_GROUP_AUD_PLAYBACK, L1AUDIO_GENERAL_INFO, AUDIO_TRACE_STOP_FINISH, hdl->mediaType, hdl->state, 0,0,0,0,0);
return MEDIA_SUCCESS;
}
static void pcmStrmRecCloseDevice( MHdl *hdl )
{
uint16 I, ctl;
for ( I = 0; ; I++ ) {
ctl = *DSP_PCM_REC_CTRL;
if ( ctl == 0 ) // DSP returns to idle state
break;
if ( ctl == 0x400 )
*DSP_PCM_REC_CTRL = 0x800; // give ABORT command to the DSP
ASSERT_REBOOT( I < 20 );
kal_sleep_task( 2 );
}
AM_PCM8K_RecordOff( true );
mhdlAllowSleep( hdl );
}
static void I2S_RecordOn()
{
kal_uint32 I=0;
i2s.state = I2S_RECORD_STATE_RECORDING;
i2s.flush_encoder = false;
kal_trace( TRACE_FUNC, L1AUDIO_I2S_REC_ON );
#if !defined(__AUDIO_RECORD_COMPONENT_SUPPORT__)
HOST_APM_Register(APM_TASKID_I2S_RECORD);
while(i2s.pEnchdl == NULL)
{
kal_sleep_task(1);
I++;
ASSERT(I<80);
}
#endif
}
static void toneStop( void *data )
{
if (tone.state == TONE_STATE_NONE)
return;
if( !L1Audio_CheckFlag( tone.aud_id ) )
return;
if (tone.isReentrance)
return;
else
tone.isReentrance = true;
tone.bQTMF = false;
if (tone.state == TONE_STATE_INIT) {
int I;
for (I = 0; ; I++) {
if (tone.state != TONE_STATE_INIT)
break;
ASSERT_REBOOT( I < 20 );
kal_sleep_task( 2 );
}
}
if (tone.state == TONE_STATE_PLAY) {
tone.state = TONE_STATE_STOP;
tone.isWait = true;
L1Audio_FC_TonePlaybackOff(tone.fc_aud_id);
tone.isWait = false;
tone.state = TONE_STATE_IDLE;
}
if (tone.state == TONE_STATE_IDLE) {
tone.state = TONE_STATE_NONE;
L1Audio_FC_UnHookHandler(tone.fc_aud_id, 0);
tone.fc_aud_id = 0xFFFF;
}
AM_ToneOff();
AFE_TurnOffSpeaker( L1SP_TONE );
L1Audio_ClearFlag( tone.aud_id );
tone.seqNum++;
L1Audio_SetEvent( tone.aud_id, 0 );
}
void bgsndOnHandler(void)
{
AM_SND_PlaybackOn();
SAL_Bgsnd_SetInit();
//*DSP_SOUND_EFFECT_CTRL = DP_BGSND_STATE_READY;
{
uint32 I;
for( I = 0; ; I++ ) {
//if( *DSP_SOUND_EFFECT_CTRL == DP_BGSND_STATE_PLAYING)
if(SAL_Bgsnd_IsRunning())
break;
ASSERT_REBOOT( I < 20 );
kal_sleep_task( 2 );
}
}
}
void Direction_Sensor_state_Filter()
{
kal_uint8 direction_sensor_tmr_handle = DIRECTION_SENSOR_TMR_HANDLE;
kal_uint16 direction_sensor_tmr_repeat = 50; /* 1s = 100ticks, 0.1s = 10ticks */
kal_bool ret = KAL_FALSE;
//noke_dbg_printf("\rHongzhe.Liu : Direction_Sensor_state_Filter ... \n");
GPTI_StopItem(direction_sensor_tmr_handle);
kal_sleep_task(100);
do{
ret = GPTI_StartItem(direction_sensor_tmr_handle,
direction_sensor_tmr_repeat,
Direct_Sensor_Set_Sensor_State,
NULL);
//noke_dbg_printf("\rHongzhe.Liu : Direction_Sensor_state_Filter : start ret=%d... \n", ret);
}while( ret== KAL_FALSE );
}
static void pcmStrmRecOpenDevice( pcmStrmMediaHdl *ihdl )
{
uint16 I;
ihdl->end_status = MEDIA_NONE;
mhdlDisallowSleep( (MHdl*)ihdl );
if (ihdl->pcmStrm.dedicated_mode) { // PCM recording in TCH mode/
AM_PCM8K_RecordOn();
} else {
*DSP_PCM_REC_CTRL = 0x200;
AM_PCM8K_RecordOn();
for ( I = 0; ; I++ ) {
if ( *DSP_PCM_REC_CTRL == 0x400 )
break;
ASSERT_REBOOT( I < 20 );
kal_sleep_task( 2 );
}
}
}
void usbc_mode_switch(usb_mode_e mode){
kal_uint32 idx;
usbc_core_t* usbc_inst = usbc_core_get_instance();
usbc_class_reinit_func_t class_reinit;
usbc_ind_t ind_to_enqueue; // Do mode switch immediately if it is not in HISR, or enqueue a mode switch event for USBCORE task
if (!kal_if_hisr()) {
#if 1
if (mode == USB_MODE_MSD_OSDRTY){
/* wait 3 second for OSD known issue */
kal_sleep_task(600);
}
#endif
/* 1. set disconnect */
hifusb_set_disconnect();
usbc_empty_ind_queue();
/* 2. Set switch mode */
usbc_inst->is_mode_switch = KAL_TRUE;
usbc_inst->mode = mode;
/* 3. Send re-init callback to all usb class */
_SET_NODE_VALUE(0);
usbc_stack_checkin(USB_CLASS_NUM, NULL);
for (idx = 0; idx < USB_CLASS_NUM; idx++) {
class_reinit = _get_class_reinit_func(idx);
_SET_NODE_REG_TABLE(idx, NULL);
if (class_reinit) {
usbc_trace_info(USBCORE_ALL_NODE_CHECKIN_REINIT_CLASS_START, idx);
class_reinit(KAL_TRUE);
usbc_trace_info(USBCORE_ALL_NODE_CHECKIN_REINIT_CLASS_END, idx);
} else {
EXT_ASSERT(KAL_FALSE, 2, 0, 0);
}
}
} else {
ind_to_enqueue.type = USBC_IND_MODE_SWITCH;
ind_to_enqueue.ext = 0;
ind_to_enqueue.data = (kal_uint8)mode;
usbc_enqueue_ind(&ind_to_enqueue);
hmu_hifeg_set(HIF_DRV_EG_USBC_IND_EVENT);
}
}
static void tonePlayOn( void *data )
{
tone.isOnDur = true;
if( tone.bQTMF ) {
tone.curr_qtmf = (L1SP_QTMF *)tone.tonelist + (uint32)data;
tone.info->freq1 = tone.curr_qtmf->freq1;
tone.info->freq2 = tone.curr_qtmf->freq2;
tone.info->freq3 = tone.curr_qtmf->freq3;
tone.info->freq4 = tone.curr_qtmf->freq4;
} else {
tone.curr_qtmf = (L1SP_QTMF *)(tone.tonelist + (uint32)data);
tone.info->freq1 = tone.curr_qtmf->freq1;
tone.info->freq2 = tone.curr_qtmf->freq2;
tone.info->freq3 = 0;
tone.info->freq4 = 0;
}
if (tone.curr_qtmf->on_duration == 0) {
tone.info->msDur = -1;
} else {
tone.info->msDur = tone.curr_qtmf->on_duration;
}
AFE_TurnOnSpeaker( L1SP_TONE );
kal_sleep_task(1);
tone.state = TONE_STATE_INIT;
/*workaround for SPEECH DSP MAIN/AUX Mode Task in FCORE*/
#ifdef BGSND_ENABLE
if (tone.sndOffHandler != NULL)
tone.sndOffHandler( tone.sndHdl );
#endif
/*workaround for SPEECH DSP MAIN/AUX Mode Task in FCORE*/
L1Audio_FC_TonePlaybackOn(tone.fc_aud_id, tone.info);
// apply hardware mute during tone playback
//AFE_TurnOnSpeaker( L1SP_TONE );
}
void AVB_Flush()
{
kal_uint32 i=0;
AVB.uHisrRunning = KAL_FALSE;
if(AVB.uState == AVB_STATE_RUNING)
{
AVB.uState = AVB_STATE_FLUSH_TAIL;
}
while(AVB.uState != AVB_STATE_ENDING)
{
kal_trace( TRACE_GROUP_SCO, L1AUDIO_AVB_FLUSH, AVB.uState, AVB.uHisrRunning, i);
kal_sleep_task(1);
if(i>AVB_FLUSH_MAX_TICK)
{
//ASSERT(!AVB.uHisrRunning);
break;
}
i++;
}
}
void bgsndOffHandler(void)
{
if(BGSND_STATE_STOP != bgSnd.state) {
return;
}
uint32 I;
if(SAL_Bgsnd_IsRunning())
SAL_Bgsnd_SetFinal();
for ( I = 0; ; I++ ) {
if ( SAL_Bgsnd_IsIdle()) /* DSP returns to idle state */
break;
ASSERT_REBOOT( I < 20 );
kal_sleep_task( 2 );
}
AM_SND_PlaybackOff( true );
}
void ToneLoopBackRec(void(*callback)( kal_uint8 *pBuf, kal_uint16 mode ), ToneLBR_Para *pstPara )
{
#ifndef __L1_STANDALONE__ // avoid link error
ASSERT(ToneLBR.uState == TLBR_STATE_IDLE);
ASSERT(0xFFFF == ToneLBR.aud_id);
ToneLBR.aud_id = L1Audio_GetAudioID();
L1Audio_SetEventHandler( ToneLBR.aud_id, toneLoopbackRecHandler );
ToneLBR.callback = callback;
ToneLBR.uState = TLBR_STATE_INIT;
ToneLBR.uSize = pstPara->uSize - (pstPara->uSize%BYTES_PER_FRAME);
ToneLBR.pBuf = pstPara->pBuf;
ToneLBR.uMode = pstPara->uMode;
AFE_EnableToneLoopBackFlag( KAL_TRUE );
AM_EnableToneLoopBackFlag( KAL_TRUE );
if(pstPara->uMode)
KT_SetOutputDevice( L1SP_LOUD_SPEAKER ); // loud speaker mode
else
KT_SetOutputDevice( L1SP_SPEAKER1 ); // normal mode
kal_trace( TRACE_FUNC, L1AUDIO_TONE_LOOPBACK_REC_MODE, pstPara->uMode);
KT_SetOutputVolume( pstPara->bAnalogSpkGain, 0 );
KT_Play( pstPara->uFreq, pstPara->uFreq, 0 );
KT_SetAmplitude( pstPara->uKT_AMP );
kal_sleep_task(30); // to ensure tone is stable
// Activate 2-way PCM
AM_DSP_SetSpeechUplinkDigitalGain(pstPara->uUL_DigGain); // *DP_VOL_IN_PCM = pstPara->uUL_DigGain; // uplink digital gain
AM_DSP_SetSpeechDigitalGain(pstPara->uDL_DigGain); // *DP_VOL_OUT_PCM = pstPara->uDL_DigGain;
AFE_MuteMicrophone(KAL_FALSE); // un-mute microphone
L1SP_SetMicrophoneVolume( pstPara->uAnalogMicGain );
Media_SetOutputDevice( 0 );
PCM2WAY_Start( toneLoopBackRecHisr, 1 ); // voice
#endif // #ifndef __L1_STANDALONE__
}
void PCM2WAY_Start(void (*pcm2way_hdlr)(void), uint32 type)
{
uint32 I;
ASSERT(type==1 || type==2);
AM_PCM_EX_On(type);
ASSERT(DP_PCM_EX_CTRL == 0);
L1Audio_HookHisrHandler(DP_D2C_PCM_EX, (L1Audio_EventHandler)pcmEx_hisrHdlr, 0);
pcmEx.hdlr = pcm2way_hdlr;
pcmEx.state = PCM2WAY_STATE;
DP_PCM_EX_CTRL = 0x110;
for(I = 0; ;I ++)
{
if(DP_PCM_EX_CTRL == 0x120)
break;
ASSERT(I < 22); // wait 200ms
kal_sleep_task(2);
}
}
