/*
 * dspbridge/src/api/linux/DSPProcessor.c
 *
 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
 *
 * Copyright (C) 2007 Texas Instruments, Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation version 2.1 of the License.
 *
 * This program is distributed .as is. WITHOUT ANY WARRANTY of any kind,
 * whether express or implied; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 */


/*
 *  ======== DSPProcessor.c ========
 *  Description:
 *      This is the source for the DSP/BIOS Bridge API processor module. The
 *      parameters are validated at the API level, but the bulk of the
 *      work is done at the driver level through the PM PROC module.
 *
 *  Public Functions:
 *      DSPProcessor_Attach
 *      DSPProcessor_Detach
 *      DSPProcessor_EnumNodes
 *      DSPProcessor_FlushMemory
 *      DSPProcessor_GetResourceInfo
 *      DSPProcessor_GetState
 *      DSPProcessor_Map
 *      DSPProcessor_RegisterNotify
 *      DSPProcessor_ReserveMemory
 *      DSPProcessor_UnMap
 *      DSPProcessor_UnReserveMemory
 *      DSPProcessor_InvalidateMemory

 *! Revision History
 *! ================
 *! 04-Apr-2007 sh  Added DSPProcessor_InvalidateMemory
 *! 19-Apr-2004 sb  Aligned DMM definitions with Symbian
 *! 08-Mar-2004 sb  Added the Dynamic Memory Mapping APIs
 *! 27-Jun-2001 rr: DSPProcessor_RegisterNotify allows EventMask =0
 *!                 for De Registration.
 *! 16-Feb-2001 jeh Fixed message in DSPProcessor_Detach.
 *! 12-Dec-2000 rr: DSP_ProcessorEnumNodes returns DSP_ESIZE if
 *!                 uNodeTabSize is zero and valid aNodeTab.
 *! 29-Nov-2000 rr: Incorporated code review changes.
 *! 09-Nov-2000 rr: Code cleaned up. Use of IsValidEvent/Mask Macros.
 *! 28-Sep-2000 rr: Updated to version 0.9.
 *! 07-Sep-2000 jeh Changed type HANDLE in DSPProcessor_RegisterNotify to
 *!                 DSP_HNOTIFICATION.
 *! 07-Aug-2000 rr: Enum fxns do not return ESIZE if the size of the data
 *!                 structure is less than the actual size for backward
 *!                 compatibility.
 *! 04-Aug-2000 rr: DSPProcessor_Attach does not check for pAttrin for NULL.
 *!                 file name changed to DSPProcessor.c
 *! 27-Jul-2000 rr: Updated to 0.8 ver API. GetTrace Implemented.
 *! 10-Jul-2000 rr: Calls into DSP Trap for the bulk of the functionality.
 *! 12-May-2000 gp: Removed PROC_UNKNOWN state.  Mapped to return DSP_EFAIL.
 *!                 Return DSP_EHANDLE in DSPProcessor_Ctrl()/Detach().
 *!                 Return DSP_EWRONGSTATE from DSPProcessor_Start().
 *! 03-May-2000 rr: Uses SERVICES CSL fxns
 *! 19-Apr-2000 ww: Updated based on code review.
 *! 12-Apr-2000 ww: Created based on DirectDSP API specification, Version 0.6.
 *
 */

/*  ----------------------------------- Host OS */
#include <host_os.h>

/*  ----------------------------------- DSP/BIOS Bridge */
#include <dbdefs.h>
#include <errbase.h>

/*  ----------------------------------- Others */
#include <dsptrap.h>

#ifdef DEBUG_BRIDGE_PERF
#include <perfutils.h>
#endif
/*  ----------------------------------- This */
#include "_dbdebug.h"
#include "_dbpriv.h"
#include <DSPProcessor.h>

/*
 *  ======== DSPProcessor_Attach ========
 *  Purpose:
 *      Prepare for communication with a particular DSP processor, and
 *		return a handle to the processor object.
 */
