/** ============================================================================
* @func LDRV_MPCS_create
*
* @desc This function creates and initializes an instance of the MPCS
* object.
* The memory for the object may or may not be provided by the user.
* If provided by the user, the memory for the object must be shared
* across the processors using the MPCS. It must also already be mapped
* into user space for OSes supporting user/kernel separation.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
DSP_STATUS
LDRV_MPCS_create (IN ProcessorId dspId,
IN MPCS_ShObj * mpcsObj)
{
DSP_STATUS status = DSP_SOK ;
TRC_2ENTER ("LDRV_MPCS_create", dspId, mpcsObj) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
DBC_Require (mpcsObj != NULL) ;
mpcsObj->turn = SELF ;
#if defined (DDSP_PROFILE)
mpcsObj->gppMpcsObj.conflicts = 0 ;
mpcsObj->gppMpcsObj.numCalls = 0 ;
mpcsObj->dspMpcsObj.conflicts = 0 ;
mpcsObj->dspMpcsObj.numCalls = 0 ;
#endif
status = LDRV_MPCS_OS_create (dspId, mpcsObj) ;
mpcsObj->dspMpcsObj.localLock = 0 ;
mpcsObj->gppMpcsObj.flag = (Uint16) MPCS_FREE ;
mpcsObj->dspMpcsObj.flag = (Uint16) MPCS_FREE ;
mpcsObj->gppMpcsObj.freeObject = (Uint16) FALSE ;
mpcsObj->dspMpcsObj.freeObject = (Uint16) FALSE ;
mpcsObj->dspMpcsObj.mpcsEntryAddr = 0 ;
mpcsObj->gppMpcsObj.mpcsEntryAddr = 0 ;
TRC_1LEAVE ("LDRV_MPCS_create", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_MPLIST_exit
*
* @desc This function finalizes the LDRV MPLIST module for a particular DSP.
* Finalizing means no further services will be provided by this
* module for this particular DSP.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_MPLIST_exit (IN ProcessorId dspId)
{
DSP_STATUS status = DSP_SOK ;
LDRV_MPLIST_Object * mplistState ;
TRC_1ENTER ("LDRV_MPLIST_exit", dspId) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
if (LDRV_MPLIST_IsInitialized [dspId] == TRUE) {
mplistState = &(LDRV_MPLIST_State [dspId]) ;
/* --------------------------------------------------------------------
* Free shared memory allocated for the MPLIST component.
* --------------------------------------------------------------------
*/
if (mplistState->ctrlPtr != NULL) {
status = LDRV_SMM_free (dspId,
mplistState->memEntry,
mplistState->ctrlSize) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
LDRV_MPLIST_IsInitialized [dspId] = FALSE ;
}
TRC_1LEAVE ("LDRV_MPLIST_exit", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_MPLIST_isEmpty
*
* @desc check for an empty list.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
Bool
LDRV_MPLIST_isEmpty (IN ProcessorId dspId,
IN List * list )
{
Bool retVal = FALSE ;
LDRV_MPLIST_Object * mplistState ;
Uint32 temp ;
TRC_2ENTER ("LDRV_MPLIST_isEmpty", dspId, list) ;
DBC_Require (IS_VALID_PROCID(dspId)) ;
DBC_Require (list != NULL) ;
DBC_Assert (LDRV_MPLIST_IsInitialized [dspId] == TRUE) ;
mplistState = &(LDRV_MPLIST_State [dspId]) ;
temp = SWAP_LONG (DSP_addrConvert (dspId,
(Uint32) &((list)->head),
GppToDsp),
mplistState->wordSwap) ;
if ( ((Uint32) (list)->head.next) == temp) {
retVal = TRUE ;
}
TRC_1LEAVE ("LDRV_MPLIST_isEmpty", retVal) ;
return retVal ;
}
/** ============================================================================
* @func LDRV_MPCS_exit
*
* @desc This function finalizes the LDRV MPCS module for a particular DSP.
* Finalizing means no further services will be provided by this
* module for this particular DSP.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_MPCS_exit (IN ProcessorId dspId)
{
DSP_STATUS status = DSP_SOK ;
DSP_STATUS tmpStatus = DSP_SOK ;
LDRV_MPCS_Object * mpcsState ;
MPCS_Ctrl * mpcsCtrl ;
Uint32 i ;
MPCS_Entry * entry ;
TRC_1ENTER ("LDRV_MPCS_exit", dspId) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
if (LDRV_MPCS_IsInitialized [dspId] == TRUE) {
mpcsState = &(LDRV_MPCS_State [dspId]) ;
mpcsCtrl = mpcsState->ctrlPtr ;
if (mpcsCtrl != NULL) {
/* mpcsCtrl->entry is reset on user-side with user address, so it
* is again set to kernel address.
*/
entry = (MPCS_Entry *) ( (Uint32) (mpcsState->ctrlPtr)
+ sizeof (MPCS_Ctrl)) ;
status = LDRV_MPCS_delete (dspId, &(mpcsCtrl->lockObj)) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
/* Finalize the entries table. */
for (i = 0 ; i < mpcsState->maxEntries ; i++) {
entry [i].physAddress = NULL ;
entry [i].name [0] = '\0' ;
}
/* ----------------------------------------------------------------
* Free shared memory allocated for the MPCS component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_SMM_free (dspId,
mpcsState->memEntry,
mpcsState->ctrlSize) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
mpcsCtrl->isInitialized = FALSE ;
}
LDRV_MPCS_IsInitialized [dspId] = FALSE ;
}
TRC_1LEAVE ("LDRV_MPCS_exit", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_init
*
* @desc Allocates resources and initializes the LDRV component for a DSP.
*
* @modif None
* ============================================================================
*/
EXPORT_API
DSP_STATUS
LDRV_init (IN ProcessorId procId, IN LINKCFG_DspConfig * dspCfg)
{
DSP_STATUS status = DSP_SOK ;
Char8 * dspName = NULL ;
TRC_2ENTER ("LDRV_init", procId, dspCfg) ;
DBC_Require (LDRV_LinkCfgPtr != NULL) ;
DBC_Require (IS_VALID_PROCID (procId)) ;
/* ------------------------------------------------------------------------
* Get the pointer to kernel-side APUDRV configuration structure.
* ------------------------------------------------------------------------
*/
if (dspCfg != NULL) {
if (LDRV_LinkCfgPtr->dspConfigs [procId] != NULL) {
/* First free the previously read config values */
status = LDRV_freeLinkDspCfg (procId, LDRV_LinkCfgPtr) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
if (DSP_SUCCEEDED (status)) {
status = LDRV_getLinkDspCfg (procId, dspCfg, LDRV_LinkCfgPtr) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
LDRV_exit (procId) ;
}
}
}
else {
if (LDRV_LinkCfgPtr->dspConfigs [procId] == NULL) {
PRINT_Printf ("For multi-app support, Please pass valid DSP") ;
PRINT_Printf ("Config values through PROC_attach.\n") ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
}
/* ------------------------------------------------------------------------
* Plug the correct configuration mapping information for APU DRIVER.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
dspName = LDRV_LinkCfgPtr->dspConfigs [procId]->dspObject->name ;
status = CFGMAP_attachObject (procId, dspName) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
LDRV_exit (procId) ;
}
}
TRC_1LEAVE ("LDRV_init", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_MPLIST_removeElement
*
* @desc Removes (unlinks) the given element from the list, if the list is
* not empty. Does not free the list element. This function works on
* the list object and element fields in DSP address space.If the
* element is from pool memory, it does the invalidate and writeback
* operations on the element. If the element is from a non pool shared
* memory, invalidate writeback operations are not performed.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
Void
LDRV_MPLIST_removeElement (IN ProcessorId dspId,
IN List * list,
IN ListElement * element )
{
PoolId poolId = POOL_INVALIDID ;
LDRV_MPLIST_Object * mplistState ;
ListElement * temp ;
TRC_4ENTER ("LDRV_MPLIST_removeElement", dspId, list, element, poolId) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
DBC_Require (list != NULL) ;
DBC_Require (element != NULL) ;
DBC_Assert (LDRV_MPLIST_IsInitialized [dspId] == TRUE) ;
mplistState = &(LDRV_MPLIST_State [dspId]) ;
if (LDRV_MPLIST_isEmpty (dspId, list) == FALSE) {
temp = (ListElement *)
DSP_addrConvert (dspId,
SWAP_LONG ((Uint32) (element->prev),
mplistState->wordSwap),
DspToGpp) ;
LDRV_POOL_getPoolId (dspId,
temp,
AddrType_Knl,
&poolId );
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_invalidate (poolId, temp, sizeof (ListElement)) ;
}
temp->next = element->next ;
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_writeback (poolId, temp, sizeof (ListElement)) ;
}
temp = (ListElement *)
DSP_addrConvert (dspId,
SWAP_LONG ((Uint32) (element->next),
mplistState->wordSwap),
DspToGpp) ;
LDRV_POOL_getPoolId (dspId,
temp,
AddrType_Knl,
&poolId );
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_invalidate (poolId, temp, sizeof (ListElement)) ;
}
temp->prev = element->prev ;
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_writeback (poolId, temp, sizeof (ListElement)) ;
}
}
TRC_0LEAVE ("LDRV_MPLIST_removeElement") ;
}
/** ============================================================================
* @func LDRV_MPCS_delete
*
* @desc This function deletes the instance of the MPCS object.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
DSP_STATUS
LDRV_MPCS_delete (IN ProcessorId dspId,
IN MPCS_ShObj * mpcsObj)
{
DSP_STATUS status = DSP_SOK ;
TRC_2ENTER ("LDRV_MPCS_delete", dspId, mpcsObj) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
DBC_Require (mpcsObj != NULL) ;
DBC_Assert (mpcsObj->dspMpcsObj.flag != MPCS_BUSY) ;
mpcsObj->dspMpcsObj.flag = (Uint16) MPCS_FREE ;
mpcsObj->gppMpcsObj.flag = (Uint16) MPCS_FREE ;
status = LDRV_MPCS_OS_delete (dspId, mpcsObj) ;
TRC_1LEAVE ("LDRV_MPCS_delete", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_MPLIST_getMemInfo
*
* @desc This function returns the memory information for the MPLIST region.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_MPLIST_getMemInfo (IN OUT MPLIST_MemInfo * mplistMemInfo)
{
DSP_STATUS status = DSP_SOK ;
LDRV_MPLIST_Object * mplistState ;
TRC_1ENTER ("LDRV_MPLIST_getMemInfo", mplistMemInfo) ;
DBC_Require (mplistMemInfo != NULL) ;
DBC_Require (IS_VALID_PROCID (mplistMemInfo->procId)) ;
DBC_Assert (LDRV_MPLIST_IsInitialized [mplistMemInfo->procId] == TRUE) ;
mplistState = &(LDRV_MPLIST_State [mplistMemInfo->procId]) ;
mplistMemInfo->kernAddr = (Uint32) mplistState->ctrlPtr ;
mplistMemInfo->physAddr = mplistState->physCtrlAddr ;
mplistMemInfo->size = mplistState->ctrlSize ;
TRC_1LEAVE ("LDRV_MPLIST_getMemInfo", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_RINGIO_getMemInfo
*
* @desc This function returns the memory information for the RINGIO region.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_RINGIO_getMemInfo (IN OUT RingIO_MemInfo * ringIoMemInfo)
{
DSP_STATUS status = DSP_SOK ;
LDRV_RINGIO_Object * ringIoState ;
TRC_1ENTER ("LDRV_RINGIO_getMemInfo", ringIoMemInfo) ;
DBC_Require (ringIoMemInfo != NULL) ;
DBC_Require (IS_VALID_PROCID (ringIoMemInfo->procId)) ;
DBC_Assert (LDRV_RINGIO_IsInitialized [ringIoMemInfo->procId] == TRUE) ;
ringIoState = &(LDRV_RINGIO_State [ringIoMemInfo->procId]) ;
ringIoMemInfo->kernAddr = (Uint32) ringIoState->ctrlPtr ;
ringIoMemInfo->physAddr = ringIoState->physCtrlAddr ;
ringIoMemInfo->size = ringIoState->ctrlSize ;
TRC_1LEAVE ("LDRV_RINGIO_getMemInfo", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_MPLIST_clear
*
* @desc Clears a statically created list and translates its contents to
* work with DSP address space.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
Void
LDRV_MPLIST_clear (IN ProcessorId dspId,
IN List * list )
{
LDRV_MPLIST_Object * mplistState ;
TRC_2ENTER ("LDRV_MPLIST_clear", dspId, list) ;
DBC_Require (IS_VALID_PROCID(dspId)) ;
DBC_Require (list != NULL) ;
DBC_Assert (LDRV_MPLIST_IsInitialized [dspId] == TRUE) ;
mplistState = &(LDRV_MPLIST_State [dspId]) ;
list->head.next = (ListElement *)
SWAP_LONG (DSP_addrConvert (dspId,
(Uint32) &(list->head),
GppToDsp),
mplistState->wordSwap) ;
list->head.prev = list->head.next ;
TRC_0LEAVE ("LDRV_MPLIST_clear") ;
}
/** ============================================================================
* @func LDRV_MPLIST_putTail
*
* @desc Adds the specified element to the tail of the list while working on
* the list object and element fields in DSP address space.If the
* element is from pool memory, it does the invalidate and writeback
* operations on the element. If the element is from a non pool shared
* memory, invalidate writeback operations are not performed.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
Void
LDRV_MPLIST_putTail (IN ProcessorId dspId,
IN List * list,
IN ListElement * element )
{
PoolId poolId = POOL_INVALIDID ;
LDRV_MPLIST_Object * mplistState ;
ListElement * temp ;
Uint32 intermediateState ;
TRC_3ENTER ("LDRV_MPLIST_putTail", dspId, list, element) ;
DBC_Require (IS_VALID_PROCID(dspId)) ;
DBC_Require (list != NULL) ;
DBC_Require (element != NULL) ;
DBC_Assert (LDRV_MPLIST_IsInitialized [dspId] == TRUE) ;
mplistState = &(LDRV_MPLIST_State [dspId]) ;
element->prev = list->head.prev ;
element->next = (ListElement *)
SWAP_LONG (DSP_addrConvert (dspId,
(Uint32) &(list->head),
GppToDsp),
mplistState->wordSwap) ;
/* Get the poolId of the element to do write back */
LDRV_POOL_getPoolId (dspId,
element,
AddrType_Knl,
&poolId );
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_writeback (poolId, element, sizeof (ListElement)) ;
}
intermediateState = DSP_addrConvert (dspId,
(Uint32) element,
GppToDsp) ;
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_writeback (poolId, element, sizeof (ListElement)) ;
}
list->head.prev = (ListElement *) SWAP_LONG ((Uint32)intermediateState,
mplistState->wordSwap) ;
temp = (ListElement *)
DSP_addrConvert (dspId,
SWAP_LONG ((Uint32) (element->prev),
mplistState->wordSwap),
DspToGpp) ;
/* Get the poolId of temp, to be able to invalidate and write back
* properly
*/
LDRV_POOL_getPoolId (dspId,
temp,
AddrType_Knl,
&poolId );
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_invalidate (poolId, temp, sizeof (ListElement)) ;
}
temp->next = list->head.prev ;
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_writeback (poolId, temp, sizeof (ListElement)) ;
}
TRC_0LEAVE ("LDRV_MPLIST_putTail") ;
}
/** ============================================================================
* @func LDRV_MPLIST_getHead
*
* @desc Gets the head pointer from the list while working on the list object
* and element fields in DSP address space.If the head element is from
* pool memory, it does the invalidate and writeback operations on the
* element. If the element is from a non pool shared memory, invalidate
* writeback operations are not performed.
*
* @modif None.
* ============================================================================
*/
EXPORT_API
Void
LDRV_MPLIST_getHead (IN ProcessorId dspId,
IN List * list,
OUT ListElement ** headElement )
{
PoolId poolId = POOL_INVALIDID;
LDRV_MPLIST_Object * mplistState ;
ListElement * temp ;
TRC_3ENTER ("LDRV_MPLIST_getHead", dspId, list, headElement) ;
DBC_Require (IS_VALID_PROCID(dspId)) ;
DBC_Require (list != NULL) ;
DBC_Require (headElement != NULL) ;
DBC_Assert (LDRV_MPLIST_IsInitialized [dspId] == TRUE) ;
mplistState = &(LDRV_MPLIST_State [dspId]) ;
if (LDRV_MPLIST_isEmpty (dspId, list) == TRUE) {
*headElement = NULL ;
}
else {
*headElement = (ListElement *)
DSP_addrConvert (dspId,
SWAP_LONG (((Uint32) (list->head.next)),
mplistState->wordSwap),
DspToGpp) ;
/* Get the pool Id of the Head element */
LDRV_POOL_getPoolId (dspId,
*headElement,
AddrType_Knl,
&poolId);
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_invalidate (poolId, *headElement, sizeof (ListElement)) ;
}
list->head.next = (ListElement *) (*headElement)->next ;
temp = (ListElement *)
DSP_addrConvert (dspId,
SWAP_LONG ((Uint32) ((*headElement)->next),
mplistState->wordSwap),
DspToGpp) ;
LDRV_POOL_getPoolId (dspId,
temp,
AddrType_Knl,
&poolId );
/* Invalidate only when (*headElement)->next is from POOL memory*/
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_invalidate (poolId, temp, sizeof (ListElement)) ;
}
temp->prev = (ListElement *)
SWAP_LONG (DSP_addrConvert (dspId,
(Uint32) (&(list->head)),
GppToDsp),
mplistState->wordSwap) ;
if (IS_VALID_POOLID (poolId)) {
LDRV_POOL_writeback (poolId, temp, sizeof (ListElement)) ;
}
}
TRC_0LEAVE ("LDRV_MPLIST_getHead") ;
}
/*!
* @brief Function to open a handle to an instance of this PwrMgr. This
* function is called when access to the PwrMgr is required from
* a different process.
*
* @param handlePtr Handle to the PwrMgr instance
* @param procId Processor ID addressed by this PwrMgr instance.
*
* @sa DM8168DUCATIPWR_close
*/
Int
DM8168DUCATIPWR_open (DM8168DUCATIPWR_Handle * handlePtr, UInt16 procId)
{
Int status = PWRMGR_SUCCESS;
GT_2trace (curTrace, GT_ENTER, "DM8168DUCATIPWR_open", handlePtr, procId);
GT_assert (curTrace, (handlePtr != NULL));
GT_assert (curTrace, IS_VALID_PROCID (procId));
GT_assert (curTrace, (DM8168DUCATIPWR_state.refCount != 0));
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
if (DM8168DUCATIPWR_state.refCount == 0) {
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_open",
DM8168DUCATIPWR_E_INVALIDSTATE,
"Module was not initialized!");
}
else if (handlePtr == NULL) {
/*! @retval PWRMGR_E_HANDLE Invalid NULL handlePtr specified */
status = PWRMGR_E_HANDLE;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_open",
status,
"Invalid NULL handlePtr specified");
}
else if (!IS_VALID_PROCID (procId)) {
/*! @retval PWRMGR_E_INVALIDARG Invalid procId specified */
status = PWRMGR_E_INVALIDARG;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_open",
status,
"Invalid procId specified");
}
else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
/* Initialize return parameter handle. */
*handlePtr = NULL;
/* Check if the PwrMgr exists and return the handle if found. */
if (DM8168DUCATIPWR_state.pwrHandles [procId] == NULL) {
/*! @retval PWRMGR_E_NOTFOUND Specified instance not found */
status = PWRMGR_E_NOTFOUND;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_open",
status,
"Specified DM8168DUCATIPWR instance does not exist!");
}
else {
*handlePtr = DM8168DUCATIPWR_state.pwrHandles [procId];
}
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
}
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
GT_1trace (curTrace, GT_LEAVE, "DM8168DUCATIPWR_open", status);
/*! @retval PWRMGR_SUCCESS Operation successful */
return status;
}
/** ============================================================================
* @func LDRV_MPLIST_init
*
* @desc This function allocates and initializes resources used by this
* component.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_MPLIST_init (IN ProcessorId dspId, OUT Uint32 * shDspAddr)
{
DSP_STATUS status = DSP_SOK ;
LINKCFG_MpList * mplistObject ;
LINKCFG_Dsp * dspObj ;
LINKCFG_DspConfig * dspCfg ;
LINKCFG_LinkDrv * linkDrv ;
LDRV_MPLIST_Object * mplistState ;
TRC_2ENTER ("LDRV_MPLIST_init", dspId, shDspAddr) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
DBC_Require (shDspAddr != NULL) ;
mplistState = &(LDRV_MPLIST_State [dspId]) ;
dspCfg = LDRV_LinkCfgPtr->dspConfigs [dspId] ;
dspObj = dspCfg->dspObject ;
linkDrv = &(dspCfg->linkDrvObjects [dspObj->linkDrvId]) ;
mplistObject = &(dspCfg->mplistObjects [linkDrv->mplistTableId]) ;
*shDspAddr = (Uint32) NULL ;
if (LDRV_MPLIST_IsInitialized [dspId] == FALSE) {
/* --------------------------------------------------------------------
* Validate the setup configuration parameters for the link driver.
* --------------------------------------------------------------------
*/
mplistState = &(LDRV_MPLIST_State [dspId]) ;
/* Initialize the state object. */
mplistState->ctrlPtr = NULL ;
mplistState->dspCtrlAddr = (Uint32) NULL ;
mplistState->physCtrlAddr = (Uint32) NULL ;
mplistState->ctrlSize = 0 ;
mplistState->memEntry = mplistObject->memEntry ;
mplistState->wordSwap = dspObj->wordSwap ;
/* Check if the memEntry is in valid range. */
if ( (mplistObject->memEntry != (Uint32) -1)
&& (mplistObject->memEntry >= dspObj->memEntries)) {
PRINT_Printf ("<1>Configuration error:"
" Incorrect MPLIST memEntry specified [0x%x]\n",
mplistObject->memEntry) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else if ( (mplistObject->ipsId != (Uint32) -1)
&& (mplistObject->ipsId >= linkDrv->numIpsEntries)) {
/* Check if the ipsId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect MPLIST ipsId specified [0x%x]\n",
mplistObject->ipsId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else if ( (mplistObject->ipsId != (Uint32) -1)
&& (mplistObject->ipsEventNo != (Uint32) -1)
&& ( mplistObject->ipsEventNo
>= dspCfg->ipsTables [linkDrv->ipsTableId]
[mplistObject->ipsId].numIpsEvents)) {
/* Check if the ipsEventNo is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect MPLIST ipsEventNo specified [0x%x]\n",
mplistObject->ipsEventNo) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else {
/* Added for MISRAC compliance */
}
}
if ( (LDRV_MPLIST_IsInitialized [dspId] == FALSE)
&& (DSP_SUCCEEDED (status))) {
/* --------------------------------------------------------------------
* Allocate shared memory required for the MPLIST component.
* --------------------------------------------------------------------
*/
mplistState->ctrlSize = sizeof (MPLIST_Ctrl)
+ (sizeof (MPLIST_Entry) * mplistObject->maxEntries) ;
status = LDRV_SMM_alloc (dspId,
mplistState->memEntry,
&(mplistState->physCtrlAddr),
&(mplistState->dspCtrlAddr),
(Uint32 *) ((Pvoid) &(mplistState->ctrlPtr)),
mplistState->ctrlSize) ;
if (DSP_SUCCEEDED (status)) {
*shDspAddr = mplistState->dspCtrlAddr ;
TRC_1PRINT (TRC_LEVEL4,
"MPLIST Ctrl GPP address [0x%x]\n",
mplistState->ctrlPtr) ;
TRC_1PRINT (TRC_LEVEL4,
"MPLIST Ctrl DSP address [0x%x]\n",
mplistState->dspCtrlAddr) ;
TRC_1PRINT (TRC_LEVEL4,
"MPLIST Ctrl physical address [0x%x]\n",
mplistState->physCtrlAddr) ;
TRC_1PRINT (TRC_LEVEL4,
"MPLIST Ctrl size [0x%x]\n",
mplistState->ctrlSize) ;
/* mplistState->ctrlPtr->entry is set on user-side with user
* address.
*/
mplistState->ctrlPtr->dspAddrEntry = (MPLIST_Entry *)
( (Uint32) (mplistState->dspCtrlAddr)
+ sizeof (MPLIST_Ctrl)) ;
}
else {
SET_FAILURE_REASON ;
}
LDRV_MPLIST_IsInitialized [dspId] = TRUE ;
if (DSP_FAILED (status)) {
/* LDRV_MPLIST_exit executes cleanup only if the initialized flag is
* TRUE.
*/
LDRV_MPLIST_exit (dspId) ;
LDRV_MPLIST_IsInitialized [dspId] = FALSE ;
}
}
TRC_1LEAVE ("LDRV_MPLIST_init", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_freeLinkCfg
*
* @desc Frees any memory allocated for the kernel-side APUDRV configuration
* structure.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_freeLinkDspCfg (IN ProcessorId procId,
IN LINKCFG_Object * knlLinkCfg)
{
DSP_STATUS status = DSP_SOK ;
DSP_STATUS tmpStatus = DSP_SOK ;
LINKCFG_DspConfig * dspCfg = NULL ;
LINKCFG_Dsp * dspObject = NULL ;
#if !(defined (ONLY_PROC_COMPONENT))
LINKCFG_LinkDrv * linkDrvObject = NULL ;
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
Uint32 tableId ;
TRC_2ENTER ("LDRV_freeLinkDspCfg", procId, knlLinkCfg) ;
DBC_Require (IS_VALID_PROCID (procId)) ;
DBC_Require (knlLinkCfg != NULL) ;
if (knlLinkCfg != NULL) {
dspCfg = knlLinkCfg->dspConfigs [procId] ;
if (dspCfg != NULL && ((Pvoid) dspCfg >= KMEM_STARTADDRESS)) {
dspObject = dspCfg->dspObject ;
if (dspObject != NULL && ((Pvoid) dspObject >= KMEM_STARTADDRESS)) {
#if !(defined (ONLY_PROC_COMPONENT))
linkDrvObject = &dspCfg->linkDrvObjects [dspObject->linkDrvId] ;
if ( (linkDrvObject != NULL)
&& ((Pvoid) linkDrvObject >= KMEM_STARTADDRESS)) {
}
else {
status = DSP_EFAIL ;
SET_FAILURE_REASON ;
}
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
}
else {
status = DSP_EFAIL ;
SET_FAILURE_REASON ;
}
}
else {
status = DSP_EFAIL ;
SET_FAILURE_REASON ;
}
}
else {
status = DSP_EFAIL ;
SET_FAILURE_REASON ;
}
if (DSP_SUCCEEDED (status)) {
#if defined (LOG_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the LOG object.
* --------------------------------------------------------------------
*/
if ( (dspCfg->logObject != NULL)
&& (dspCfg->logObject >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->logObject) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (LOG_COMPONENT) */
#if !(defined (ONLY_PROC_COMPONENT))
#if defined (MPCS_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the MPCS objects
* --------------------------------------------------------------------
*/
if ( (dspCfg->mpcsObjects != NULL)
&& ((Pvoid) dspCfg->mpcsObjects >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->mpcsObjects) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MPCS_COMPONENT) */
#if defined (MPLIST_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the MPLIST objects
* --------------------------------------------------------------------
*/
if ( (dspCfg->mplistObjects != NULL)
&& ((Pvoid) dspCfg->mplistObjects >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->mplistObjects) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MPLIST_COMPONENT) */
#if defined (RINGIO_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the RingIO objects
* --------------------------------------------------------------------
*/
if ( (dspCfg->ringIoObjects != NULL)
&& ((Pvoid) dspCfg->ringIoObjects >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->ringIoObjects) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (RINGIO_COMPONENT) */
#if defined (MSGQ_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the MQT objects
* --------------------------------------------------------------------
*/
if ( (dspCfg->mqtObjects != NULL)
&& ((Pvoid) dspCfg->mqtObjects >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->mqtObjects) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MSGQ_COMPONENT) */
#if defined (CHNL_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the Data driver tables
* --------------------------------------------------------------------
*/
if ( (dspCfg->dataTables != NULL)
&& ((Pvoid) dspCfg->dataTables >= KMEM_STARTADDRESS)) {
tableId = linkDrvObject->dataTableId ;
tmpStatus = FREE_PTR (dspCfg->dataTables [tableId]) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
tmpStatus = FREE_PTR (dspCfg->dataTables) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (CHNL_COMPONENT) */
#if defined (POOL_COMPONENT)
/* --------------------------------------------------------------------
* Free memory allocated for the Pool tables
* --------------------------------------------------------------------
*/
if ( (dspCfg->poolTables != NULL)
&& ((Pvoid) dspCfg->poolTables >= KMEM_STARTADDRESS)) {
tableId = linkDrvObject->poolTableId ;
tmpStatus = FREE_PTR (dspCfg->poolTables [tableId]) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
tmpStatus = FREE_PTR (dspCfg->poolTables) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if defined (POOL_COMPONENT) */
/* --------------------------------------------------------------------
* Free memory allocated for the IPS tables
* --------------------------------------------------------------------
*/
if ( (dspCfg->ipsTables != NULL)
&& ((Pvoid) dspCfg->ipsTables >= KMEM_STARTADDRESS)) {
tableId = linkDrvObject->ipsTableId ;
tmpStatus = FREE_PTR (dspCfg->ipsTables [tableId]) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
tmpStatus = FREE_PTR (dspCfg->ipsTables) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
/* --------------------------------------------------------------------
* Free memory allocated for the Memory tables
* --------------------------------------------------------------------
*/
if ( (dspCfg->memTables != NULL)
&& ((Pvoid) dspCfg->memTables >= KMEM_STARTADDRESS)) {
tableId = dspCfg->dspObject->memTableId ;
tmpStatus = FREE_PTR (dspCfg->memTables [tableId]) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
tmpStatus = FREE_PTR (dspCfg->memTables) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
/* --------------------------------------------------------------------
* Free memory allocated for the Link Driver objects
* --------------------------------------------------------------------
*/
#if !(defined (ONLY_PROC_COMPONENT))
if ( (dspCfg->linkDrvObjects != NULL)
&& ((Pvoid) dspCfg->linkDrvObjects >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->linkDrvObjects) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
/* --------------------------------------------------------------------
* Free memory allocated for the DSP objects
* --------------------------------------------------------------------
*/
if ( (dspCfg->dspObject != NULL)
&& ((Pvoid) dspCfg->dspObject >= KMEM_STARTADDRESS)) {
tmpStatus = FREE_PTR (dspCfg->dspObject) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
/* --------------------------------------------------------------------
* Free memory allocated for the global DSP Config object.
* --------------------------------------------------------------------
*/
tmpStatus = FREE_PTR (dspCfg) ;
if (DSP_FAILED (tmpStatus) && DSP_SUCCEEDED (status)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
/* Delete the dspConfig anyway */
knlLinkCfg->dspConfigs [procId] = NULL ;
}
TRC_1LEAVE ("LDRV_freeLinkDspCfg", status) ;
return status ;
}
/*!
* @brief Function to delete an instance of this PwrMgr.
*
* The user provided pointer to the handle is reset after
* successful completion of this function.
*
* @param handlePtr Pointer to Handle to the PwrMgr instance
*
* @sa DM8168DUCATIPWR_create
*/
Int
DM8168DUCATIPWR_delete (DM8168DUCATIPWR_Handle * handlePtr)
{
Int status = PWRMGR_SUCCESS;
DM8168DUCATIPWR_Object * object = NULL;
PwrMgr_Object * handle;
IArg key;
GT_1trace (curTrace, GT_ENTER, "DM8168DUCATIPWR_delete", handlePtr);
GT_assert (curTrace, (handlePtr != NULL));
GT_assert (curTrace, ((handlePtr != NULL) && (*handlePtr != NULL)));
GT_assert (curTrace, (DM8168DUCATIPWR_state.refCount != 0));
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
if (DM8168DUCATIPWR_state.refCount == 0) {
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_delete",
DM8168DUCATIPWR_E_INVALIDSTATE,
"Module was not initialized!");
}
else if (handlePtr == NULL) {
/*! @retval PWRMGR_E_INVALIDARG Invalid NULL handlePtr specified*/
status = PWRMGR_E_INVALIDARG;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_delete",
status,
"Invalid NULL handlePtr specified");
}
else if (*handlePtr == NULL) {
/*! @retval PWRMGR_E_HANDLE Invalid NULL *handlePtr specified */
status = PWRMGR_E_HANDLE;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_delete",
status,
"Invalid NULL *handlePtr specified");
}
else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
handle = (PwrMgr_Object *) (*handlePtr);
/* Enter critical section protection. */
key = IGateProvider_enter (DM8168DUCATIPWR_state.gateHandle);
/* Reset handle in PwrMgr handle array. */
GT_assert (curTrace, IS_VALID_PROCID (handle->procId));
DM8168DUCATIPWR_state.pwrHandles [handle->procId] = NULL;
object = (DM8168DUCATIPWR_Object *) handle->object;
/* Free memory used for the DM8168DUCATIPWR object. */
if (handle->object != NULL) {
/* Free memory used for the clock handle */
#if defined (SYSLINK_BUILDOS_LINUX)
LinuxClock_delete(((DM8168DUCATIPWR_Object *)handle->object)->clockHandle);
#endif /* #if defined (SYSLINK_BUILDOS_LINUX) */
#if defined (SYSLINK_BUILD_RTOS)
DM8168CLOCK_delete(((DM8168DUCATIPWR_Object *)handle->object)->clockHandle);
#endif /* #if defined (SYSLINK_BUILD_RTOS) */
Memory_free (NULL,
object,
sizeof (DM8168DUCATIPWR_Object));
handle->object = NULL;
}
/* Free memory used for the PwrMgr object. */
Memory_free (NULL, handle, sizeof (PwrMgr_Object));
*handlePtr = NULL;
/* Leave critical section protection. */
IGateProvider_leave (DM8168DUCATIPWR_state.gateHandle, key);
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
}
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
GT_1trace (curTrace, GT_LEAVE, "DM8168DUCATIPWR_delete", status);
/*! @retval PWRMGR_SUCCESS Operation successful */
return (status);
}
/** ============================================================================
* @func LDRV_DRV_init
*
* @desc This function allocates and initializes resources used by this
* component.
*
* @modif None.
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_DRV_init (IN ProcessorId dspId)
{
DSP_STATUS status = DSP_SOK ;
LDRV_DRV_Ctrl * drvCtrl = NULL ;
LINKCFG_DspConfig * dspCfg ;
LINKCFG_Dsp * dspObj ;
LINKCFG_LinkDrv * linkDrv ;
LDRV_DRV_Object * drvState ;
Int32 strCmpResult ;
Uint32 mapId ;
TRC_1ENTER ("LDRV_DRV_init", dspId) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
drvState = &(LDRV_DRV_State [dspId]) ;
dspCfg = LDRV_LinkCfgPtr->dspConfigs [dspId] ;
dspObj = dspCfg->dspObject ;
linkDrv = &(dspCfg->linkDrvObjects [dspObj->linkDrvId]) ;
if (LDRV_DRV_IsInitialized [dspId] == FALSE) {
/* --------------------------------------------------------------------
* Validate the setup configuration parameters for the link driver.
* --------------------------------------------------------------------
*/
drvState = &(LDRV_DRV_State [dspId]) ;
/* Initialize the state object. */
drvState->linkDrvId = dspObj->linkDrvId ;
drvState->ctrlPtr = NULL ;
drvState->dspCtrlAddr = (Uint32) NULL ;
drvState->interface = NULL ;
/* Check if the configured link driver is available and set the
* interface table if the configuration is valid.
*/
for (mapId = 0 ; mapId < CFGMAP_Config [dspId]->numLinkDrvs ; mapId++) {
status = GEN_Strcmp (
dspCfg->linkDrvObjects [drvState->linkDrvId].name,
CFGMAP_Config [dspId]->linkDrvObjects [mapId].name,
&strCmpResult) ;
DBC_Assert (DSP_SUCCEEDED (status)) ;
if (strCmpResult == 0) {
drvState->interface =
CFGMAP_Config [dspId]->linkDrvObjects [mapId].interface ;
break ;
}
}
if (mapId == CFGMAP_Config [dspId]->numLinkDrvs) {
/* Configured link driver is not available. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver name specified [%s]\n",
dspCfg->linkDrvObjects [drvState->linkDrvId].name) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else {
/* Check if the memEntry is in valid range. */
if ( (linkDrv->memEntry != (Uint32) -1)
&& (linkDrv->memEntry >= dspObj->memEntries)) {
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver memEntry specified [0x%x]\n",
linkDrv->memEntry) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else if (linkDrv->ipsTableId >= dspCfg->numIpsTables) {
/* Check if the ipsTableId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver ipsTableId specified [0x%x]\n",
linkDrv->ipsTableId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#if defined (POOL_COMPONENT)
else if (linkDrv->poolTableId >= dspCfg->numPoolTables) {
/* Check if the poolTableId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver poolTableId specified [0x%x]\n",
linkDrv->poolTableId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#endif /* if defined (POOL_COMPONENT) */
#if defined (CHNL_COMPONENT)
else if (linkDrv->dataTableId >= dspCfg->numDataTables) {
/* Check if the dataTableId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver dataTableId specified [0x%x]\n",
linkDrv->dataTableId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#endif /* if defined (CHNL_COMPONENT) */
#if defined (MSGQ_COMPONENT)
else if (linkDrv->mqtId >= dspCfg->numMqts) {
/* Check if the mqtId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver mqtId specified [0x%x]\n",
linkDrv->mqtId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#endif /* if defined (MSGQ_COMPONENT) */
#if defined (RINGIO_COMPONENT)
else if (linkDrv->ringIoTableId >= dspCfg->numRingIo) {
/* Check if the ringIoTableId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver ringIoTableId specified [0x%x]\n",
linkDrv->ringIoTableId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#endif /* if defined (RINGIO_COMPONENT) */
#if defined (MPLIST_COMPONENT)
else if (linkDrv->mplistTableId >= dspCfg->numMpList) {
/* Check if the mplistTableId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver mplistTableId specified [0x%x]\n",
linkDrv->mplistTableId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#endif /* if defined (MPLIST_COMPONENT) */
#if defined (MPCS_COMPONENT)
else if (linkDrv->mpcsTableId >= dspCfg->numMpcs) {
/* Check if the mpcsTableId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect link driver mpcsTableId specified [0x%x]\n",
linkDrv->mpcsTableId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
#endif /* if defined (MPCS_COMPONENT) */
}
/* --------------------------------------------------------------------
* Initialize the Shared Memory Manager component.
* --------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
status = LDRV_SMM_init (dspId) ;
}
else {
SET_FAILURE_REASON ;
}
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Allocate shared memory required for the LDRV_DRV component.
* ----------------------------------------------------------------
*/
status = LDRV_SMM_alloc (dspId,
linkDrv->memEntry,
NULL, /* Physical address not required. */
&(drvState->dspCtrlAddr),
(Uint32 *) ((Pvoid) &(drvState->ctrlPtr)),
sizeof (LDRV_DRV_Ctrl)) ;
if (DSP_SUCCEEDED (status)) {
TRC_1PRINT (TRC_LEVEL4,
"LDRV_DRV Ctrl GPP address [0x%x]\n",
drvState->ctrlPtr) ;
TRC_1PRINT (TRC_LEVEL4,
"LDRV_DRV Ctrl DSP address [0x%x]\n",
drvState->dspCtrlAddr) ;
TRC_1PRINT (TRC_LEVEL4,
"LDRV_DRV Ctrl size [0x%x]\n",
sizeof (LDRV_DRV_Ctrl)) ;
drvCtrl = drvState->ctrlPtr ;
DBC_Assert (drvCtrl != NULL) ;
}
else {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize all fields of the shared memory control structure.
* ----------------------------------------------------------------
*/
status = GEN_Strcpyn (drvCtrl->version,
APUDRV_VERSION,
DSP_MAX_STRLEN) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->linkAddr = 0 ;
drvCtrl->drvDspInitDone = (Uint32) -1 ;
drvCtrl->ipsAddr = 0 ;
drvCtrl->ipsDspInitDone = (Uint32) -1 ;
drvCtrl->poolAddr = 0 ;
drvCtrl->poolConfigured = 0 ;
drvCtrl->poolDspInitDone = (Uint32) -1 ;
drvCtrl->mpcsAddr = 0 ;
drvCtrl->mpcsConfigured = 0 ;
drvCtrl->mpcsDspInitDone = (Uint32) -1 ;
drvCtrl->mplistAddr = 0 ;
drvCtrl->mplistConfigured = 0 ;
drvCtrl->mplistDspInitDone = (Uint32) -1 ;
drvCtrl->mqtAddr = 0 ;
drvCtrl->mqtConfigured = 0 ;
drvCtrl->mqtDspInitDone = (Uint32) -1 ;
drvCtrl->dataAddr = 0 ;
drvCtrl->dataConfigured = 0 ;
drvCtrl->dataDspInitDone = (Uint32) -1 ;
drvCtrl->ringIoAddr = 0 ;
drvCtrl->ringIoConfigured = 0 ;
drvCtrl->ringIoDspInitDone = (Uint32) -1 ;
drvCtrl->config.numIpsEntries = linkDrv->numIpsEntries ;
drvCtrl->config.numPools = linkDrv->numPools ;
drvCtrl->config.numDataDrivers = linkDrv->numDataDrivers ;
drvCtrl->config.cpuFreq = dspObj->cpuFreq ;
}
else {
SET_FAILURE_REASON ;
}
}
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the link towards the DSP and get the address of its
* shared memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = (drvState->interface->init) (dspId,
drvState->linkDrvId,
&(drvCtrl->linkAddr)) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the IPS component and get the address of its
* shared memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_IPS_init (dspId, &(drvCtrl->ipsAddr)) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
#if defined (POOL_COMPONENT)
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the POOL component and get the address of its shared
* memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_POOL_init (dspId, &(drvCtrl->poolAddr)) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->poolConfigured = (Uint32) TRUE ;
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (POOL_COMPONENT) */
#if defined (MPCS_COMPONENT)
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the MPCS component and get the address of its shared
* memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_MPCS_init (dspId, &(drvCtrl->mpcsAddr)) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->mpcsConfigured = (Uint32) TRUE ;
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MPCS_COMPONENT) */
#if defined (MPLIST_COMPONENT)
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the MPLIST component and get the address of its
* shared memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_MPLIST_init (dspId, &(drvCtrl->mplistAddr)) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->mplistConfigured = (Uint32) TRUE ;
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MPLIST_COMPONENT) */
#if defined (MSGQ_COMPONENT)
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the MQT component and get the address of its shared
* memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_MQT_init (dspId, &(drvCtrl->mqtAddr)) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->mqtConfigured = (Uint32) TRUE ;
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MSGQ_COMPONENT) */
#if defined (CHNL_COMPONENT)
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the DATA component and get the address of its shared
* memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_DATA_init (dspId, &(drvCtrl->dataAddr)) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->dataConfigured = (Uint32) TRUE ;
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (CHNL_COMPONENT) */
#if defined (RINGIO_COMPONENT)
if (DSP_SUCCEEDED (status)) {
/* ----------------------------------------------------------------
* Initialize the RINGIO component and get the address of its
* shared memory control region in DSP address space.
* ----------------------------------------------------------------
*/
status = LDRV_RINGIO_init (dspId, &(drvCtrl->ringIoAddr)) ;
if (DSP_SUCCEEDED (status)) {
drvCtrl->ringIoConfigured = (Uint32) TRUE ;
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (RINGIO_COMPONENT) */
LDRV_DRV_IsInitialized [dspId] = TRUE ;
if (DSP_FAILED (status)) {
/* LDRV_DRV_exit executes cleanup only if the initialized flag is
* TRUE.
*/
LDRV_DRV_exit (dspId) ;
LDRV_DRV_IsInitialized [dspId] = FALSE ;
}
}
TRC_1LEAVE ("LDRV_DRV_init", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_DRV_exit
*
* @desc This function finalizes the LDRV DRV module for a particular DSP.
* Finalizing means no further services will be provided by this
* module for this particular DSP.
*
* @modif None.
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_DRV_exit (IN ProcessorId dspId)
{
DSP_STATUS status = DSP_SOK ;
DSP_STATUS tmpStatus = DSP_SOK ;
LDRV_DRV_Object * drvState ;
LINKCFG_Dsp * dspObj ;
LINKCFG_LinkDrv * linkDrv ;
LINKCFG_DspConfig * dspCfg ;
TRC_1ENTER ("LDRV_DRV_exit", dspId) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
if (LDRV_DRV_IsInitialized [dspId] == TRUE) {
if (LDRV_LinkCfgPtr != NULL) {
dspCfg = LDRV_LinkCfgPtr->dspConfigs [dspId] ;
drvState = &(LDRV_DRV_State [dspId]) ;
dspObj = dspCfg->dspObject ;
linkDrv = &(dspCfg->linkDrvObjects [dspObj->linkDrvId]) ;
#if defined (RINGIO_COMPONENT)
/* ----------------------------------------------------------------
* Finalize the RINGIO component.
* ----------------------------------------------------------------
*/
status = LDRV_RINGIO_exit (dspId) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
#endif /* if defined (RINGIO_COMPONENT) */
#if defined (CHNL_COMPONENT)
/* ----------------------------------------------------------------
* Finalize the DATA component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_DATA_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
#endif /* if defined (CHNL_COMPONENT) */
#if defined (MSGQ_COMPONENT)
/* ----------------------------------------------------------------
* Finalize the MQT component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_MQT_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
#endif /* if defined (MSGQ_COMPONENT) */
#if defined (MPLIST_COMPONENT)
/* ----------------------------------------------------------------
* Finalize the MPLIST component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_MPLIST_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
#endif /* if defined (MPLIST_COMPONENT) */
#if defined (MPCS_COMPONENT)
/* ----------------------------------------------------------------
* Finalize the MPCS component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_MPCS_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
#endif /* if defined (MPCS_COMPONENT) */
#if defined (POOL_COMPONENT)
/* ----------------------------------------------------------------
* Finalize the POOL component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_POOL_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
#endif /* if defined (POOL_COMPONENT) */
/* ----------------------------------------------------------------
* Finalize the IPS component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_IPS_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
/* ----------------------------------------------------------------
* Finalize the link toward the DSP.
* ----------------------------------------------------------------
*/
if (drvState->interface != NULL) {
tmpStatus = (drvState->interface->exit) (dspId,
drvState->linkDrvId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
/* ----------------------------------------------------------------
* Free shared memory allocated for the LDRV_DRV component.
* ----------------------------------------------------------------
*/
if (drvState->ctrlPtr != NULL) {
tmpStatus = LDRV_SMM_free (dspId,
linkDrv->memEntry,
sizeof (LDRV_DRV_Ctrl)) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
/* ----------------------------------------------------------------
* Finalize the Shared Memory Manager component.
* ----------------------------------------------------------------
*/
tmpStatus = LDRV_SMM_exit (dspId) ;
if (DSP_SUCCEEDED (status) && DSP_FAILED (tmpStatus)) {
status = tmpStatus ;
SET_FAILURE_REASON ;
}
}
LDRV_DRV_IsInitialized [dspId] = FALSE ;
}
TRC_1LEAVE ("LDRV_DRV_exit", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_MPCS_init
*
* @desc This function allocates and initializes resources used by this
* component.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_MPCS_init (IN ProcessorId dspId, OUT Uint32 * shDspAddr)
{
DSP_STATUS status = DSP_SOK ;
LINKCFG_Mpcs * mpcsObject ;
LINKCFG_Dsp * dspObj ;
LINKCFG_DspConfig * dspCfg ;
LINKCFG_LinkDrv * linkDrv ;
LDRV_MPCS_Object * mpcsState ;
MPCS_Ctrl * mpcsCtrl ;
Uint32 i ;
MPCS_Entry * entry ;
TRC_2ENTER ("LDRV_MPCS_init", dspId, shDspAddr) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
DBC_Require (shDspAddr != NULL) ;
mpcsState = &(LDRV_MPCS_State [dspId]) ;
dspCfg = LDRV_LinkCfgPtr->dspConfigs [dspId] ;
dspObj = dspCfg->dspObject ;
linkDrv = &(dspCfg->linkDrvObjects [dspObj->linkDrvId]) ;
mpcsObject = &(dspCfg->mpcsObjects [linkDrv->mpcsTableId]) ;
*shDspAddr = (Uint32) NULL ;
if (LDRV_MPCS_IsInitialized [dspId] == FALSE) {
/* --------------------------------------------------------------------
* Validate the setup configuration parameters for the link driver.
* --------------------------------------------------------------------
*/
mpcsState = &(LDRV_MPCS_State [dspId]) ;
/* Initialize the state object. */
mpcsState->ctrlPtr = NULL ;
mpcsState->dspCtrlAddr = (Uint32) NULL ;
mpcsState->physCtrlAddr = (Uint32) NULL ;
mpcsState->ctrlSize = 0 ;
mpcsState->memEntry = mpcsObject->memEntry ;
mpcsState->maxEntries = mpcsObject->maxEntries ;
/* Check if the memEntry is in valid range. */
if ( (mpcsObject->memEntry != (Uint32) -1)
&& (mpcsObject->memEntry >= dspObj->memEntries)) {
PRINT_Printf ("<1>Configuration error:"
" Incorrect MPCS memEntry specified [0x%x]\n",
mpcsObject->memEntry) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else if ( (mpcsObject->ipsId != (Uint32) -1)
&& (mpcsObject->ipsId >= linkDrv->numIpsEntries)) {
/* Check if the ipsId is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect MPCS ipsId specified [0x%x]\n",
mpcsObject->ipsId) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else if ( (mpcsObject->ipsId != (Uint32) -1)
&& (mpcsObject->ipsEventNo != (Uint32) -1)
&& ( mpcsObject->ipsEventNo
>= dspCfg->ipsTables [linkDrv->ipsTableId]
[mpcsObject->ipsId].numIpsEvents)) {
/* Check if the ipsEventNo is in valid range. */
PRINT_Printf ("<1>Configuration error:"
" Incorrect MPCS ipsEventNo specified [0x%x]\n",
mpcsObject->ipsEventNo) ;
status = DSP_ECONFIG ;
SET_FAILURE_REASON ;
}
else {
/*Added for MISRAC compliance */
}
}
if ( (LDRV_MPCS_IsInitialized [dspId] == FALSE)
&& (DSP_SUCCEEDED (status))) {
/* --------------------------------------------------------------------
* Allocate shared memory required for the MPCS component.
* --------------------------------------------------------------------
*/
mpcsState->ctrlSize = sizeof (MPCS_Ctrl)
+ (sizeof (MPCS_Entry) * mpcsObject->maxEntries) ;
status = LDRV_SMM_alloc (dspId,
mpcsState->memEntry,
&(mpcsState->physCtrlAddr),
&(mpcsState->dspCtrlAddr),
(Uint32 *) ((Pvoid) &(mpcsState->ctrlPtr)),
mpcsState->ctrlSize) ;
if (DSP_SUCCEEDED (status)) {
*shDspAddr = mpcsState->dspCtrlAddr ;
TRC_1PRINT (TRC_LEVEL4,
"MPCS Ctrl GPP address [0x%x]\n",
mpcsState->ctrlPtr) ;
TRC_1PRINT (TRC_LEVEL4,
"MPCS Ctrl DSP address [0x%x]\n",
mpcsState->dspCtrlAddr) ;
TRC_1PRINT (TRC_LEVEL4,
"MPCS Ctrl physical address [0x%x]\n",
mpcsState->physCtrlAddr) ;
TRC_1PRINT (TRC_LEVEL4,
"MPCS Ctrl size [0x%x]\n",
mpcsState->ctrlSize) ;
mpcsCtrl = mpcsState->ctrlPtr ;
DBC_Assert (mpcsCtrl != NULL) ;
/* Initialize the control region. */
mpcsCtrl->dspId = dspId ;
mpcsCtrl->maxEntries = mpcsState->maxEntries ;
mpcsCtrl->ipsId = mpcsObject->ipsId ;
mpcsCtrl->ipsEventNo = mpcsObject->ipsEventNo ;
entry = (MPCS_Entry *) ( (Uint32) (mpcsState->ctrlPtr)
+ sizeof (MPCS_Ctrl)) ;
mpcsCtrl->dspAddrEntry = (MPCS_Entry *)
( (Uint32) (mpcsState->dspCtrlAddr)
+ sizeof (MPCS_Ctrl)) ;
/* Initialize the entries table. */
for (i = 0 ; i < mpcsState->maxEntries ; i++) {
entry [i].physAddress = NULL ;
entry [i].name [0] = '\0' ;
}
/* Create the MPCS to be used for protecting the shared region. */
status = LDRV_MPCS_create (dspId, &(mpcsCtrl->lockObj)) ;
if (DSP_SUCCEEDED (status)) {
mpcsCtrl->isInitialized = TRUE ;
}
else {
SET_FAILURE_REASON ;
}
/* mpcsCtrl->entry is reset on user-side with user address */
}
else {
SET_FAILURE_REASON ;
}
LDRV_MPCS_IsInitialized [dspId] = TRUE ;
if (DSP_FAILED (status)) {
/* LDRV_MPCS_exit executes cleanup only if the initialized flag is
* TRUE.
*/
LDRV_MPCS_exit (dspId) ;
LDRV_MPCS_IsInitialized [dspId] = FALSE ;
}
}
TRC_1LEAVE ("LDRV_MPCS_init", status) ;
return status ;
}
/** ============================================================================
* @func LDRV_DRV_debug
*
* @desc Prints the current status of this subcomponent.
*
* @modif None.
* ============================================================================
*/
NORMAL_API
Void
LDRV_DRV_debug (IN ProcessorId dspId)
{
LDRV_DRV_Object * drvState ;
TRC_1ENTER ("LDRV_DRV_debug", dspId) ;
DBC_Require (IS_VALID_PROCID (dspId)) ;
drvState = &(LDRV_DRV_State [dspId]) ;
if (LDRV_DRV_IsInitialized [dspId] == TRUE) {
/* --------------------------------------------------------------------
* Print the LDRV DRV component state information.
* --------------------------------------------------------------------
*/
TRC_0PRINT (TRC_LEVEL4, "========================================.\n") ;
TRC_1PRINT (TRC_LEVEL4,
"LDRV DRV component state information for DSP ID %d:\n",
dspId) ;
TRC_1PRINT (TRC_LEVEL4,
" ctrlPtr = [0x%x].\n",
drvState->ctrlPtr) ;
TRC_1PRINT (TRC_LEVEL4,
" dspCtrlAddr = [0x%x].\n",
drvState->dspCtrlAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" interface = [0x%x].\n",
drvState->interface) ;
TRC_0PRINT (TRC_LEVEL4, "========================================.\n") ;
/* --------------------------------------------------------------------
* Print the information for the shared memory region.
* --------------------------------------------------------------------
*/
TRC_0PRINT (TRC_LEVEL4, "Shared memory region information:\n") ;
TRC_1PRINT (TRC_LEVEL4,
" version = [%s]\n",
drvState->ctrlPtr->version) ;
TRC_1PRINT (TRC_LEVEL4,
" ProcId = [%d]\n",
drvState->ctrlPtr->procId) ;
TRC_1PRINT (TRC_LEVEL4,
" linkAddr = [%d]\n",
drvState->ctrlPtr->linkAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" drvDspInitDone = [0x%x]\n",
drvState->ctrlPtr->drvDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" ipsAddr = [0x%x]\n",
drvState->ctrlPtr->ipsAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" ipsDspInitDone = [0x%x]\n",
drvState->ctrlPtr->ipsDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" poolAddr = [0x%x]\n",
drvState->ctrlPtr->poolAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" poolConfigured = [0x%x]\n",
drvState->ctrlPtr->poolConfigured) ;
TRC_1PRINT (TRC_LEVEL4,
" poolDspInitDone = [0x%x]\n",
drvState->ctrlPtr->poolDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" mpcsAddr = [0x%x]\n",
drvState->ctrlPtr->mpcsAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" mpcsConfigured = [0x%x]\n",
drvState->ctrlPtr->mpcsConfigured) ;
TRC_1PRINT (TRC_LEVEL4,
" mpcsDspInitDone = [0x%x]\n",
drvState->ctrlPtr->mpcsDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" mplistAddr = [0x%x]\n",
drvState->ctrlPtr->mplistAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" mplistConfigured = [0x%x]\n",
drvState->ctrlPtr->mplistConfigured) ;
TRC_1PRINT (TRC_LEVEL4,
" mplistDspInitDone = [0x%x]\n",
drvState->ctrlPtr->mplistDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" mqtAddr = [0x%x]\n",
drvState->ctrlPtr->mqtAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" mqtConfigured = [0x%x]\n",
drvState->ctrlPtr->mqtConfigured) ;
TRC_1PRINT (TRC_LEVEL4,
" mqtDspInitDone = [0x%x]\n",
drvState->ctrlPtr->mqtDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" dataAddr = [0x%x]\n",
drvState->ctrlPtr->dataAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" dataConfigured = [0x%x]\n",
drvState->ctrlPtr->dataConfigured) ;
TRC_1PRINT (TRC_LEVEL4,
" dataDspInitDone = [0x%x]\n",
drvState->ctrlPtr->dataDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" ringIoAddr = [0x%x]\n",
drvState->ctrlPtr->ringIoAddr) ;
TRC_1PRINT (TRC_LEVEL4,
" ringIoConfigured = [0x%x]\n",
drvState->ctrlPtr->ringIoConfigured) ;
TRC_1PRINT (TRC_LEVEL4,
" ringIoDspInitDone = [0x%x]\n",
drvState->ctrlPtr->ringIoDspInitDone) ;
TRC_1PRINT (TRC_LEVEL4,
" config.numIpsEntries = [0x%x]\n",
drvState->ctrlPtr->config.numIpsEntries) ;
TRC_1PRINT (TRC_LEVEL4,
" config.numPools = [0x%x]\n",
drvState->ctrlPtr->config.numPools) ;
TRC_1PRINT (TRC_LEVEL4,
" config.numDataDrivers = [0x%x]\n",
drvState->ctrlPtr->config.numDataDrivers) ;
/* --------------------------------------------------------------------
* Call the debug function for the specific link driver.
* --------------------------------------------------------------------
*/
TRC_2PRINT (TRC_LEVEL4,
"Platform-specifc Link driver information for DSP ID %d"
" Link driver ID %d:\n",
dspId,
drvState->linkDrvId) ;
drvState->interface->debug (dspId, drvState->linkDrvId) ;
}
else {
TRC_1PRINT (TRC_LEVEL4,
"LDRV_DRV component for DSP ID %d is not initialized.\n",
dspId) ;
}
TRC_0LEAVE ("LDRV_DRV_debug") ;
}
/** ============================================================================
* @func LDRV_getLinkDspCfg
*
* @desc Gets the pointer to kernel configuration structure after creating
* it (if required). Copies only DSP structures.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
LDRV_getLinkDspCfg (IN ProcessorId procId,
IN LINKCFG_DspConfig * dspCfg,
OUT LINKCFG_Object * knlLinkCfg)
{
DSP_STATUS status = DSP_SOK ;
LINKCFG_DspConfig * knlDspCfg = NULL ;
LINKCFG_Dsp * dspObject = NULL ;
#if !(defined (ONLY_PROC_COMPONENT))
LINKCFG_LinkDrv * linkDrvObject = NULL ;
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
Void * tmpUsrPtr ;
Void * tmpKnlPtr ;
Uint32 size ;
Uint32 tableId ;
TRC_3ENTER ("LDRV_getLinkDspCfg",procId, dspCfg, knlLinkCfg) ;
DBC_Require (knlLinkCfg != NULL) ;
DBC_Require (IS_VALID_PROCID (procId)) ;
if (DSP_SUCCEEDED (status)) {
size = sizeof (LINKCFG_DspConfig) ;
/* Allocate memory for the DSP object. */
status = MEM_Alloc ((Void **) &(tmpKnlPtr),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *) tmpKnlPtr,
(void *) dspCfg,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
knlLinkCfg->dspConfigs [procId] = tmpKnlPtr ;
knlDspCfg = tmpKnlPtr ;
}
}
else {
SET_FAILURE_REASON ;
}
}
/* ------------------------------------------------------------------------
* Allocate memory required for the DSP and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = knlDspCfg->dspObject ;
size = sizeof (LINKCFG_Dsp) ;
/* Allocate memory for the DSP object. */
status = MEM_Alloc ((Void **) &(knlDspCfg->dspObject),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *) knlDspCfg->dspObject,
(void *) tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
dspObject = knlDspCfg->dspObject ;
}
}
else {
SET_FAILURE_REASON ;
}
}
/* ------------------------------------------------------------------------
* Allocate memory required for the Link driver object array and initialize
* it.
* ------------------------------------------------------------------------
*/
#if !(defined (ONLY_PROC_COMPONENT))
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->linkDrvObjects ;
size = sizeof (LINKCFG_LinkDrv) * knlDspCfg->numDrvs ;
/* Allocate memory for the Link Driver object array. */
status = MEM_Alloc ((Void **) &(knlDspCfg->linkDrvObjects),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->linkDrvObjects),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
linkDrvObject =
&knlDspCfg->linkDrvObjects [dspObject->linkDrvId] ;
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
/* ------------------------------------------------------------------------
* Allocate memory required for the array of memory tables and initialize
* it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->memTables ;
size = sizeof (LINKCFG_MemEntry *) * knlDspCfg->numMemTables ;
/* Allocate memory for the array of pointers to memory tables. */
status = MEM_Calloc ((Void **) &(knlDspCfg->memTables),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the array of pointers from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->memTables),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
tableId = knlDspCfg->dspObject->memTableId ;
tmpUsrPtr = (Void *) knlDspCfg->memTables [tableId] ;
size = sizeof (LINKCFG_MemEntry)
* knlDspCfg->dspObject->memEntries ;
/* Allocate memory for the memory table. */
status = MEM_Alloc ((Void **)
&(knlDspCfg->memTables [tableId]),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser (
(Void *) (knlDspCfg->memTables [tableId]),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
}
else {
SET_FAILURE_REASON ;
}
}
#if !(defined (ONLY_PROC_COMPONENT))
/* ------------------------------------------------------------------------
* Allocate memory required for the array of IPS tables and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->ipsTables ;
size = sizeof (LINKCFG_Ips *) * knlDspCfg->numIpsTables ;
/* Allocate memory for the array of pointers to IPS tables. */
status = MEM_Calloc ((Void **) &(knlDspCfg->ipsTables),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the array of pointers from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->ipsTables),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
tableId = linkDrvObject->ipsTableId;
tmpUsrPtr = (Void *) knlDspCfg->ipsTables [tableId] ;
size = sizeof (LINKCFG_Ips) * linkDrvObject->numIpsEntries ;
/* Allocate memory for the IPS table. */
status = MEM_Alloc ((Void **)
&(knlDspCfg->ipsTables [tableId]),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *)
(knlDspCfg->ipsTables [tableId]),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
}
}
else {
SET_FAILURE_REASON ;
}
}
#if defined (POOL_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the array of Pool tables and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->poolTables ;
size = sizeof (LINKCFG_Pool *) * knlDspCfg->numPoolTables ;
/* Allocate memory for the array of pointers to Pool tables. */
status = MEM_Calloc ((Void **) &(knlDspCfg->poolTables),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the array of pointers from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->poolTables),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
tableId = linkDrvObject->poolTableId ;
tmpUsrPtr = (Void *) knlDspCfg->poolTables [tableId] ;
size = sizeof (LINKCFG_Pool) * linkDrvObject->numPools ;
/* Allocate memory for the Pool table. */
status = MEM_Alloc ((Void **)
&(knlDspCfg->poolTables [tableId]),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser (
(Void *) (knlDspCfg->poolTables [tableId]),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (POOL_COMPONENT) */
#if defined (CHNL_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the array of Data driver tables and
* initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->dataTables ;
size = sizeof (LINKCFG_DataDrv *) * knlDspCfg->numDataTables ;
/* Allocate memory for the array of pointers to Data driver tables. */
status = MEM_Calloc ((Void **) &(knlDspCfg->dataTables),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the array of pointers from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->dataTables),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
else {
tableId = linkDrvObject->dataTableId ;
tmpUsrPtr = (Void *) knlDspCfg->dataTables [tableId] ;
size = sizeof (LINKCFG_DataDrv)
* linkDrvObject->numDataDrivers ;
/* Allocate memory for the Data driver table. */
status = MEM_Alloc ((Void **)
&(knlDspCfg->dataTables [tableId]),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser (
(Void *) (knlDspCfg->dataTables [tableId]),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (CHNL_COMPONENT) */
#if defined (MSGQ_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the MQT object array and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->mqtObjects ;
size = sizeof (LINKCFG_Mqt) * knlDspCfg->numMqts ;
/* Allocate memory for the MQT object array. */
status = MEM_Alloc ((Void **) &(knlDspCfg->mqtObjects),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->mqtObjects),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MSGQ_COMPONENT) */
#if defined (RINGIO_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the RingIO object array and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->ringIoObjects ;
size = sizeof (LINKCFG_RingIo) * knlDspCfg->numRingIo ;
/* Allocate memory for the RingIO object array. */
status = MEM_Alloc ((Void **) &(knlDspCfg->ringIoObjects),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *)(knlDspCfg->ringIoObjects),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (RINGIO_COMPONENT) */
#if defined (MPLIST_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the MPLIST object array and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->mplistObjects ;
size = sizeof (LINKCFG_MpList) * knlDspCfg->numMpList ;
/* Allocate memory for the MPLIST object array. */
status = MEM_Alloc ((Void **) &(knlDspCfg->mplistObjects),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *)(knlDspCfg->mplistObjects),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MPLIST_COMPONENT) */
#if defined (MPCS_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the MPCS object array and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->mpcsObjects ;
size = sizeof (LINKCFG_Mpcs) * knlDspCfg->numMpcs ;
/* Allocate memory for the MPCS object array. */
status = MEM_Alloc ((Void **) &(knlDspCfg->mpcsObjects),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the objects from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->mpcsObjects),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (MPCS_COMPONENT) */
#if defined (LOG_COMPONENT)
/* ------------------------------------------------------------------------
* Allocate memory required for the LOG object and initialize it.
* ------------------------------------------------------------------------
*/
if (DSP_SUCCEEDED (status)) {
tmpUsrPtr = (Void *) knlDspCfg->logObject ;
size = sizeof (LINKCFG_Log) ;
/* Allocate memory for the GPP object. */
status = MEM_Alloc ((Void **) &(knlDspCfg->logObject),
size,
MEM_DEFAULT) ;
if (DSP_SUCCEEDED (status)) {
/* Copy the contents of the object from user-space. */
status = USER_copyFromUser ((Void *) (knlDspCfg->logObject),
tmpUsrPtr,
size) ;
if (DSP_FAILED (status)) {
SET_FAILURE_REASON ;
}
}
else {
SET_FAILURE_REASON ;
}
}
#endif /* if defined (LOG_COMPONENT) */
#endif /* if !(defined (ONLY_PROC_COMPONENT)) */
if (DSP_FAILED (status)) {
LDRV_freeLinkDspCfg (procId, knlLinkCfg) ;
}
TRC_1LEAVE ("LDRV_getLinkDspCfg", status) ;
return status ;
}
/*!
* @brief Function to create an instance of this PwrMgr.
*
* @param procId Processor ID addressed by this PwrMgr instance.
* @param params Configuration parameters.
*
* @sa DM8168DUCATIPWR_delete
*/
DM8168DUCATIPWR_Handle
DM8168DUCATIPWR_create ( UInt16 procId,
const DM8168DUCATIPWR_Params * params)
{
Int status = PWRMGR_SUCCESS;
PwrMgr_Object * handle = NULL;
IArg key;
GT_2trace (curTrace, GT_ENTER, "DM8168DUCATIPWR_create", procId, params);
GT_assert (curTrace, IS_VALID_PROCID (procId));
GT_assert (curTrace, (params != NULL));
GT_assert (curTrace, (DM8168DUCATIPWR_state.refCount != 0));
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
if (DM8168DUCATIPWR_state.refCount == 0) {
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_create",
DM8168DUCATIPWR_E_INVALIDSTATE,
"Module was not initialized!");
}
else if (!IS_VALID_PROCID (procId)) {
/* Not setting status here since this function does not return status.*/
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_create",
PWRMGR_E_INVALIDARG,
"Invalid procId specified");
}
else if (params == NULL) {
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_create",
PWRMGR_E_INVALIDARG,
"params passed is null!");
}
else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
/* Enter critical section protection. */
key = IGateProvider_enter (DM8168DUCATIPWR_state.gateHandle);
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
/* Check if the PwrMgr already exists for specified procId. */
if (DM8168DUCATIPWR_state.pwrHandles [procId] != NULL) {
status = PWRMGR_E_ALREADYEXIST;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_create",
status,
"PwrMgr already exists for specified procId!");
}
else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
/* Allocate memory for the handle */
handle = (PwrMgr_Object *) Memory_calloc (NULL,
sizeof (PwrMgr_Object),
0,
NULL);
if (handle == NULL) {
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_create",
PWRMGR_E_MEMORY,
"Memory allocation failed for handle!");
}
else {
/* Populate the handle fields */
handle->pwrFxnTable.attach = &DM8168DUCATIPWR_attach;
handle->pwrFxnTable.detach = &DM8168DUCATIPWR_detach;
handle->pwrFxnTable.on = &DM8168DUCATIPWR_on;
handle->pwrFxnTable.off = &DM8168DUCATIPWR_off;
/* TBD: Other functions */
/* Allocate memory for the DM8168DUCATIPWR handle */
handle->object = Memory_calloc (NULL,
sizeof (DM8168DUCATIPWR_Object),
0,
NULL);
if (handle == NULL) {
status = PWRMGR_E_MEMORY;
GT_setFailureReason (curTrace,
GT_4CLASS,
"DM8168DUCATIPWR_create",
status,
"Memory allocation failed for handle!");
}
else {
#if defined (SYSLINK_BUILDOS_LINUX)
((DM8168DUCATIPWR_Object *)handle->object)->clockHandle
= (ClockOps_Handle) LinuxClock_create();
#endif/* #if defined (SYSLINK_BUILDOS_LINUX) */
#if defined (SYSLINK_BUILD_RTOS)
((DM8168DUCATIPWR_Object *)handle->object)->clockHandle
= (ClockOps_Handle) DM8168CLOCK_create();
#endif/* #if defined (SYSLINK_BUILD_RTOS) */
handle->procId = procId;
DM8168DUCATIPWR_state.pwrHandles [procId] =
(DM8168DUCATIPWR_Handle) handle;
}
}
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
}
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
/* Leave critical section protection. */
IGateProvider_leave (DM8168DUCATIPWR_state.gateHandle, key);
#if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS)
}
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) && defined (SYSLINK_BUILD_HLOS) */
if (status < 0) {
if (handle != NULL) {
if (handle->object != NULL) {
Memory_free (NULL, handle->object, sizeof (DM8168DUCATIPWR_Object));
}
Memory_free (NULL, handle, sizeof (PwrMgr_Object));
}
/*! @retval NULL Function failed */
handle = NULL;
}
GT_1trace (curTrace, GT_LEAVE, "DM8168DUCATIPWR_create", handle);
/*! @retval Valid-Handle Operation successful */
return (DM8168DUCATIPWR_Handle) handle;
}
