C++ GT_1trace函数代码示例

/*!
 *  @brief      Function to enter a Gate Spinlock.
 *
 *  @param      handle  Handle to previously created gate Spinlock instance.
 *
 *  @sa         GateSpinlock_leave
 */
UInt32
GateSpinlock_enter (GateSpinlock_Handle handle)
{
    UInt32 key = 0x0;

    GT_1trace (curTrace, GT_ENTER, "GateSpinlock_enter", handle);

    GT_assert (curTrace, (handle != NULL));

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (handle == NULL) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "GateSpinlock_enter",
                             GateSpinlock_E_INVALIDARG,
                             "Handle passed is invalid!");
    }
    else {
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
        key = OsalSpinlock_enter ((OsalSpinlock_Handle) handle->sHandle);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE, "GateSpinlock_enter", key);

    /*! @retval Flags Operation successful */
    return key;
}

/*!
 *  @brief      Closes the handle corresponding to an event. It also frees the
 *              resources allocated, if any, during call to OpenEvent ()
 *
 *  @param      allocated event object handle.
 *  @sa         OsalEvent_delete
 */
Int OsalEvent_delete (OsalEvent_Handle handle)
{
    Int status = OSALEVENT_SUCCESS ;
    OsalEvent_Object* event = (OsalEvent_Object*) handle;

    GT_1trace (curTrace, GT_ENTER,"OsalEvent_close",event );
    GT_assert (curTrace, (NULL != event) );

    status = OsalSpinlock_delete (&(event->lock));
    if (status >= 0)
    {
        event->signature = 0;
    }
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    else {
        status = OSALEVENT_E_SPINLOCK;
        GT_setFailureReason(curTrace, GT_4CLASS,
                            "OsalEvent_close",OSALEVENT_E_SPINLOCK,
                            "SpinLock Delete failed");
    }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE,"Event_Close",status );

    /*[email protected] OSALEVENT_SUCCESS if call succeeded.*/
    /*[email protected] OSALEVENT_E_SPINLOCK when SpinLock operation fails.*/
    return status;
}

/*!
 *  ======== NotifyCircSetup_sharedMemReq ========
 *  Return the amount of shared memory required
 */
SizeT
NotifyCircSetupDm8168_sharedMemReq (UInt16 remoteProcId, Ptr sharedAddr)
{
    SizeT                  memReq = 0x0;
    NotifyDriverCirc_Params params;

    GT_1trace (curTrace, GT_ENTER, "NotifyCircSetupDm8168_sharedMemReq",
               sharedAddr);

    GT_assert (curTrace, (sharedAddr != NULL));

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (sharedAddr == NULL) {
        /*! @retval  0 Invalid NULL sharedAddr argument provided. */
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "NotifyCircSetupDm8168_sharedMemReq",
                             Notify_E_INVALIDARG,
                             "Invalid NULL sharedAddr provided.");
    }
    else {
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
        NotifyDriverCirc_Params_init (&params);
        params.sharedAddr = sharedAddr;

        memReq = NotifyDriverCirc_sharedMemReq (&params);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE, "NotifyCircSetupDm8168_sharedMemReq", memReq);

    /*! @retval Shared-Memory-Requirements Operation successful */
    return (memReq);
}

/*
 *  ======== DBLL_unload ========
 */
void DBLL_unload(struct DBLL_LibraryObj *lib, struct DBLL_Attrs *attrs)
{
	struct DBLL_LibraryObj *zlLib = (struct DBLL_LibraryObj *)lib;
	s32 err = 0;

	DBC_Require(cRefs > 0);
	DBC_Require(MEM_IsValidHandle(zlLib, DBLL_LIBSIGNATURE));
	DBC_Require(zlLib->loadRef > 0);
	GT_1trace(DBLL_debugMask, GT_ENTER, "DBLL_unload: lib: 0x%x\n", lib);
	zlLib->loadRef--;
	/* Unload only if reference count is 0 */
	if (zlLib->loadRef != 0)
		goto func_end;

	zlLib->pTarget->attrs = *attrs;
	if (zlLib->mHandle) {
		err = Dynamic_Unload_Module(zlLib->mHandle,
			&zlLib->symbol.dlSymbol,
			&zlLib->allocate.dlAlloc, &zlLib->init.dlInit);
		if (err != 0) {
			GT_1trace(DBLL_debugMask, GT_5CLASS,
				 "Dynamic_Unload_Module failed: 0x%x\n", err);
		}
	}
	/* remove symbols from symbol table */
	if (zlLib->symTab != NULL) {
		GH_delete(zlLib->symTab);
		zlLib->symTab = NULL;
	}
	/* delete DOFF desc since it holds *lots* of host OS
	 * resources */
	dofClose(zlLib);
func_end:
	DBC_Ensure(zlLib->loadRef >= 0);
}