DBAPI DSPProcessor_Attach(UINT uProcessor,
		    OPTIONAL CONST struct DSP_PROCESSORATTRIN *pAttrIn,
		    OUT DSP_HPROCESSOR *phProcessor)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;

	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("PROC: DSPProcessor_Attach\r\n")));
	if (!DSP_ValidWritePtr(phProcessor, sizeof(DSP_HPROCESSOR))) {
		if (uProcessor <= DSP_MAX_PROCESSOR) {
			tempStruct.ARGS_PROC_ATTACH.uProcessor = uProcessor;
			tempStruct.ARGS_PROC_ATTACH.pAttrIn =
				(struct DSP_PROCESSORATTRIN *)pAttrIn;
			tempStruct.ARGS_PROC_ATTACH.phProcessor = phProcessor;
			status = DSPTRAP_Trap(&tempStruct,
					CMD_PROC_ATTACH_OFFSET);
		} else {
			status = DSP_EINVALIDARG;
			DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: invalid processor number\r\n")));
		}
	} else {
		/* Invalid pointer */
		status = DSP_EPOINTER;
		DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: Invalid Pointer \r\n")));
	}

	return status;
}

/*
 *  ======== DSPProcessor_Detach ========
 *  Purpose:
 *      Close a DSP processor and de-allocate all (GPP) resources.
 */
DBAPI DSPProcessor_Detach(DSP_HPROCESSOR hProcessor)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;

	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("PROC: DSPProcessor_Detach\r\n")));
	/* Check the handle */
	if (hProcessor) {
		tempStruct.ARGS_PROC_DETACH.hProcessor = hProcessor;
		status = DSPTRAP_Trap(&tempStruct, CMD_PROC_DETACH_OFFSET);
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR,
			(TEXT("PROC: Invalid Handle \r\n")));
	}

	return status;
}

/*
 *  ======== DSPProcessor_EnumNodes ========
 *  Purpose:
 *      Enumerate and get configuration information about nodes allocated
 *      on a DSP processor.
 */
DBAPI DSPProcessor_EnumNodes(DSP_HPROCESSOR hProcessor,
		       IN DSP_HNODE *aNodeTab, IN UINT uNodeTabSize,
		       OUT UINT *puNumNodes, OUT UINT *puAllocated)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;

	DEBUGMSG(DSPAPI_ZONE_FUNCTION,
			(TEXT("PROC:DSPProcessor_EnumNodes\r\n")));

	/* Check the handle */
	if (hProcessor) {
		if (!DSP_ValidWritePtr(puNumNodes, sizeof(UINT)) &&
		    !DSP_ValidWritePtr(puAllocated, sizeof(UINT)) &&
			(uNodeTabSize && !DSP_ValidWritePtr(aNodeTab,
					(sizeof(DSP_HNODE)*uNodeTabSize)))) {
			tempStruct.ARGS_PROC_ENUMNODE_INFO.hProcessor =
						hProcessor;
			tempStruct.ARGS_PROC_ENUMNODE_INFO.aNodeTab = aNodeTab;
			tempStruct.ARGS_PROC_ENUMNODE_INFO.uNodeTabSize =
						uNodeTabSize;
			tempStruct.ARGS_PROC_ENUMNODE_INFO.puNumNodes =
						puNumNodes;
			tempStruct.ARGS_PROC_ENUMNODE_INFO.puAllocated =
						puAllocated;
			status = DSPTRAP_Trap(&tempStruct,
					CMD_PROC_ENUMNODE_OFFSET);
		} else {
			if (uNodeTabSize <= 0 &&
			    !DSP_ValidWritePtr(puNumNodes, sizeof(UINT)) &&
			    !DSP_ValidWritePtr(puAllocated, sizeof(UINT)) &&
			    !DSP_ValidWritePtr(aNodeTab, sizeof(DSP_HNODE)*1)) {
				status = DSP_ESIZE;
			} else
				status = DSP_EPOINTER;

			DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: "
					"pNodeInfo is invalid \r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: Invalid Handle \r\n")));
	}

	return status;
}

/*
 *  ======== DSPProcessor_FlushMemory ========
 *  Purpose:
 *      Flushes a buffer from the MPU data cache.
 */
