static DALResult
STMTrace_DeviceDeInit(DalDeviceHandle *h)
{
STMTraceClientCtxt *pClientCtxt = ((DalSTMTraceHandle *)h)->pClientCtxt;
STMTraceDevCtxt *pDevCtxt = pClientCtxt->pSTMTraceDevCtxt;
/* also delete the list of ports here */
if(pDevCtxt->hSync)
{
DALSYS_DestroyObject(pDevCtxt->hSync);
}
if(pDevCtxt->portRangeDMA.pBitMask)
{
DALSYS_Free(pDevCtxt->portRangeDMA.pBitMask);
}
if(pDevCtxt->portRange.pBitMask)
{
DALSYS_Free(pDevCtxt->portRange.pBitMask);
}
return DAL_SUCCESS;
}
/*==================================================================================================
@brief FTM driver Detach
This API can be used to Detach FTM driver, it will release all resournces
@param DriverHdl: Input - handle created in Audio_FTM_Attach
@return return code, AUDIO_FTM_SUCCESS on successful completion, error code otherwise
==================================================================================================*/
AUDIO_FTM_STS_T
audio_ftm_toneplay_detach
(
AUDIO_FTM_DRIVER_HANDLE_T pDriverContext
)
{
Aud_FTM_DevCtxt_T* pDevContext;
Aud_FTM_DrvCtxt_T* pDrvContext;
pDrvContext = (Aud_FTM_DrvCtxt_T *)pDriverContext;
if(pDrvContext == NULL)
{
return AUDIO_FTM_ERROR;
}
pDevContext= pDrvContext->pDevCtxt;
if(pDevContext == NULL)
{
return AUDIO_FTM_ERROR;
}
pDrvContext->bStart=FALSE;
aud_ftm_hw_deinit(pDevContext);
DALSYS_DestroySyncObject(pDrvContext->hClientSync);
DALSYS_DestroyEventObject(pDrvContext->hReq_Data_Event);
DALSYS_Free(pDevContext); pDevContext=NULL;
DALSYS_Free(pDrvContext); pDrvContext=NULL;
g_bDriverInitialized=FALSE;
return AUDIO_FTM_SUCCESS;
}
/*==================================================================================================
@brief FTM driver Close
This API can be used to Close the FTM driver.
@param OpenHdl: Input - handle created in Audio_FTM_Open
@return return code, AUDIO_FTM_SUCCESS on successful completion, error code otherwise
==================================================================================================*/
AUDIO_FTM_STS_T
audio_ftm_toneplay_close
(
AUDIO_FTM_CLIENT_HANDLE_T pOpenContext /* Input: client handle */
)
{
Aud_FTM_ClientCtxt_T *pExplicitOpenContext;
Aud_FTM_DrvCtxt_T *pDrvCtx;
uint32 nClient_id;
uint32 i;
AUDIO_FTM_STS_T res;
if (pOpenContext == NULL)
{
return AUDIO_FTM_ERR_INVALID_PARAM;
}
pExplicitOpenContext = (Aud_FTM_ClientCtxt_T *)pOpenContext;
pDrvCtx = pExplicitOpenContext->pDrvCtxt;
res=audio_ftm_hw_close(pDrvCtx->pDevCtxt);
if(res != AUDIO_FTM_SUCCESS) return AUDIO_FTM_ERROR;
nClient_id=pExplicitOpenContext->dwClientID;
DALSYS_Free(pExplicitOpenContext); pExplicitOpenContext=NULL;
DALSYS_SyncEnter(pDrvCtx->hClientSync);
aud_ftm_cbuf_clear(&(pDrvCtx->fifo_data_buf));
for(i=nClient_id; i< DALSYS_atomic_read(&pDrvCtx->dwOpenCount)-1; i++)
{
pDrvCtx->apClientCtxt[i]=pDrvCtx->apClientCtxt[i+1];
pDrvCtx->apClientCtxt[i]->dwClientID--;
}
pDrvCtx->apClientCtxt[i]=NULL;
// Decrease opened device counter
Release(&pDrvCtx->dwOpenCount);
if(DALSYS_atomic_read(&pDrvCtx->dwOpenCount) == 0)
{
pDrvCtx->bOpened=FALSE;
aud_ftm_cbuf_deinit(&(pDrvCtx->fifo_data_buf));
DALSYS_Free(pTmpBuf); pTmpBuf=NULL;
DALSYS_Free(pAud_ftm_rx_buf); pAud_ftm_rx_buf=NULL;
}
DALSYS_SyncLeave(pDrvCtx->hClientSync);
return AUDIO_FTM_SUCCESS;
}
DALResult
DALSYS_DestroyWorkLoopObject(DALSYSWorkLoopHandle hWorkLoop)
{
_DALSYSWorkLoopObj *pWorkLoopObj = (_DALSYSWorkLoopObj *) hWorkLoop;
if(DALSYSCMN_WORKLOOP_OBJECT_ID ==
DALSYSCMN_GET_OBJECT_ID(pWorkLoopObj->dwObjInfo))
{
// send signal to kill the workloop
qurt_anysignal_set(&pWorkLoopObj->signal, SIGNAL_EXIT);
DALSYS_WorkLoopThreadJoin(pWorkLoopObj);
// delete all events on this workloop
// users are still responsible for calling DALSYS_DeleteEventFromWorkLoop and
// DALSYS_DestroyObject on the events
while (pWorkLoopObj->hWorkLoopEventHead)
{
_DALSYSWorkLoopEvent *pRemovedWLEvent = pWorkLoopObj->hWorkLoopEventHead;
pWorkLoopObj->hWorkLoopEventHead = pRemovedWLEvent->nextEvent;
pRemovedWLEvent->dwState = WL_EVENT_DEQUEUED;
pRemovedWLEvent->nextEvent = NULL;
}
pWorkLoopObj->hWorkLoopEventTail = NULL;
qurt_anysignal_destroy(&pWorkLoopObj->signal);
if(pWorkLoopObj->hSync)
DALSYS_DestroyObject(pWorkLoopObj->hSync);
if (pWorkLoopObj->pStackBuffer)
DALSYS_Free(pWorkLoopObj->pStackBuffer);
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));
return DAL_SUCCESS;
}
// ensure workloop object size is valid
DALSYSCMN_COMPILER_ASSERT((sizeof(_DALSYSWorkLoopObj) >
DALSYS_WORKLOOP_OBJ_SIZE_BYTES));
DALSYS_LOG_ERROR_EVENT("not a workloop object- pWorkLoopObj:0x%x",
pWorkLoopObj);
return DAL_ERROR;
}
/**
Frees the memory allocated by bam_osal_malloc.
Frees the memory (virtual) using OS Free API.
@param[in,out] mem Pointer to the memory to be freed
@return
None.
@sa
bam_osal_malloc.
*/
void bam_osal_free(void *pmem)
{
#if defined(BAM_MBA)
qurt_free(pmem);
#elif defined(BAM_TZOS)
tzbsp_free(pmem);
#else
DALSYS_Free(pmem);
#endif
}
/*==================================================================================================
FUNCTION: tal_clock_close
DESCRIPTION:
Close the clock handle, freeing any resources that were allocated when opening the clock handle.
==================================================================================================*/
void tal_clock_close(TAL_CLOCK_HANDLE handle)
{
// No close needed for clock
if(handle->npa_pnoc_client)
{
icbarb_complete_request(handle->npa_pnoc_client);
icbarb_destroy_client(handle->npa_pnoc_client);
}
DAL_DeviceDetach(handle->daldev_clock);
DALSYS_Free(handle);
}
void DALSYS_DestroyEventTimerObject(DALSYSEventHandle hEvent)
{
_DALSYSEventObj * pEventObj = (_DALSYSEventObj *)hEvent;
if(pEventObj && pEventObj->pTimerObj)
{
timer_clr_64( pEventObj->pTimerObj, T_USEC );
timer_undef( pEventObj->pTimerObj );
DALSYS_Free( pEventObj->pTimerObj );
pEventObj->pTimerObj = NULL;
}
}
/** @brief Detaches from the device.
@param[in] h Pointer to dal device handle.
@return DAL_SUCCESS if successful, error otherwise.
*/
static uint32
I2C_DalI2C_Detach
(
DalDeviceHandle* h
)
{
uint32 dwref = DALFW_Release((DALClientCtxt *)(h->pClientCtxt));
if( 0 == dwref ) {
/* Release the client ctxt*/
DALSYS_Free(h->pClientCtxt);
}
return dwref;
}
static DALResult
HWEvent_DeviceDeInit(DalDeviceHandle *h)
{
DALResult ret=DAL_ERROR;
DALClientCtxt * pClientCtxt = (DALClientCtxt *)(h->pClientCtxt);
HWEventDevCtxt *pDevCtxt;
uint32 i;
pDevCtxt=(HWEventDevCtxt *)pClientCtxt->pDALDevCtxt;
if(pDevCtxt->pMemMapTable!=NULL)
{
for(i=0;i<pDevCtxt->uTableSize;i++)
{
if(pDevCtxt->pMemMapTable[i].hMem!=NULL)
{
DALSYS_DestroyObject(pDevCtxt->pMemMapTable[i].hMem);/*destroy mem object*/
}
}
DALSYS_Free(pDevCtxt->pMemMapTable);
ret=DAL_SUCCESS;
}
return ret;
}
/*------------------------------------------------------------------------------
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;
}
DALResult DALSYS_TimerStart(DALSYSEventHandle hEvent, uint32 time)
{
_DALSYSEventObj * pEventObj = (_DALSYSEventObj *)hEvent;
timer_error_type timerRet;
DALResult dalRet;
if (!hEvent) return DAL_ERROR_INVALID_HANDLE;
// allocate and initialize timer object
if ( !pEventObj->pTimerObj )
{
int hEventValue = (int)hEvent; // used to avoid compiler warnings
dalRet = DALSYS_Malloc(sizeof(timer_type),
(void**)&pEventObj->pTimerObj);
if (DAL_ERROR_RETURNED(dalRet)) return dalRet;
if(DALSYSCMN_IS_EVENT_NON_DEFERRED(pEventObj->dwObjInfo))
{
timerRet = timer_def_osal( pEventObj->pTimerObj,
&timer_non_defer_group,
TIMER_FUNC1_CB_TYPE,
(timer_t1_cb_type)timeoutCB,
(timer_cb_data_type)hEventValue);
}
else
{
timerRet = timer_def_osal( pEventObj->pTimerObj,
NULL,
TIMER_FUNC1_CB_TYPE,
(timer_t1_cb_type)timeoutCB,
(timer_cb_data_type)hEventValue);
}
if (TE_SUCCESS != timerRet)
{
DALSYS_Free( pEventObj->pTimerObj );
pEventObj->pTimerObj = NULL;
return DAL_ERROR_INTERNAL;
}
}
if (time)
{
if(DALSYSCMN_IS_EVENT_A_TIMER(pEventObj->dwObjInfo))
{
// periodic
timerRet = timer_set_64(pEventObj->pTimerObj, time, time, T_USEC);
}
else
{
// one-shot
timerRet = timer_set_64(pEventObj->pTimerObj, time, 0, T_USEC);
}
if (TE_SUCCESS != timerRet) return DAL_ERROR_INTERNAL;
}
else
{
timer_clr_64( pEventObj->pTimerObj, T_USEC );
}
return DAL_SUCCESS;
}
/*==================================================================================================
FUNCTION: tal_clock_open
DESCRIPTION:
Open a clock handle for the specified UART device. If successful, this function will return a
clock handle, and may acquire other resources, which must be released by calling
tal_clock_close().
==================================================================================================*/
TAL_RESULT tal_clock_open(TAL_CLOCK_HANDLE *phandle, uint32 client_id)
{
DALSYS_PROPERTY_HANDLE_DECLARE(property_handle);
TAL_CLOCK_HANDLE handle = NULL;
DalDeviceHandle *clock_dal = NULL;
char *clock_name = NULL;
ICBArb_MasterSlaveType uart_arb_master_slave;
ICBArb_RequestType pnoc_request;
ICBArb_ErrorType arb_error;
DALResult result;
if (DALSYS_Malloc(sizeof(TAL_CLOCK_CONTEXT), (void **)&handle) != DAL_SUCCESS) { goto error; }
if (DAL_DeviceAttach(DALDEVICEID_CLOCK, &clock_dal) != DAL_SUCCESS) { goto error; }
handle->daldev_clock = clock_dal;
// No open needed for clock
handle->dal_id = client_id;
handle->manage_pclk = FALSE;
// Read this clock's Clock Regime-specific parameters from the UART configuration:
//
// UartClockName: This is the name of the core clock. It must be present.
//
// ManagePCLK: In recent chips there are two clock inputs to the UART HW block: the
// core clock and the peripheral bus clock. The peripheral bus clock
// operates the bus interface (it must be enabled when reading/writing
// registers). On some builds CLKREGIM manages the peripheral bus clock
// for us and turns it on/off along with the core clock. On other builds
// we must manage the peripheral bus clock ourselves. This property is
// used to specify whether we must manage it ourselves.
//
// PClockName: This is the name of the peripheral clock (if present)
//
// ResetClock: Flag indicating whether the clock block must be reset before
// it can be used.
//
// ClockFundFreq: The fundamental frequency of the bit clock, to which an
// integer divider can be applied. If unspecified, the clock
// has an M/N:D divider and the clock frequency can be
// specified directly.
result = DALSYS_GetDALPropertyHandle(handle->dal_id, property_handle);
if (result != DAL_SUCCESS) { goto error; }
// Read the name of the UART clock
result = get_property_string(handle->dal_id, property_handle, "UartClockName", &clock_name, NULL);
if (result != DAL_SUCCESS || clock_name == 0) { goto error; }
// Look up the clock ID for the core clock
result = DalClock_GetClockId(handle->daldev_clock, clock_name, &handle->core_clk_id);
if (result != DAL_SUCCESS)
{
DALSYS_LogEvent(handle->dal_id, DALSYS_LOGEVENT_ERROR, "Core GetClockId( %s ) = %d", clock_name, result);
goto error;
}
handle->periph_clk_id = 0;
get_property_dword(handle->dal_id,property_handle,"ManagePCLK", &handle->manage_pclk,FALSE);
if (handle->manage_pclk)
{
// Read the name of the peripheral clock
result = get_property_string(handle->dal_id, property_handle, "PClockName", &clock_name, NULL);
// Look up the clock ID for the peripheral clock
if (result == DAL_SUCCESS && clock_name)
{
result = DalClock_GetClockId(handle->daldev_clock, clock_name, &handle->periph_clk_id);
if (result != DAL_SUCCESS)
{
DALSYS_LogEvent(handle->dal_id, DALSYS_LOGEVENT_ERROR, "Periph GetClockId(%s) = %d", clock_name, result);
goto error;
}
}
}
get_property_dword(handle->dal_id,property_handle,"ResetClock", &handle->reset_clock,0);
get_property_dword(handle->dal_id,property_handle,"ClockFundFreq", &handle->fundamental_frequency,0);
get_property_dword(handle->dal_id,property_handle,"PnocVoteEnable", &handle->pnoc_enable, 0);
if(handle->pnoc_enable)
{
get_property_dword(handle->dal_id,property_handle,"PnocArbMaster", &handle->pnoc_master,0);
get_property_dword(handle->dal_id,property_handle,"PnocArbSlave", &handle->pnoc_slave, 0);
if(!(handle->pnoc_master)){ goto error;}
get_property_dword(handle->dal_id,property_handle,"PnocIBval", &handle->pnoc_ib_val,0);
get_property_dword(handle->dal_id,property_handle,"PnocABval", &handle->pnoc_ab_val,0);
if(!(handle->pnoc_ib_val && handle->pnoc_ab_val)){ goto error;}
DALSYS_LogEvent(handle->dal_id, DALSYS_LOGEVENT_INFO, "Pnoc vote is enabled:Master %d & SLAVE %d",
handle->pnoc_master,handle->pnoc_slave);
uart_arb_master_slave.eMaster = handle->pnoc_master;
uart_arb_master_slave.eSlave = handle->pnoc_slave;
/* Create a NPA client for the "/node/core/bus/uart/pnocclk" client to make PNOC voting request*/
handle->npa_pnoc_client = icbarb_create_suppressible_client_ex
("/node/core/bus/uart/pnocclk",
&uart_arb_master_slave,
UART_ICB_CLIENT_CNT, NULL);
if (NULL == handle->npa_pnoc_client)
{
DALSYS_LogEvent(handle->dal_id, DALSYS_LOGEVENT_ERROR, "tal_clock_open: "
"Unable to create a pnoc npa client");
goto error;
}
pnoc_request.arbType = ICBARB_REQUEST_TYPE_3; /* Ib/Ab pair */
/* Bandwidth in Bytes/second */
pnoc_request.arbData.type3.uIb = (uint64) handle->pnoc_ib_val;
pnoc_request.arbData.type3.uAb = (uint64) handle->pnoc_ab_val;
arb_error = icbarb_issue_request(handle->npa_pnoc_client, &pnoc_request,
UART_PNOC_MSTRSLV_PAIRS_NUM);
if(arb_error != ICBARB_ERROR_SUCCESS)
{
DALSYS_LogEvent(handle->dal_id, DALSYS_LOGEVENT_ERROR, "tal_clock_enable: "
"pnoc request is failed witht the error: %d",arb_error);
goto error;
}
}
else
{
handle->pnoc_master = 0;
handle->pnoc_slave = 0;
handle->pnoc_ib_val = 0;
handle->pnoc_ab_val = 0;
handle->npa_pnoc_client = NULL;
DALSYS_LogEvent(handle->dal_id, DALSYS_LOGEVENT_INFO, "Pnoc vote is not enabled");
}
*phandle = handle;
return TAL_SUCCESS;
error:
if (clock_dal) { DAL_DeviceDetach(clock_dal); }
if (handle) { DALSYS_Free(handle); }
return TAL_ERROR;
}
static void
STMTrace_FreePort( DalDeviceHandle * h, uint32 uPort)
{
STMTraceClientCtxt *pClientCtxt = ((DalSTMTraceHandle *)h)->pClientCtxt;
STMTraceDevCtxt *pDevCtxt = pClientCtxt->pSTMTraceDevCtxt;
STMPortRangeItem * currRange = NULL;
STMPortRangeItem * prevRange = NULL;
uint32 uBitPos = 0;
DALSYS_SyncEnter(pDevCtxt->hSync);
currRange = pDevCtxt->listHead;
while(NULL != currRange)
{
// does the uPort fall in the current range ?
if(currRange->uBaseAddr <= uPort &&
uPort < currRange->uBaseAddr + STM_PORT_SIZE*currRange->portRange.uNumPorts)
{
goto free_port;
}
prevRange = currRange;
currRange = currRange->next;
}
DALSYS_SyncLeave(pDevCtxt->hSync);
return;
free_port:
uBitPos = (uPort-currRange->uBaseAddr)/STM_PORT_SIZE;
if(DAL_SUCCESS != _FreeBit(currRange->portRange.pBitMask, MAX_STM_PORTS_PER_PAGE, uBitPos))
{
DALSYS_SyncLeave(pDevCtxt->hSync);
return;
}
currRange->uNumFreePorts++;
if(currRange->uNumFreePorts == currRange->portRange.uNumPorts)
{
// all ports in this range have been freed so free the bit from
// main mask
if(DAL_SUCCESS != _FreeBit(currRange->mainPortRange->pBitMask,
currRange->mainPortRange->uNumPorts/MAX_STM_PORTS_PER_PAGE,
currRange->portRange.uBasePort/MAX_STM_PORTS_PER_PAGE))
{
DALSYS_SyncLeave(pDevCtxt->hSync);
return;
}
if(NULL != currRange->hMem)
{
DALSYS_DestroyObject(currRange->hMem);
}
if(NULL != prevRange)
{
prevRange->next = currRange->next;
}
else
{
pDevCtxt->listHead = pDevCtxt->listHead->next;
}
DALSYS_Free(currRange->portRange.pBitMask);
DALSYS_Free(currRange);
}
DALSYS_SyncLeave(pDevCtxt->hSync);
return;
}
static DALResult
STMTrace_NewPort( DalDeviceHandle * h, uint32 * uPort, uint32 * uPortDMA)
{
STMTraceClientCtxt *pClientCtxt = ((DalSTMTraceHandle *)h)->pClientCtxt;
STMTraceDevCtxt *pDevCtxt = pClientCtxt->pSTMTraceDevCtxt;
STMPortRange *pMainPortRange;
STMPortRangeItem * currRange = NULL;
STMPortRangeItem * prevRange = NULL;
uint32 uBitPos;
DALSYSMemInfo memInfo;
if(NULL != uPortDMA) // DMA'able port requested ?
{
pMainPortRange = &pDevCtxt->portRangeDMA;
if(!pMainPortRange->uNumPorts)
{
return DAL_ERROR;
}
}
else
{
pMainPortRange = &pDevCtxt->portRange;
}
DALSYS_SyncEnter(pDevCtxt->hSync);
currRange = pDevCtxt->listHead;
while(NULL != currRange)
{
// previously allocated range has a free port?
if(0 != currRange->uNumFreePorts)
goto alloc_port;
prevRange = currRange;
currRange = currRange->next;
}
// carve out a new range from the master range now
if(DAL_SUCCESS != DALSYS_Malloc(sizeof(STMPortRangeItem),(void **)&currRange))
{
DALSYS_SyncLeave(pDevCtxt->hSync);
return DAL_ERROR;
}
memset(currRange, 0, sizeof(STMPortRangeItem));
if(DAL_SUCCESS != _AllocBit(pMainPortRange->pBitMask,
pMainPortRange->uNumPorts/MAX_STM_PORTS_PER_PAGE,
&uBitPos))
{
DALSYS_Free(currRange);
DALSYS_SyncLeave(pDevCtxt->hSync);
return DAL_ERROR;
}
currRange->portRange.uBasePort = pMainPortRange->uBasePort + (uBitPos * MAX_STM_PORTS_PER_PAGE);
currRange->portRange.uNumPorts = MAX_STM_PORTS_PER_PAGE;
currRange->uNumFreePorts = MAX_STM_PORTS_PER_PAGE;
currRange->mainPortRange = pMainPortRange;
if(DAL_SUCCESS != _AllocateMemForBitMasks(&currRange->portRange.pBitMask, MAX_STM_PORTS_PER_PAGE))
{
_FreeBit(pMainPortRange->pBitMask, pMainPortRange->uNumPorts/MAX_STM_PORTS_PER_PAGE, uBitPos);
DALSYS_Free(currRange);
DALSYS_SyncLeave(pDevCtxt->hSync);
return DAL_ERROR;
}
if(DAL_SUCCESS != DALSYS_MemRegionAlloc(DALSYS_MEM_PROPS_HWIO, DALSYS_MEM_ADDR_NOT_SPECIFIED,
pDevCtxt->uSTMSPBaseAddr +
(currRange->portRange.uBasePort * STM_PORT_SIZE),
4096, &currRange->hMem, NULL))
{
_FreeBit(pMainPortRange->pBitMask, pMainPortRange->uNumPorts/MAX_STM_PORTS_PER_PAGE, uBitPos);
DALSYS_Free(currRange->portRange.pBitMask);
DALSYS_Free(currRange);
DALSYS_SyncLeave(pDevCtxt->hSync);
return DAL_ERROR;
}
DALSYS_MemInfo(currRange->hMem, &memInfo);
currRange->uBaseAddr = memInfo.VirtualAddr;
if(NULL != prevRange)
{
prevRange->next = currRange;
}
else
{
pDevCtxt->listHead = currRange;
}
alloc_port:
if(DAL_SUCCESS != _AllocBit(currRange->portRange.pBitMask, MAX_STM_PORTS_PER_PAGE, &uBitPos))
{
DALSYS_SyncLeave(pDevCtxt->hSync);
return DAL_ERROR;
}
*uPort = currRange->uBaseAddr + (STM_PORT_SIZE * uBitPos);
if(NULL != uPortDMA)
{
/* prepare a 32 bit int with 7 bits starting at 17th bit */
uint32 uPortOffset = ((currRange->portRange.uBasePort+uBitPos)&0x7F)<<17;
/* first get the physical address of the allocated port */
*uPortDMA = pDevCtxt->uSTMSPBaseAddr +
((currRange->portRange.uBasePort + uBitPos) * STM_PORT_SIZE);
/* then set the 7 bits starting at 17th bit pos to 0's */
*uPortDMA = *uPortDMA &(~(0x7F<<17));
/* finally set the lower 7 bits of the stimulus port number at the 17th bit pos */
*uPortDMA |= uPortOffset;
}
currRange->uNumFreePorts--;
DALSYS_SyncLeave(pDevCtxt->hSync);
return DAL_SUCCESS;
}