/*!
 *  @brief      Begin protection of code through spin lock with all ISRs
 *              disabled. Calling this API protects critical regions of code
 *              from preemption by tasks, DPCs and all interrupts.
 *
 *  @param      lockHandle   Spinlock object handle to be acquired.
 *
 *  @sa         OsalSpinlock_leave
 */
UInt32
OsalSpinlock_enter (OsalSpinlock_Handle lockHandle)
{
    UInt32 flags = 0;

    OsalSpinlock_Object * lockObject = (OsalSpinlock_Object*) lockHandle;

    GT_1trace (curTrace, GT_ENTER, "OsalSpinlock_enter", lockHandle);

    GT_assert (curTrace, (lockHandle != NULL));

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (lockHandle == NULL) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "OsalSpinlock_enter",
                             OSALSPINLOCK_E_HANDLE,
                             "NULL spinlock handle provided.");
    }
    else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
        spin_lock (&(lockObject->lock));
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE, "OsalSpinlock_enter", flags);

    /*! @retval Flags Flags to be provided to corresponding leave call. */
    return flags;
}

/*!
 *  @brief      Remove and delete entry from the Translation Table
 *
 *  @param      da      Device address
 *
 *  @sa         _SysLinkMemUtils_insertMapElement
 */
static Ptr
_SysLinkMemUtils_removeMapElement (Ptr da)
{
    AddrNode  * node;
    Ptr         addr = NULL;

    GT_1trace (curTrace, GT_ENTER, "_SysLinkMemUtils_removeMapElement", da);

    OsalSemaphore_pend (SysLinkMemUtils_module->semList,
                        OSALSEMAPHORE_WAIT_FOREVER);
    node = _SysLinkMemUtils_findNode (da);
    if (!node || node->da != da) {
#if !defined(SYSLINK_BUILD_OPTIMIZE)
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             (Char *)__func__,
                             PROCMGR_E_FAIL,
                             "Entry not found!");
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
    }
    else {
        addr = node->ua;
        List_remove (SysLinkMemUtils_module->addrTable, &node->elem);
        Memory_free (NULL, node, sizeof (AddrNode));
    }
    OsalSemaphore_post (SysLinkMemUtils_module->semList);

    GT_1trace (curTrace, GT_LEAVE, "_SysLinkMemUtils_removeMapElement", addr);

    return addr;
}

/*!
 *  @brief      Get a valid A9 address from a remote proc address
 *
 *              This function  can be called by an app running
 *              in A9 to access a buffer allocated from remote processor.
 *
 *  @param      da      Device address
 *
 *  @sa         SysLinkMemUtils_alloc, SysLinkMemUtils_free
 */
Ptr
SysLinkMemUtils_DAtoVA (Ptr da)
{
    AddrNode  * node;
    Ptr         addr = NULL;

    GT_1trace (curTrace, GT_ENTER, "SysLinkMemUtils_DAtoVA", da);

#if 1
    /* SysLinkMemUtils_DAtoVA() is now a stub that always      */
    /* returns NULL.  It is necessary to disable this function */
    /* due to the changes to the block lookup that breaks its  */
    /* functionality.                                          */
    (Void)node;
    (Void)da;
    GT_setFailureReason (curTrace,
                         GT_4CLASS,
                         (Char *)__func__,
                         -1,
                         "SysLinkMemUtils_DAtoVA() is unavailable.");
#else
    OsalSemaphore_pend (SysLinkMemUtils_module->semList,
                        OSALSEMAPHORE_WAIT_FOREVER);
    node = _SysLinkMemUtils_findNode (da);
    OsalSemaphore_post (SysLinkMemUtils_module->semList);
    if (node) {
        addr = node->ua + (da - node->da);
    }
#endif

    GT_1trace (curTrace, GT_LEAVE, "SysLinkMemUtils_DAtoVA", addr);

    return addr;
}

/*
 * ======== OsalKfile_tell ========
 */