DBAPI DSPProcessor_FlushMemory(DSP_HPROCESSOR hProcessor, PVOID pMpuAddr,
			 ULONG ulSize, ULONG ulFlags)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;
#ifdef DEBUG_BRIDGE_PERF
	struct timeval tv_beg;
	struct timeval tv_end;
	struct timezone tz;
	int timeRetVal = 0;

timeRetVal = getTimeStamp(&tv_beg);

#endif

	DEBUGMSG(DSPAPI_ZONE_FUNCTION,
			(TEXT("PROC: DSPProcessor_FlushMemory\r\n")));

	/* Check the handle */
	if (hProcessor) {
		tempStruct.ARGS_PROC_FLUSHMEMORY.hProcessor = hProcessor;
		tempStruct.ARGS_PROC_FLUSHMEMORY.pMpuAddr = pMpuAddr;
		tempStruct.ARGS_PROC_FLUSHMEMORY.ulSize = ulSize;
		tempStruct.ARGS_PROC_FLUSHMEMORY.ulFlags = ulFlags;
		status = DSPTRAP_Trap(&tempStruct, CMD_PROC_FLUSHMEMORY_OFFSET);
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: Invalid Handle\r\n")));
	}
#ifdef DEBUG_BRIDGE_PERF
timeRetVal = getTimeStamp(&tv_end);
	PrintStatistics(&tv_beg, &tv_end, "DSPProcessor_FlushMemory", ulSize);
#endif

	return status;

}

/*
 *  ======== DSPProcessor_InvalidateMemory ========
 *  Purpose:
 *      Invalidates a buffer from MPU data cache.
 */
DBAPI DSPProcessor_InvalidateMemory(DSP_HPROCESSOR hProcessor,
					PVOID pMpuAddr, ULONG ulSize)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;
#ifdef DEBUG_BRIDGE_PERF
	struct timeval tv_beg;
	struct timeval tv_end;
	struct timezone tz;
	int timeRetVal = 0;

	timeRetVal = getTimeStamp(&tv_beg);
#endif

	DEBUGMSG(DSPAPI_ZONE_FUNCTION,
			(TEXT("PROC: DSPProcessor_InvalidateMemory\r\n")));

	/* Check the handle */
	if (hProcessor) {
		tempStruct.ARGS_PROC_INVALIDATEMEMORY.hProcessor = hProcessor;
		tempStruct.ARGS_PROC_INVALIDATEMEMORY.pMpuAddr = pMpuAddr;
		tempStruct.ARGS_PROC_INVALIDATEMEMORY.ulSize = ulSize;
		status = DSPTRAP_Trap(&tempStruct,
				CMD_PROC_INVALIDATEMEMORY_OFFSET);
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: Invalid Handle\r\n")));
	}
#ifdef DEBUG_BRIDGE_PERF
	timeRetVal = getTimeStamp(&tv_end);
	PrintStatistics(&tv_beg, &tv_end,
			"DSPProcessor_InvalidateMemory", ulSize);
#endif

	return status;

}

/*
 *  ======== DSPProcessor_GetResourceInfo ========
 *  Purpose:
 *      Enumerate the resources currently available on a processor.
 */
