/*!
 *  @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;
}

/*
 * @brief Function to find out the number of frame buffers in a frame .
 *
 * @param buf      frame.
 */
UInt32
FrameQ_getNumFrameBuffers (FrameQ_Frame frame )
{
    UInt32 numbufs = 0 ;

    GT_1trace (curTrace,
               GT_ENTER,
               "FrameQ_getNumFrameBuffers",
               frame);

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

#if !defined(SYSLINK_BUILD_OPTIMIZE)
    if (frame == NULL) {
        /*! @retval 0  frame passed is null
         */
        GT_setFailureReason (curTrace,
                             GT_4CLASS,
                             "FrameQ_getNumFrameBuffers",
                             FrameQ_E_INVALIDARG,
                             "frame passed is null !");
    }
    else {
#endif /*#if !defined(SYSLINK_BUILD_OPTIMIZE)*/
        numbufs = frame->numFrameBuffers;
#if !defined(SYSLINK_BUILD_OPTIMIZE)
    }
#endif /*#if !defined(SYSLINK_BUILD_OPTIMIZE)*/

    GT_1trace (curTrace, GT_LEAVE, "FrameQ_getNumFrameBuffers",numbufs);

    /*! @retval number of frame buffers*/
    return (numbufs) ;
}

Int32 encodeReclaim(AUDENC1_Handle enc, int in, int out)
{
    Int32 status;

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

    status = AUDENC1_processWait(enc, &inBufDesc[in],
                                 &encodedBufDesc[out],
                                 &encInArgs[in],
                                 &encOutArgs[out],
                                 AUDENC1_FOREVER);

#ifdef CACHE_ENABLED
    /*
     * Since encodedBuf is an inBuf to the next process call, we
     * must invalidate it, to clean buffer lines.
     */
    Memory_cacheWbInv(encodedBuf[out], EFRAMESIZE);
#endif

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

    return status;
}

/*
 *  ======== DPC_Schedule ========
 *  Purpose:
 *      Schedule a deferred procedure call to be executed at a later time.
 *      Latency and order of DPC execution is platform specific.
 */
DSP_STATUS DPC_Schedule(struct DPC_OBJECT *hDPC)
{
	DSP_STATUS status = DSP_SOK;
	struct DPC_OBJECT *pDPCObject = (struct DPC_OBJECT *)hDPC;
	unsigned long flags;

	GT_1trace(DPC_DebugMask, GT_ENTER, "DPC_Schedule hDPC %x\n", hDPC);
	if (MEM_IsValidHandle(hDPC, SIGNATURE)) {
		/* Increment count of DPC's pending. Needs to be protected
		 * from ISRs since this function is called from process
		 * context also. */
		spin_lock_irqsave(&hDPC->dpc_lock, flags);
		pDPCObject->numRequested++;
		spin_unlock_irqrestore(&hDPC->dpc_lock, flags);
		tasklet_schedule(&(hDPC->dpc_tasklet));
#ifdef DEBUG
		if (pDPCObject->numRequested > pDPCObject->numScheduled +
						pDPCObject->numRequestedMax) {
			pDPCObject->numRequestedMax = pDPCObject->numRequested -
						pDPCObject->numScheduled;
		}
#endif
	/*  If an interrupt occurs between incrementing numRequested and the
	 *  assertion below, then DPC will get executed while returning from
	 *  ISR, which will complete all requests and make numRequested equal
	 * to numScheduled, firing this assertion. This happens only when
	 * DPC is being scheduled in process context */
	} else {
		GT_0trace(DPC_DebugMask, GT_6CLASS,
			  "DPC_Schedule: DSP_EHANDLE\n");
		status = DSP_EHANDLE;
	}
	GT_1trace(DPC_DebugMask, GT_ENTER, "DPC_Schedule status %x\n", status);
	return status;
}

/*
 *  ======== SemMP_post ========
 */
Void SemMP_post(SemMP_Handle sem)
{
    GT_1trace(curTrace, GT_ENTER, "Entered SemMP_post> sem[0x%x]\n", sem);

        ReleaseSemaphore(sem->id, 1, NULL);

    GT_1trace(curTrace, GT_ENTER, "Leaving SemMP_post> sem[0x%x]\n", sem);
}

/* ARGSUSED - this line tells the compiler not to warn about unused args. */
IRES_Handle IRES_ADDRSPACE_constructHandle(
        IRES_ProtocolArgs * resProtocolArgs,
        IALG_MemRec *memRecs,
        IRESMAN_ConstructArgs * constructHandleArgs,
        IRES_Status *status)
{
    IRES_ADDRSPACE_Handle handle = (IRES_ADDRSPACE_Handle)memRecs[0].base;

    IRESMAN_ADDRSPACE_ConstructHandleArgs * constructArgs =
        (IRESMAN_ADDRSPACE_ConstructHandleArgs *)constructHandleArgs;

    GT_3trace(ti_sdo_fc_ires_addrspace_GTMask, GT_ENTER,
            "_IRES_ADDRSPACE_constructHandle> Enter (resProtcolArgs=0x%x, "
            "memRecs=0x%x, constructHandleArgs=0x%x)\n", resProtocolArgs,
            memRecs, constructHandleArgs);

    GT_assert(ti_sdo_fc_ires_addrspace_GTMask, resProtocolArgs != NULL);
    GT_assert(ti_sdo_fc_ires_addrspace_GTMask, memRecs != NULL);
    GT_assert(ti_sdo_fc_ires_addrspace_GTMask, constructHandleArgs != NULL);
    GT_assert(ti_sdo_fc_ires_addrspace_GTMask, status != NULL);

    if (handle == NULL) {
        *status = IRES_ENORESOURCE;

        GT_0trace(ti_sdo_fc_ires_addrspace_GTMask, GT_7CLASS,
                "_IRES_ADDRSPACE_constructHandle> NULL handle passed in "
                "memRecs[0].base\n");

        GT_1trace(ti_sdo_fc_ires_addrspace_GTMask, GT_ENTER,
                "_IRES_ADDRSPACE_constructHandle> Exit (handle=0x%x, "
                "status=IRES_ENORESOURCE)\n", handle);

        return ((IRES_Handle) NULL);
    }

    handle->addr = constructArgs->addr ;

    handle->len = constructArgs->len ;
    ((IRES_ADDRSPACE_IntObj *)handle)->mapBase = constructArgs->mapBase;
    ((IRES_ADDRSPACE_IntObj *)handle)->mapLen = constructArgs->mapLen;

    ((IRES_ADDRSPACE_Handle)handle)->ires.getStaticProperties =
            IRES_ADDRSPACE_getStaticProperties;

    /*
     * Use the constructHandleargs to populate the ShadowPaRams with the
     * correct link
     */

    *status = IRES_OK;

    GT_1trace(ti_sdo_fc_ires_addrspace_GTMask, GT_ENTER,
            "_IRES_ADDRSPACE_constructHandle> Exit (handle=0x%x, "
            "status=IRES_OK)\n", handle);

    return ((IRES_Handle)handle);
}