/*****************************************************************************
* FUNCTION
* jbt_cmd_queue_init
* DESCRIPTION
*
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void jbt_cmd_queue_init(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
kal_uint8 i = 0;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
jbt_cmd_sem = kal_create_sem("jbt_cmd_sem", 1);
jbt_cmd_process_sem = kal_create_sem("jbt_cmd_process_sem", 1);
jbt_cmd_kick_sem = kal_create_sem("jbt_cmd_kick_sem", 1);
kal_mem_set((kal_uint8*) & jbt_cmd_queue_context, 0, sizeof(jbt_cmd_queue_context));
jbt_cmd_list_init(&jbt_cmd_queue_context.empty_list);
jbt_cmd_list_init(&jbt_cmd_queue_context.cmd_list);
jbt_cmd_queue_context.queue_kick_off = 0;
for (i = 0; i < JBT_MAX_COMMAND_QUEUE; i++)
{
jbt_cmd_list_init(&jbt_cmd_queue_context.cmd_node[i]);
jbt_cmd_list_insert_tail(&jbt_cmd_queue_context.empty_list, &jbt_cmd_queue_context.cmd_node[i]);
}
}
DCL_STATUS DclSIM_Initialize(void)
{
kal_uint32 maskedValue;
kal_uint32 loopIndex;
maskedValue = SaveAndSetIRQMask();
if(KAL_FALSE == fgSIMInit) {
fgSIMInit = KAL_FALSE;
RestoreIRQMask(maskedValue);
kal_mem_set(simResource, 0, sizeof(DCL_SIM_RESOURCE) * DCL_SIM_MAX_INTERFACE);
dclSimArb = kal_create_sem("SIM_DCL", 1);
for(loopIndex = 0; DCL_SIM_MAX_INTERFACE > loopIndex; loopIndex ++) {
simResource[loopIndex].guardHead = SIM_RESOURCE_HEAD;
simResource[loopIndex].guardTail = SIM_RESOURCE_TAIL;
simResource[loopIndex].driverHandle = SIM_RSC_HANDLE_UDEF;
}
sim_init_all_cb();
#ifdef MEUT_ON_FPGA
MT6302_test();
#endif
}
else {
RestoreIRQMask(maskedValue);
}
return STATUS_OK;
}
kal_bool
idp_imgdma_rotdma0_init(void)
{
memset(&owner, 0, sizeof(owner));
owner.sem = kal_create_sem("IDP", 1);
return KAL_TRUE;
}
RTFAPI RTFSYSAllocMutex(const char * Name)
{
if (NextMutex >= MAX_MUTEX)
{
fs_err_internal_fatal(FS_ERR_MUTEX_01, (void*)MAX_MUTEX);
}
M[NextMutex].rtf_lock_count = 0;
M[NextMutex].rtf_sem_owner = KAL_NILTASK_ID;
M[NextMutex].DeviceNum_1 = 0;
M[NextMutex].DeviceNum_2 = 0;
M[NextMutex++].rtf_sem = kal_create_sem((kal_char*)Name, INI_SEM);
return &M[NextMutex-1];
}
void ccci_ipc_init(void)
{
kal_uint32 p_cache_aligned;
//Send message does not need callback
ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.send_channel , ccci_ipc_send_msg_cb);
//send mesage ack need to implement callback
// ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.send_ack_channel , ccci_ipc_error_cb);
//Receive mesage need to implement callback
ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.receive_channel , ccci_ipc_receive_msg_cb);
//Receive mesage ack does not need to implement callback
// ccci_ipc_ch.ccci_init_gpdior(ccci_ipc_ch.receive_ack_channel , ccci_ipc_error_cb);
//Initialize the event for usage
if (ccci_ipc_ch.event == 0){
ccci_ipc_ch.event = kal_create_event_group("CCCI_IPC");
}
//Initialize the semaphore for critical section
if (ccci_ipc_ch.semaphore == 0){
ccci_ipc_ch.semaphore = kal_create_sem("CCCI_IPC",1);
}
/* initialize polling mode GPD */
ASSERT(CCCI_IPC_POLLING_MODE_BUF_SZ >= 2*CPU_CACHE_LINE_SIZE);
/*make p_gpd aligned to CPU_CACHE_LINE_SIZE_MASK*/
p_cache_aligned = (kal_uint32)g_ccci_ipc_polling_buf;
if(p_cache_aligned&CPU_CACHE_LINE_SIZE_MASK) {
p_cache_aligned = ((kal_uint32)(g_ccci_ipc_polling_buf)&~CPU_CACHE_LINE_SIZE_MASK);
p_cache_aligned += CPU_CACHE_LINE_SIZE;
}
// The reason + QBM_HEAD_SIZE is for ROME E1, cldma needs to record this buff whether is cacheable or non-cacheable
ccci_ipc_ch.p_polling_gpd = (qbm_gpd *)(p_cache_aligned + QBM_HEAD_SIZE);
// register ccci debug get status cb funp
ccci_debug_get_status_register(CCCI_DEBUG_GET_STATUS_MODULE_CCCIIPC, ccci_ipc_get_debug_status);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_ipc_ch.p_polling_gpd,ccci_ipc_ch.p_polling_gpd);
#ifdef CCCI_IT_MODE_CONTROL_CCCI_IPC
ccci_ipc_it_create();
#endif
}
void
idp_init(void)
{
kal_uint32 i;
/* All operations based on this buffer will assume that the size of the buffer
* is power of 2. This is to say that I have to ensure that the binary form of
* buffer_size must contain only one one.
*/
//ASSERT(1 == count_one_bit_number(IDP_TRACED_BUFFER_SIZE));
/* Because I need to call semaphore API, I have to ensure
* this function will not be called from HISR & LISR.
*/
if (kal_if_hisr() || kal_if_lisr())
{
ASSERT(0);
}
idp_owners_sem = kal_create_sem("IDP", 1);
for (i = 0; i < MAX_CONCURRENT_DP; ++i)
{
memset(&(owners[i]), 0, sizeof(owners[i]));
}
idp_hw_init();
#if defined(IDP_HISR_SUPPORT)
idp_hisr_init();
#endif
#if defined(DRV_IDP_6238_SERIES) || defined(DRV_IDP_MT6236_SERIES)
// For MT6268 VT video frame rotation
//idp_sw_yuv_rotator_init(); // for MT6268 VT
#endif // #if defined(DRV_IDP_6238_SERIES) || defined(DRV_IDP_MT6236_SERIES)
}
/******************************************************************************
* Function:
* GPSLocateNvramInitDataFile
*
* Usage:
* Initialize data file
* If the file doesn't exist, create it and write the default data to the file. Otherwise, load the
* content of the file to the cache.
*
* Parameters:
* None
*
* Return:
* KAL_TRUE - successfully
* KAL_FALSE - failed
******************************************************************************/
kal_bool GPSLocateNvramInitDataFile(void)
{
FS_HANDLE file_handle;
int result;
kal_uint16 folderName[GPSLOCATE_NVRAMDATA_FULLPATHNAME_LEN_MAX];
char tmpBuffer[GPSLOCATE_NVRAMDATA_FULLPATHNAME_LEN_MAX];
kal_bool bRet = KAL_TRUE, bNeedCreate = KAL_FALSE;
unsigned int Size;
unsigned char Ver;
if (gGPSLocateNvramSem != NULL)
{
//has been initialized
//do nothing, return error directly
return KAL_FALSE;
}
//create semaphore
gGPSLocateNvramSem = kal_create_sem("GPSNVRAM SEM", 1);
ASSERT((gGPSLocateNvramSem!=NULL));
/*
* Taking the semaphore here will make the handset not able to power up.
* Maybe, semaphore is not ready now.
*/
//take the semaphore
//kal_take_sem(gGPSLocateNvramSem, KAL_INFINITE_WAIT);
//initialize global data
gGPSLocateNvramFullPathFileName[0] = 0x0000;
gGPSLocateNvramDataCache.Valid = KAL_FALSE;
//construct folder name
sprintf(tmpBuffer, "%c:\\%s", GPSLOCATE_NVRAMDATA_DRV, GPSLOCATE_NVRAMDATA_FOLDER_NAME);
app_ansii_to_unicodestring((kal_int8*)folderName, (kal_int8*)tmpBuffer);
//check the folder exists or not
file_handle = FS_Open(folderName, FS_OPEN_DIR | FS_READ_ONLY );
if (file_handle < FS_NO_ERROR)
{
//the folder doesn't exist, create it.
result = FS_CreateDir(folderName);
if (result < FS_NO_ERROR)
{
//fail to create
bRet = KAL_FALSE;
//return KAL_FALSE;
goto _RelSem_Return_;
}
}
else
{
FS_Close(file_handle);
}
/*
1. construct full path file name
2. check file exist or not
3. check file valid or not (by file size)
4. if file doesn't exist or it is invalid, re-create and restore default data for it
*/
//construct full path file name
sprintf(tmpBuffer, "%c:\\%s%s",
GPSLOCATE_NVRAMDATA_DRV,
GPSLOCATE_NVRAMDATA_FOLDER_NAME,
GPSLOCATE_NVRAMDATA_FILE_NAME);
app_ansii_to_unicodestring((kal_int8*)gGPSLocateNvramFullPathFileName, (kal_int8*)tmpBuffer);
//check files exist or not
file_handle = FS_Open(gGPSLocateNvramFullPathFileName, FS_READ_ONLY);
if (file_handle < FS_NO_ERROR)
{
//this file doesn't exist, need create it
bNeedCreate = KAL_TRUE;
}
else
{
if (FS_GetFileSize(file_handle, &Size) < FS_NO_ERROR)
{
//fail to get file size, consider the file invalid, need create it
bNeedCreate = KAL_TRUE;
}
else if (Size != sizeof(GPSLocateNvramDataStruct_t))
{
//invalid size, need re-create it
bNeedCreate = KAL_TRUE;
}
else
{
//check version number
result = FS_Read(file_handle, &Ver, sizeof(unsigned char), &Size);
if (result == FS_NO_ERROR && Size == sizeof(unsigned char))
{
//Got version number
if (Ver != GPSLOCATE_NVRAM_VER_NO)
{
//old version, should be re-created
bNeedCreate = KAL_TRUE;
}
}
}
//close the file
FS_Close(file_handle);
if (bNeedCreate == KAL_TRUE)
{
//delete the bad file
FS_Delete(gGPSLocateNvramFullPathFileName);
}
}
if (bNeedCreate == KAL_FALSE)
{
#if 0//defined(M100)
if (gGPSLocateRestoreFlag == 1 && BMT.PWRon == PWRKEYPWRON)
{
//should restore the default value
file_handle = FS_Open(gGPSLocateNvramFullPathFileName, FS_READ_WRITE);
if (file_handle < FS_NO_ERROR)
{
//fail to open
bRet = KAL_FALSE;
goto _RelSem_Return_;
}
else
{
//load default
bRet = GPSLocateNvramLoadDefault(file_handle, KAL_FALSE);
FS_Close(file_handle);
goto _RelSem_Return_;
}
}
else
#endif // M100
{
//valid file, load the content to the cache
bRet = GPSLocateNvramLoadData();
goto _RelSem_Return_;
}
}
else
{
//create the file
if (GPSLocateNvramCreateDataFile() != KAL_TRUE)
{
//fail to create, set the full path name empty
gGPSLocateNvramFullPathFileName[0] = 0x0000;
bRet = KAL_FALSE;
//return KAL_FALSE;
goto _RelSem_Return_;
}
}
_RelSem_Return_:
//release the semaphore
//kal_give_sem(gGPSLocateNvramSem);
return bRet;
}
/******************************************************************************
* Function:
* GPSAppDataBackupInit
*
* Usage:
* Initialize data backup
*
* Parameters:
* None
*
* Return:
* void
******************************************************************************/
void GPSAppDataBackupInit(void)
{
FS_HANDLE file_handle;
int result;
kal_uint16 folderName[GPSAPP_DATABACKUP_FULLPATHNAME_LEN_MAX];
kal_int8 tmpBuffer[GPSAPP_DATABACKUP_FULLPATHNAME_LEN_MAX];
unsigned int Size;
GPSAppDataBackupError_t ErrCode;
kal_int32 ErrExt1=0, ErrExt2=0, ErrExt3=0;
if (gGPSAppDataBackupSem != NULL)
{
//has been initialized
//do nothing, return error directly
return;
}
//create semaphore
gGPSAppDataBackupSem = kal_create_sem("Backup SEM", 1);
ASSERT((gGPSAppDataBackupSem!=NULL));
//initialize global data
gGPSAppDataBackupFolderName[0] = 0x00;
gGPSAppDataBackupAttrFileName[0] = 0x0000;
memset(&gGPSAppDataBackAttrCache, 0x00, sizeof(gGPSAppDataBackAttrCache));
//construct attr file name
sprintf(tmpBuffer, "%c:\\%s", GPSAPP_DATABACKUP_DRV, GPSAPP_DATABACKUP_ATTRIBUTE_FILE_NAME);
app_ansii_to_unicodestring((kal_int8*)gGPSAppDataBackupAttrFileName, (kal_int8*)tmpBuffer);
//check the file exists or not
file_handle = FS_Open(gGPSAppDataBackupAttrFileName, FS_READ_ONLY);
if (file_handle < FS_NO_ERROR)
{
//the attr file doesn't exist, create it.
ErrCode = GPSAppDataBackupWriteAttrFile(KAL_TRUE);
if (ErrCode != GPSAPP_DATABACKUP_ERROR_NONE)
{
ErrExt1 = 1;
ErrExt2 = ErrCode;
goto _INIT_FAIL_;
}
}
else
{
//the attr file exists, read it
result = FS_Read(file_handle, gGPSAppDataBackAttrCache, sizeof(gGPSAppDataBackAttrCache), &Size);
FS_Close(file_handle);
if (result != FS_NO_ERROR || Size != sizeof(gGPSAppDataBackAttrCache))
{
ErrExt1 = 2;
ErrExt2 = result;
ErrExt3 = Size;
goto _INIT_FAIL_;
}
}
//construct folder name
sprintf(gGPSAppDataBackupFolderName, "%c:\\%s", GPSAPP_DATABACKUP_DRV, GPSAPP_DATABACKUP_FOLDER_NAME);
app_ansii_to_unicodestring((kal_int8*)folderName, (kal_int8*)gGPSAppDataBackupFolderName);
//check the folder exists or not
file_handle = FS_Open(folderName, FS_OPEN_DIR | FS_READ_ONLY );
if (file_handle < FS_NO_ERROR)
{
//the folder doesn't exist, create it.
result = FS_CreateDir(folderName);
if (result < FS_NO_ERROR)
{
//fail to create
ErrExt1 = 3;
ErrExt2 = result;
goto _INIT_FAIL_;
}
}
else
{
FS_Close(file_handle);
/*
//sync attr file and backup files
ErrCode = GPSAppDataBackupSyncAttr();
if (ErrCode != GPSAPP_DATABACKUP_ERROR_NONE)
{
ErrExt1 = 4;
ErrExt2 = ErrCode;
goto _INIT_FAIL_;
}
*/
}
return;
_INIT_FAIL_:
EXT_ASSERT(0, ErrExt1, ErrExt2, ErrExt3);
return;
}
/* ------------------------------------------------------------------------------ */
void L1Audio_Task(unsigned argc, void *argv)
{
uint32 retrieved_events;
uint32 I;
uint16 tempID;
l1audio.aud_events = kal_create_event_group("L1Audio");
l1audio.hisr = kal_init_hisr(L1AUDIO_HISR);
GET_SLEEP_HANDLE();
#if ( defined( __CENTRALIZED_SLEEP_MANAGER__ ) && defined(MTK_SLEEP_ENABLE) && !defined(__AUDIO_POWERON_RESET_DSP__) )
l1audio.md2g_pdn_handle = L1D_MD2G_PWD_GetHandle();
l1audio.l1sm_handle = L1SM_IntGetHandle();
#endif
l1audio.runningState = 0;
l1audio.disallowSleepState = 0;
l1audio.dsp_slow_idle_counter = 0;
l1audio.event_flag = 0;
l1audio.id_flag = 0;
l1audio.media_flag = 0;
l1audio.postHisrHandler = (L1Audio_EventHandler)0;
l1audio.sema = kal_create_sem( "Aud_Sema", 1 );
l1audio.hisrMagicFlag = 0;
for( I = 0; I < MAX_HISR_HANDLER; I++ )
l1audio.hisrMagicNo[I] = 0;
tempID = L1Audio_GetAudioID();
L1Audio_SetFlag(tempID);
DSP_DynamicDownload_Init();
#ifndef L1D_TEST
/// Dynamic download for A/V sync
#if defined( DSP_WT_SYN ) && !defined(__AUDIO_COMPONENT_SUPPORT__)
DSP_DynamicDownload( DDID_WAVETABLE );
#endif
#endif
AM_Init();
#if APM_SUPPORT
APM_Init();
#endif
/// AFE_Init will invoke L1Audio_GetAudioID
/// and expect to get the id 0 to make sure
/// it has the highest priority in the event group
AFE_Init();
#if !defined(__SMART_PHONE_MODEM__) && !defined(__L1_STANDALONE__) && !defined( MED_MODEM )
AVsync_Init();
#endif
#if defined(__AUDIO_POWERON_RESET_DSP__)
{
uint32 _savedMask;
_savedMask = SaveAndSetIRQMask();
AFE_Init_status(KAL_TRUE);
AFE_RegisterBackup();
RestoreIRQMask(_savedMask);
}
#endif
L1SP_Init();
ktInit( L1Audio_GetAudioID() );
toneInit( L1Audio_GetAudioID() );
mediaInit( L1Audio_GetAudioID() );
#if defined(VR_CYBERON)
vrsdInit();
#elif defined(VRSI_CYBERON)
vrsiInit();
#endif
toneLoopbackRecInit();
#if ( defined(__BT_A2DP_PROFILE__) || defined(SBC_UNIT_TEST) ) //&& !(APM_SUPPORT)
SBC_Init();
#endif
#if defined(__BES_TS_SUPPORT__)
AudioPP_TS_Init();
#endif
#ifdef __CTM_SUPPORT__
l1ctm_init();
#endif
#ifdef __TWOMICNR_SUPPORT__
Two_Mic_NR_chip_Init();
#endif
#if VMI_SUPPORT || defined(VORTP_UNIT_TEST)
VMI_Init();
#endif
#if VORTP_SUPPORT || defined(VORTP_UNIT_TEST)
VoRTP_Init();
#endif
#if defined(CYBERON_DIC_TTS) || defined(IFLY_TTS) || defined(SINOVOICE_TTS)
ttsInit();
#endif
#if defined( DSP_WT_SYN ) && !defined(__AUDIO_COMPONENT_SUPPORT__)
DSPSYN_HW_Init();
#endif
#if defined( __I2S_INPUT_MODE_SUPPORT__ )
I2S_init();
#endif
#if defined(__VOICE_CHANGER_SUPPORT__)
VCHG_Initialize();
#endif
#if defined(__AUDIO_COMPONENT_SUPPORT__) && !defined(__L1_STANDALONE__) && !defined(MED_MODEM)
// KH : for audio component
ACU_Init();
#endif
#if defined(__CVSD_CODEC_SUPPORT__)
{
extern void BT_SCO_Init(void);
BT_SCO_Init();
}
#endif
memset( &(l1audio.debug_info), 0, sizeof(l1audio.debug_info) );
AFE_TurnOnFIR( L1SP_SPEECH );
AFE_TurnOnFIR( L1SP_VOICE );
L1Audio_ClearFlag(tempID);
L1Audio_FreeAudioID(tempID);
l1audio.isInitiated = KAL_TRUE;
while( 1 ) {
#if VERIFY_DATA_TO_DSP
VERIFY_DATA_TO_DSP_SAVE_DATA();
#endif
kal_retrieve_eg_events(l1audio.aud_events,0xFFFF,KAL_OR_CONSUME,&retrieved_events,KAL_SUSPEND);
l1audio.retrieved_events = retrieved_events;
l1audio.events_l1FN = L1I_GetTimeStamp();
for( I = 0; I < MAX_AUDIO_FUNCTIONS; I++ ) {
if ( l1audio.retrieved_events & (1<<I) ) {
l1audio.evHandler[I]( l1audio.evData[I] );
}
}
//if( (l1audio.runningState & l1audio.disallowSleepState) == 0 )
if( l1audio.runningState == 0 )
SLEEP_UNLOCK();
}
}