DBAPI DSPProcessor_GetResourceInfo(DSP_HPROCESSOR hProcessor,
	     UINT uResourceType, OUT struct DSP_RESOURCEINFO *pResourceInfo,
	     UINT uResourceInfoSize)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;

	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("PROC: DSPProcessor_Ctrl\r\n")));

	if (hProcessor) {
		if (!DSP_ValidWritePtr(pResourceInfo,
				sizeof(struct DSP_RESOURCEINFO))) {
			if (uResourceInfoSize >=
					sizeof(struct DSP_RESOURCEINFO)) {
				tempStruct.ARGS_PROC_ENUMRESOURCES.hProcessor =
							hProcessor;
				tempStruct.ARGS_PROC_ENUMRESOURCES\
					.uResourceType = uResourceType;
				tempStruct.ARGS_PROC_ENUMRESOURCES\
					.pResourceInfo = pResourceInfo;
				tempStruct.ARGS_PROC_ENUMRESOURCES\
					.uResourceInfoSize = uResourceInfoSize;
				status = DSPTRAP_Trap(&tempStruct,
						CMD_PROC_ENUMRESOURCES_OFFSET);
			} else {
				status = DSP_ESIZE;
				DEBUGMSG(DSPAPI_ZONE_ERROR,
					 (TEXT("PROC: uResourceInfoSize "
							"is small \r\n")));
			}
		} else {
			/* Invalid pointer */
			status = DSP_EPOINTER;
			DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: pResourceInfo is invalid \r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR,
			 (TEXT("PROC: Invalid Handle \r\n")));
	}

	return status;
}

/*
 *  ======== DSPProcessor_GetState ========
 *  Purpose:
 *      Report the state of the specified DSP processor.
 */
DBAPI DSPProcessor_GetState(DSP_HPROCESSOR hProcessor,
	      OUT struct DSP_PROCESSORSTATE *pProcStatus, UINT uStateInfoSize)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;

	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("PROC: DSPProcessor_Ctrl\r\n")));

	/* Check the handle */
	if (hProcessor) {
		if (!DSP_ValidWritePtr(pProcStatus,
			sizeof(struct DSP_PROCESSORSTATE))) {
			if (uStateInfoSize >=
				sizeof(struct DSP_PROCESSORSTATE)) {
				tempStruct.ARGS_PROC_GETSTATE.hProcessor =
							hProcessor;
				tempStruct.ARGS_PROC_GETSTATE.pProcStatus =
							pProcStatus;
				tempStruct.ARGS_PROC_GETSTATE.uStateInfoSize =
							uStateInfoSize;
				status = DSPTRAP_Trap(&tempStruct,
						CMD_PROC_GETSTATE_OFFSET);
			} else {
				status = DSP_ESIZE;
				DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: uStateInfoSize is small \r\n")));
			}
		} else {
			status = DSP_EPOINTER;
			DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: pProcStatus is invalid \r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR,
			(TEXT("PROC: Invalid Handle \r\n")));
	}

	return status;
}

/*
 *  ======== DSPProcessor_Map ========
 *  Purpose:
 *      Map an MPU buffer to a reserved virtual address
 */
DBAPI DSPProcessor_Map(DSP_HPROCESSOR hProcessor, PVOID pMpuAddr,
		ULONG ulSize, PVOID pReqAddr, PVOID *ppMapAddr, ULONG ulMapAttr)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;
#ifdef DEBUG_BRIDGE_PERF
	struct timeval tv_beg;
	struct timeval tv_end;
	struct timezone tz;
	int timeRetVal = 0;

	timeRetVal = getTimeStamp(&tv_beg);
#endif

	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("PROC: DSPProcessor_Map\r\n")));

	/* Check the handle */
	if (hProcessor) {
		if (!DSP_ValidWritePtr(ppMapAddr, sizeof(PVOID *))
			&& !DSP_ValidReadPtr(pMpuAddr, sizeof(PVOID))
			&& (pReqAddr != NULL)) {
			if (ulSize > 0) {
#if 0
				INT i;
				ULONG ulLastByte;
				/* Physical memory pages are reserved by the
				 * driver (get_user_pages), so no need to
				 * reserve here. Ensure that physical memory
				 * pages are reserved */
				size_t page_size = getpagesize();
				for (i = 0; i < (INT)ulSize; i += page_size) {
					*(volatile BYTE *)(pMpuAddr + i) =
						*(BYTE *)(pMpuAddr + i);
				}
				/* Non page-aligned size: Write final byte */
				ulLastByte = pMpuAddr + ulSize - 1;
				*(volatile BYTE *)(ulLastByte) =
				    *(BYTE *)(ulLastByte);
#endif
				tempStruct.ARGS_PROC_MAPMEM.hProcessor =
						hProcessor;
				tempStruct.ARGS_PROC_MAPMEM.pMpuAddr = pMpuAddr;
				tempStruct.ARGS_PROC_MAPMEM.ulSize = ulSize;
				tempStruct.ARGS_PROC_MAPMEM.pReqAddr = pReqAddr;
				tempStruct.ARGS_PROC_MAPMEM.ppMapAddr =
						ppMapAddr;
				tempStruct.ARGS_PROC_MAPMEM.ulMapAttr =
						ulMapAttr;
				status = DSPTRAP_Trap(&tempStruct,
						CMD_PROC_MAPMEM_OFFSET);
			} else {
				status = DSP_ESIZE;
				DEBUGMSG(DSPAPI_ZONE_ERROR,
					(TEXT("PROC:size is zero\r\n")));
			}
		} else {
			status = DSP_EPOINTER;
			DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT
				  ("PROC: Atleast one pointer argument "
					"is invalid\r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: Invalid Handle\r\n")));
	}