UInt32
OsalKfile_tell (OsalKfile_Handle fileHandle)
{
    OsalKfile_Object *  fileObject  = NULL;
    UInt32              posValue    = 0u;

    GT_1trace (curTrace, GT_ENTER, "OsalKfile_tell", fileHandle);

    GT_assert (curTrace, (fileHandle != NULL));

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (fileHandle == NULL) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "OsalKfile_seek",
                             OSALKFILE_E_INVALIDARG,
                             "NULL provided for argument fileHandle");
    }
    else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
        fileObject = (OsalKfile_Object*) fileHandle;

        posValue = fileObject->curPos;

        GT_assert (GT_1CLASS, (posValue == fileObject->fileDesc->f_pos));
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace(curTrace, GT_LEAVE,"OsalKfile_tell",posValue );

    /* !< @retval File-position Current file pointer position in file.*/
    return posValue;
}

Int32 decodeReclaim(AUDDEC1_Handle dec, int in, int out)
{
    Int32 status;

    GT_4trace(curMask, GT_1CLASS, "App-> inBuf[%d]=%#x, outBuf[%d]=%#x\n",
              in, encodedBufDesc[in].descs[0].buf,
              out, outBufDesc[out].descs[0].buf);

    status = AUDDEC1_processWait(dec, &encodedBufDesc[in],
                                 &outBufDesc[out],
                                 &decInArgs[in],
                                 &decOutArgs[out],
                                 AUDDEC1_FOREVER);

#ifdef CACHE_ENABLED
    /* Writeback the outBuf. */
    Memory_cacheWb(outBuf[out], OFRAMESIZE);
#endif

    GT_1trace(curMask, GT_2CLASS,
              "App-> Decoder processWait returned 0x%x\n", status);
    if (status != AUDDEC1_EOK) {
        GT_1trace(curMask, GT_7CLASS,
                  "App-> Decoder processing FAILED, extendedError = 0x%x\n",
                  decOutArgs[out].extendedError);
    }

    return status;
}

/*!
 *  @brief      Interrupt Service Routine for Dm8168IpcInt module
 *
 *  @param      arg     Optional argument to the function.
 *
 *  @sa         _Dm8168IpcInt_checkAndClearFunc
 */
static
Bool
_Dm8168IpcInt_isr (Ptr ref)
{
    UInt16 i = 0;
    GT_1trace (curTrace, GT_ENTER, "_Dm8168IpcInt_isr", ref);

    for (i = 0 ; i < Dm8168IpcInt_state.maxProcessors ; i++) {
        while (Atomic_read (&(Dm8168IpcInt_state.isrObjects [i].asserted)) != 0) {
#if defined  (SYSLINK_INT_LOGGING)
            SysLogging_intCount++;
#endif /* if defined  (SYSLINK_INT_LOGGING) */
            /* Ensure that the ISR for this proc ID is still installed. */
            if (Dm8168IpcInt_state.isrObjects [i].fxn != NULL) {
                Dm8168IpcInt_state.isrObjects [i].fxn (
                                    Dm8168IpcInt_state.isrObjects [i].fxnArgs);
            }
            Atomic_dec_return (&(Dm8168IpcInt_state.isrObjects [i].asserted));
        }
    }

    GT_1trace (curTrace, GT_LEAVE, "_Dm8168IpcInt_isr", TRUE);

    /*! @retval TRUE Interrupt has been handled. */
    return (TRUE);
}

/*!
 *  @brief      Function to finalize the HAL object
 *
 *  @param      halObj      Pointer to the HAL object
 *
 *  @sa         OMAPL1XX_halInit
 *              OMAPL1XX_phyShmemExit
 */
Int
OMAPL1XX_halExit (Ptr halObj)
{
    Int                  status    = PROCESSOR_SUCCESS;
    OMAPL1XX_HalObject * halObject = NULL;

    GT_1trace (curTrace, GT_ENTER, "OMAPL1XX_halExit", halObj);

    GT_assert (curTrace, (halObj != NULL));

    halObject = (OMAPL1XX_HalObject *) halObj ;
    status = OMAPL1XX_phyShmemExit (halObj);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (status < 0) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "OMAPL1XX_halExit",
                             status,
                             "OMAPL1XX_phyShmemExit failed!");
    }
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */

    if (halObj != NULL) {
        /* Free the memory for the HAL object. */
        Memory_free (NULL, halObj, sizeof (OMAPL1XX_HalObject));
    }

    GT_1trace (curTrace, GT_LEAVE, "OMAPL1XX_halExit", status);

    /*! @retval PROCESSOR_SUCCESS Operation successful */
    return status;
}

/*
 *  ======== DMM_DeleteTables ========
 *  Purpose:
 *      Delete DMM Tables.
 */
