static DALResult
STMTrace_DeviceInit(DalDeviceHandle *h)
{
STMTraceClientCtxt *pClientCtxt = ((DalSTMTraceHandle *)h)->pClientCtxt;
STMTraceDevCtxt *pDevCtxt = pClientCtxt->pSTMTraceDevCtxt;
if(DAL_SUCCESS != _CollectProperties(pDevCtxt))
return DAL_ERROR;
if(DAL_SUCCESS != _AllocateMemForBitMasks(&pDevCtxt->portRange.pBitMask,
pDevCtxt->portRange.uNumPorts))
{
return DAL_ERROR;
}
if(DAL_SUCCESS != _AllocateMemForBitMasks(&pDevCtxt->portRangeDMA.pBitMask,
pDevCtxt->portRangeDMA.uNumPorts))
{
return DAL_ERROR;
}
if(DAL_SUCCESS != DALSYS_SyncCreate(DALSYS_SYNC_ATTR_RESOURCE,
&pDevCtxt->hSync, NULL))
{
return DAL_ERROR;
}
return DAL_SUCCESS;
}
/**
Initializes a sync object.
Initializes a sync object.
@param[in,out] sync Pointer to the object to be used for sync
@return
Success of the operation.
*/
bam_status_type bam_osal_syncinit(bam_osal_sync_type *sync)
{
#ifndef BAM_MBA
if (DAL_SUCCESS != DALSYS_SyncCreate(DALSYS_SYNC_ATTR_RESOURCE_INTERRUPT,
(DALSYSSyncHandle*)sync,
NULL) )
{
*(DALSYSSyncHandle*)sync = NULL;
return BAM_FAILED;
}
#endif // #ifndef BAM_MBA
return BAM_SUCCESS;
}
void DALSYSWorkLoopInit(void)
{
static DALSYSSyncObj workLoopListSyncObj;
DALResult result;
result = DALSYS_SyncCreate( DALSYS_SYNC_ATTR_RESOURCE, &workLoopListSyncHdl,
&workLoopListSyncObj );
if (DAL_SUCCESS != result)
{
DALSYS_LOG_ERROR_EVENT("Unable to create sync object for workloop list");
}
if (DALSYS_WL_TRACK_CNT != PD_VAR(DALSYSWorkLoopCnt))
{
// the useless comparisions and assignments
// ensure above variables would not be stripped by linker so
// they are accessible by the DAL log CMM script
PD_VAR(DALSYSWorkLoopCnt) = DALSYS_WL_TRACK_CNT;
}
}
Adsppm_Status MEMPWR_Init(void)
{
Adsppm_Status result = Adsppm_Status_Success;
uint32 j;
ADSPPM_LOG_FUNC_ENTER;
gMemPwrMgrCtx.activeStateIndex = 0;
if(DAL_SUCCESS != DALSYS_SyncCreate(DALSYS_SYNC_ATTR_RESOURCE, &gMemPwrMgrCtx.lock, NULL))
{
result = Adsppm_Status_Failed;
ADSPPM_LOG_PRINTF_0(ADSPPM_LOG_LEVEL_ERROR, "Failed to create mutex");
}
for(j = 0; j < (Adsppm_Mem_Max - Adsppm_Mem_Lpass_LPM); j++)
{
gMemPwrMgrCtx.memPwrState[j][gMemPwrMgrCtx.activeStateIndex] = Adsppm_Mem_Power_Off;
gMemPwrMgrCtx.memPwrState[j][gMemPwrMgrCtx.activeStateIndex^1] = Adsppm_Mem_Power_Off;
}
ADSPPM_LOG_FUNC_EXIT(result);
return result;
}
/**
@copydoc AxiCfgOs_Init
*/
bool AxiCfgOs_Init( void )
{
if( !bInitialized )
{
Info.DevStr = "/core/buses/icb/arb";
/* Get default configuration handle from config data */
if (DAL_SUCCESS != DALSYS_GetDALPropertyHandleStr( "/core/buses/icb/arb",
Info.hProp ))
{
return bInitialized;
}
/*create sync object*/
if( DAL_SUCCESS != DALSYS_SyncCreate( DALSYS_SYNC_ATTR_RESOURCE,
&Info.hMutex,
&Info.mutexSyncObj) )
{
return bInitialized;
}
/*attach hwio driver*/
if( DAL_SUCCESS != DAL_DeviceAttach(DALDEVICEID_HWIO, &Info.hHWIO) )
{
return bInitialized;
}
/*attach clock driver*/
if( DAL_SUCCESS != DAL_DeviceAttach(DALDEVICEID_CLOCK, &Info.hClock) )
{
return bInitialized;
}
bInitialized = true;
}
return bInitialized;
}
/*------------------------------------------------------------------------------
User API to Register Work Loop
-------------------------------------------------------------------------------*/
static DALResult
registerWorkLoop( char *pszname,
uint32 dwStackSize,
uint32 dwPriority,
void * ownerRetAddr,
DALSYSWorkLoopHandle *phWorkLoop,
DALSYSWorkLoopObj *pObj)
{
_DALSYSWorkLoopObj *pWorkLoopObj = (_DALSYSWorkLoopObj *)pObj;
if (!phWorkLoop)
{
DALSYS_LOG_ERROR_EVENT("phWorkLoop is NULL- workloop:%s",
pszname);
return DAL_ERROR;
}
*phWorkLoop = NULL;
if(NULL == pWorkLoopObj)
{
/*----------------------------------------------------------------------
User has not passed in WorkLoop object, we need to allocate memory.
Always get the size form the DALSYS Macros. This is done to support
static allocation and maintain consistency between sizes of statically
and dynamically alloced structures.
----------------------------------------------------------------------*/
if(DAL_SUCCESS != DALSYS_Malloc(sizeof(_DALSYSWorkLoopObj), (void**)&pWorkLoopObj))
return DAL_ERROR;
memset(pWorkLoopObj,0,sizeof(_DALSYSWorkLoopObj));
DALSYSCMN_SET_DYNAMIC_ALLOC_BIT(pWorkLoopObj->dwObjInfo);
}
else
{
/*----------------------------------------------------------------------
User has allocated memory allocate memory, we dont allocate memory
----------------------------------------------------------------------*/
memset(pWorkLoopObj,0,sizeof(_DALSYSWorkLoopObj));
}
/*--------------------------------------------------------------------------
Initialize the remaining data structure
--------------------------------------------------------------------------*/
if(DAL_SUCCESS != DALSYS_SyncCreate(DALSYS_SYNC_ATTR_NO_PREEMPTION,
&pWorkLoopObj->hSync, NULL))
{
goto wl_reg_error_1;
}
// allocate memory for thread stack.
if (DAL_SUCCESS != DALSYS_Malloc(dwStackSize,
(void**)&pWorkLoopObj->pStackBuffer ))
{
goto wl_reg_error_2;
}
DALSYSCMN_SET_OBJECT_ID(pWorkLoopObj->dwObjInfo,DALSYSCMN_WORKLOOP_OBJECT_ID);
qurt_anysignal_init(&pWorkLoopObj->signal);
if (!dwPriority || dwPriority > 255)
{
dwPriority = DALSYS_WL_DEFAULT_PRIO;
}
DALSYSCMN_SET_ATTRIB(pWorkLoopObj->dwObjInfo,(dwPriority<<4));
// setting debug information
pWorkLoopObj->ownerThreadId = qurt_thread_get_id();
pWorkLoopObj->ownerRetAddr = ownerRetAddr;
pWorkLoopObj->thisVirtualAddr = (DALSYSMemAddr)pWorkLoopObj;
if (DAL_SUCCESS == DALSYS_WorkLoopThreadCreate( pWorkLoopObj, pszname, dwStackSize, dwPriority ) )
{
*phWorkLoop = pWorkLoopObj;
return DAL_SUCCESS;
}
// workloop creation failed - need to cleanup
qurt_anysignal_destroy(&pWorkLoopObj->signal);
DALSYS_Free(pWorkLoopObj->pStackBuffer);
wl_reg_error_2:
DALSYS_DestroyObject( pWorkLoopObj->hSync );
wl_reg_error_1:
if(DALSYSCMN_IS_OBJ_DYNAMICALLY_ALLOCED(pWorkLoopObj->dwObjInfo))
DALSYS_Free(pWorkLoopObj); /* If dynamically alloced free memory */
else /*Statically alloced object, reset all fields to ZERO*/
memset(pWorkLoopObj,0,sizeof(_DALSYSWorkLoopObj));
DALSYS_LOG_ERROR_EVENT("failed- pszname:%s", pszname);
return DAL_ERROR;
}
AUDIO_FTM_STS_T
audio_ftm_toneplay_attach
(
void *pParam, /* Input: parameters */
AUDIO_FTM_DRIVER_HANDLE_T *pDriverHdl /* Output: driver handle */
)
{
/************* Context creation ***********/
Aud_FTM_DevCtxt_T *pDeviceCtxt;
Aud_FTM_DrvCtxt_T *pDriverCtxt;
Aud_FTM_HW_INIT_PARAM_T hw_param;
int16 freq1,freq2, sampling_freq;
AUDIO_FTM_STS_T sts;
if (g_bDriverInitialized)
{
DALSYS_Log_Err("%s: error: already initialized\n", __func__);
return AUDIO_FTM_ERROR; // already inited,
}
DALSYS_Log_Info("Attach TonePlay Driver\n");
/****************** create context object ******************/
if((DAL_SUCCESS != DALSYS_Malloc(sizeof(Aud_FTM_DevCtxt_T), (void **)&pDeviceCtxt)) ||
(pDeviceCtxt == NULL))
{
DALSYS_Log_Err("Memory allocation fail\n");
return AUDIO_FTM_ERR_MEM_ALLOC_FAIL;
}
DALSYS_memset(pDeviceCtxt,0,sizeof(Aud_FTM_DevCtxt_T));
if((DAL_SUCCESS != DALSYS_Malloc(sizeof(Aud_FTM_DrvCtxt_T), (void **)&pDriverCtxt)) ||
(pDriverCtxt == NULL))
{
DALSYS_Log_Err("Memory allocation fail\n");
DALSYS_Free(pDeviceCtxt);
return AUDIO_FTM_ERR_MEM_ALLOC_FAIL;
}
DALSYS_memset(pDriverCtxt,0,sizeof(Aud_FTM_DevCtxt_T));
DALSYS_atomic_init(&pDriverCtxt->dwOpenCount);
pDriverCtxt->pDevCtxt=pDeviceCtxt;
pDeviceCtxt->pDrvCtxt=pDriverCtxt;
/************* Create Critical Section ***********/
if(DAL_SUCCESS != DALSYS_SyncCreate(DALSYS_SYNC_ATTR_RESOURCE,
&(pDriverCtxt->hClientSync),
NULL))
{
DALSYS_Log_Err("hClientSync creation fail\n");
return AUDIO_FTM_ERROR;
}
if(DAL_SUCCESS != DALSYS_EventCreate(DALSYS_EVENT_ATTR_WORKLOOP_EVENT, //Not used for work loops
&(pDriverCtxt->hReq_Data_Event), //Return event handle
NULL))
{
DALSYS_Log_Err("%s: failed to create event\n", __func__);
DALSYS_SyncLeave(pDriverCtxt->hClientSync);
DALSYS_Free(pDriverCtxt->hClientSync);
return AUDIO_FTM_ERROR;
}
/************* hardware initialization ***********/
DALSYS_memcpy((uint8*)&(pDriverCtxt->client_param),
(uint8*)pParam, sizeof(AUD_FTM_TONE_PLAY_PARAM_T));
hw_param.inpath=AUDIO_FTM_IN_INVALID;
hw_param.outpath=pDriverCtxt->client_param.path.outpath;
hw_param.rate=AUDIO_FTM_PCM_RATE_8K;
hw_param.width=AUDIO_FTM_BIT_WIDTH_16;
hw_param.channel=AUDIO_FTM_CHN_1;
hw_param.gain=pDriverCtxt->client_param.gain;
hw_param.bLoopbackCase=FALSE;
sts=aud_ftm_hw_init(pDeviceCtxt, &hw_param);
if(sts != AUDIO_FTM_SUCCESS) {
DALSYS_Log_Err("%s: failed to init hw\n", __func__);
return AUDIO_FTM_ERROR;
}
/* Tone generator init */
freq1=((AUD_FTM_TONE_PLAY_PARAM_T*)pParam)->dtmf_low;
freq2=((AUD_FTM_TONE_PLAY_PARAM_T*)pParam)->dtmf_hi;
sampling_freq=8000;
audio_ftm_dtmf_tone_init(&(pDriverCtxt->dtmfGen),freq1,freq2,sampling_freq);
pDriverCtxt->nDTMF_Gain = vol_map[3];
/***** end of Init *****/
pDriverCtxt->bOpened=FALSE;
g_bDriverInitialized=TRUE;
*pDriverHdl=(AUDIO_FTM_DRIVER_HANDLE_T)pDriverCtxt;
return AUDIO_FTM_SUCCESS;
}