#ifdef DEBUG_BRIDGE_PERF
	timeRetVal = getTimeStamp(&tv_end);
	PrintStatistics(&tv_beg, &tv_end, "DSPProcessor_Map", ulSize);
#endif


	return status;
}

/*
 *  ======== DSPProcessor_RegisterNotify ========
 *  Purpose:
 *      Register to be notified of specific processor events
 */
DBAPI DSPProcessor_RegisterNotify(DSP_HPROCESSOR hProcessor, UINT uEventMask,
		    UINT uNotifyType, struct DSP_NOTIFICATION *hNotification)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;

	DEBUGMSG(DSPAPI_ZONE_FUNCTION,
			(TEXT("PROC: DSPProcessor_RegisterNotify\r\n")));

	/* Check the handle */
	if ((hProcessor) && (hNotification)) {
		if (IsValidProcEvent(uEventMask)) {
			if (IsValidNotifyMask(uNotifyType)) {
				tempStruct.ARGS_PROC_REGISTER_NOTIFY\
						.hProcessor = hProcessor;
				tempStruct.ARGS_PROC_REGISTER_NOTIFY\
						.uEventMask = uEventMask;
				tempStruct.ARGS_PROC_REGISTER_NOTIFY\
						.uNotifyType = uNotifyType;
				tempStruct.ARGS_PROC_REGISTER_NOTIFY\
						.hNotification = hNotification;

				status = DSPTRAP_Trap(&tempStruct,
						CMD_PROC_REGISTERNOTIFY_OFFSET);
			} else {
				status = DSP_ENOTIMPL;
				DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: Invalid Notify Mask \r\n")));
			}
		} else {
			status = DSP_EVALUE;
			DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: Invalid Evnet Mask \r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR,
			(TEXT("PROC: Invalid Handle \r\n")));
	}

	return status;
}

/*
 *  ======== DSPProcessor_ReserveMemory ========
 *  Purpose:
 *      Reserve a chunk of memory from the DMM
 */
DBAPI DSPProcessor_ReserveMemory(DSP_HPROCESSOR hProcessor, ULONG ulSize,
		PVOID *ppRsvAddr)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;
#ifdef DEBUG_BRIDGE_PERF
	struct timeval tv_beg;
	struct timeval tv_end;
	struct timezone tz;
	int timeRetVal = 0;

	timeRetVal = getTimeStamp(&tv_beg);
#endif


	DEBUGMSG(DSPAPI_ZONE_FUNCTION,
			(TEXT("PROC: DSPProcessor_ReserveMemory\r\n")));

	/* Check the handle */
	if (hProcessor) {
		if (!DSP_ValidWritePtr(ppRsvAddr, sizeof(PVOID *))) {
			if (ulSize > 0) {
				if ((ulSize & (PG_SIZE_4K - 1)) == 0) {
					tempStruct.ARGS_PROC_RSVMEM.hProcessor =
							hProcessor;
					tempStruct.ARGS_PROC_RSVMEM.ulSize =
							ulSize;
					tempStruct.ARGS_PROC_RSVMEM.ppRsvAddr =
							ppRsvAddr;
					status = DSPTRAP_Trap(&tempStruct,
							CMD_PROC_RSVMEM_OFFSET);
				} else {
					status = DSP_EINVALIDARG;
					DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT
						("PROC: size is not 4KB "
							"page-aligned\r\n")));
				}
			} else {
				status = DSP_ESIZE;
				DEBUGMSG(DSPAPI_ZONE_ERROR,
					(TEXT("PROC:size is zero\r\n")));
			}
		} else {
			status = DSP_EPOINTER;
			DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC:ppRsvAddr is invalid\r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: Invalid Handle\r\n")));
	}