DSP_STATUS DMM_DeleteTables(struct DMM_OBJECT *hDmmMgr)
{
	struct DMM_OBJECT *pDmmObj = (struct DMM_OBJECT *)hDmmMgr;
	DSP_STATUS status = DSP_SOK;

	GT_1trace(DMM_debugMask, GT_ENTER,
		"Entered DMM_DeleteTables () hDmmMgr %x\n", hDmmMgr);
	DBC_Require(cRefs > 0);
	if (MEM_IsValidHandle(hDmmMgr, DMMSIGNATURE)) {
		/* Delete all DMM tables */
		SYNC_EnterCS(pDmmObj->hDmmLock);

		if (pVirtualMappingTable != NULL)
			MEM_Free(pVirtualMappingTable);

		if (pPhysicalAddrTable != NULL)
			MEM_Free(pPhysicalAddrTable);

		SYNC_LeaveCS(pDmmObj->hDmmLock);
	} else
		status = DSP_EHANDLE;
	GT_1trace(DMM_debugMask, GT_4CLASS,
		"Leaving DMM_DeleteTables status %x\n", status);
	return status;
}

/*!
 *  @brief      Acquire/lock the Mutex object.
 *
 *              This function acquires the critical section identified by this
 *              mutex handle. Once this function is successfully entered,
 *              further calls to OsalMutex_enter shall block till the critical
 *              section has been released by the caller.
 *
 *  @param      mutexHandle   Mutex object handle to be acquired.
 *
 *  @sa         OsalMutex_leave
 */
IArg
OsalMutex_enter (OsalMutex_Handle mutexHandle)
{
    IArg                retVal      = 0;
    OsalMutex_Object *  mutexObj    = (OsalMutex_Object*) mutexHandle;
    Int                 ret         = 0;

    GT_1trace (curTrace, GT_ENTER, "OsalMutex_enter", mutexHandle);

    GT_assert (curTrace, (mutexHandle != NULL));

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (mutexHandle == NULL) {
        /* Function does not return status. */
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "OsalMutex_enter",
                             OSALMUTEX_E_HANDLE,
                             "NULL Mutex handle provided.");
    }
    else {
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */
        ret = pthread_mutex_lock (&(mutexObj->lock));
        GT_assert (curTrace, (ret == 0));
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /* #if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE, "OsalMutex_enter", retVal);

    /*! @retval 0 Operation successfully completed. */
    return retVal;
}

/*!
 *  @brief  Function to close the Notify driver.
 *
 *  @param  deleteThread  Flag to indicate whether to delete thread or not.
 *
 *  @sa     NotifyDrvUsr_open
 */
Int
NotifyDrvUsr_close (Bool deleteThread)
{
    Int    status      = Notify_S_SUCCESS;

    GT_1trace (curTrace, GT_ENTER, "NotifyDrvUsr_close", deleteThread);

    /* TBD: Protection for refCount. */
    if (NotifyDrvUsr_refCount == 1) {
        if (deleteThread == TRUE) {
        	Notify_CmdArgsThreadDetach detachParams;
            detachParams.pid = getpid ();
            status = NotifyDrvUsr_ioctl (CMD_NOTIFY_THREADDETACH, &detachParams);
            if (status < 0) {
                GT_setFailureReason (curTrace,
                                     GT_4CLASS,
                                     "NotifyDrvUsr_close",
                                     status,
                                     "Notify detach failed on kernel side!");
            }

            pthread_join (NotifyDrv_workerThread, NULL);
        }
        NotifyDrvUsr_refCount--;
    }
    else {
        NotifyDrvUsr_refCount--;
    }

    GT_1trace (curTrace, GT_LEAVE, "NotifyDrvUsr_close", status);

    return status;
}

/*!
 *  @brief      Function to enter a Gate Mutex.
 *
 *  @param      gmHandle  Handle to previously created gate mutex instance.
 *
 *  @sa         GateMutex_leave
 */
IArg
GateMutex_enter (GateMutex_Handle gmHandle)
{
    IArg   key = 0x0;

    GT_1trace (curTrace, GT_ENTER, "GateMutex_enter", gmHandle);

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (gmHandle == NULL) {
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "GateMutex_enter",
                             GateMutex_E_INVALIDARG,
                             "Handle passed is invalid!");
    }
    else {
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */
        key = OsalMutex_enter ((OsalMutex_Handle) gmHandle->mHandle);
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */

    GT_1trace (curTrace, GT_LEAVE, "GateMutex_enter", key);

    /*! @retval Flags Operation successful */
    return key;
}