#ifdef DEBUG_BRIDGE_PERF
	timeRetVal = getTimeStamp(&tv_end);
	PrintStatistics(&tv_beg, &tv_end, "DSPProcessor_ReserveMemory", ulSize);
#endif

	return status;
}

/*  ======== DSPProcessor_UnMap ========
 *  Purpose:
 *      UnMap an MPU buffer from a reserved virtual address
 */
DBAPI DSPProcessor_UnMap(DSP_HPROCESSOR hProcessor, PVOID pMapAddr)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;
#ifdef DEBUG_BRIDGE_PERF
	struct timeval tv_beg;
	struct timeval tv_end;
	struct timezone tz;
	int timeRetVal = 0;

	timeRetVal = getTimeStamp(&tv_beg);
#endif

	DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("PROC: DSPProcessor_UnMap\r\n")));

	/* Check the handle */
	if (hProcessor) {
		if ((pMapAddr != NULL)) {
			tempStruct.ARGS_PROC_UNMAPMEM.hProcessor = hProcessor;
			tempStruct.ARGS_PROC_UNMAPMEM.pMapAddr = pMapAddr;
			status = DSPTRAP_Trap(&tempStruct,
				CMD_PROC_UNMAPMEM_OFFSET);
		} else {
			status = DSP_EPOINTER;
			DEBUGMSG(DSPAPI_ZONE_ERROR,
				(TEXT("PROC: pMapAddr is invalid\r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: Invalid Handle\r\n")));
	}

#ifdef DEBUG_BRIDGE_PERF
	timeRetVal = getTimeStamp(&tv_end);
	PrintStatistics(&tv_beg, &tv_end, "DSPProcessor_UnMap", 0);
#endif

	return status;
}

/*
 *  ======== DSPProcessor_UnReserveMemory ========
 *  Purpose:
 *      Free a chunk of memory from the DMM
 */
DBAPI DSPProcessor_UnReserveMemory(DSP_HPROCESSOR hProcessor, PVOID pRsvAddr)
{
	DSP_STATUS status = DSP_SOK;
	Trapped_Args tempStruct;
#ifdef DEBUG_BRIDGE_PERF
	struct timeval tv_beg;
	struct timeval tv_end;
	struct timezone tz;
	int timeRetVal = 0;

	timeRetVal = getTimeStamp(&tv_beg);
#endif

	DEBUGMSG(DSPAPI_ZONE_FUNCTION,
			(TEXT("PROC: DSPProcessor_UnReserveMemory\r\n")));

	/* Check the handle */
	if (hProcessor) {
		if (pRsvAddr != NULL) {
			tempStruct.ARGS_PROC_UNRSVMEM.hProcessor = hProcessor;
			tempStruct.ARGS_PROC_UNRSVMEM.pRsvAddr = pRsvAddr;
			status = DSPTRAP_Trap(&tempStruct,
					CMD_PROC_UNRSVMEM_OFFSET);
		} else {
			status = DSP_EPOINTER;
			DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT(
					"PROC: pRsvAddr is invalid\r\n")));
		}
	} else {
		/* Invalid handle */
		status = DSP_EHANDLE;
		DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("PROC: Invalid Handle\r\n")));
	}
#ifdef DEBUG_BRIDGE_PERF
	timeRetVal = getTimeStamp(&tv_end);
	PrintStatistics(&tv_beg, &tv_end, "DSPProcessor_UnReserveMemory", 0);
#endif

	return status;
}