drv.c

/*
 * drv.c
 *
 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
 *
 * Copyright (C) 2005-2006 Texas Instruments, Inc.
 *
 * This package is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */


/*
 *  ======== drv.c ========
 *  Description:
 *      DSP/BIOS Bridge resource allocation module.
 *
 *  Public Functions:
 *      DRV_Create
 *      DRV_Destroy
 *      DRV_Exit
 *      DRV_GetDevObject
 *      DRV_GetDevExtension
 *      DRV_GetFirstDevObject
 *      DRV_GetNextDevObject
 *      DRV_GetNextDevExtension
 *      DRV_Init
 *      DRV_InsertDevObject
 *      DRV_RemoveDevObject
 *      DRV_RequestResources
 *      DRV_ReleaseResources
 *
 *! Revision History
 *! ======== ========
 *! 19-Apr-2004 sb: Replaced OS specific APIs with MEM_AllocPhysMem and
		    MEM_FreePhysMem. Fixed warnings. Cosmetic updates.
 *! 12-Apr-2004 hp: IVA clean up during bridge-uninstall
 *! 05-Jan-2004 vp: Updated for 24xx platform
 *! 21-Mar-2003 sb: Get SHM size from registry
 *! 10-Feb-2003 vp: Code review updates
 *! 18-Oct-2002 vp: Ported to Linux platform
 *! 30-Oct-2000 kc: Modified usage of REG_SetValue.
 *! 06-Sep-2000 jeh Read channel info into struct CFG_HOSTRES in
 *! 					RequestISAResources()
 *! 21-Sep-2000 rr: numwindows is calculated instead of default value in
 *!		 RequestISAResources.
 *! 07-Aug-2000 rr: static list of dev objects removed.
 *! 27-Jul-2000 rr: RequestResources split into two(Request and Release)
 *!		 Device extension created to hold the DevNodeString.
 *! 17-Jul-2000 rr: Driver Object holds the list of Device Objects.
 *!		 Added DRV_Create, DRV_Destroy, DRV_GetDevObject,
 *!		 DRV_GetFirst/NextDevObject, DRV_Insert/RemoveDevObject.
 *! 09-May-2000 rr: PCI Support is not L301 specific.Use of MEM_Calloc
 *!		 instead of MEM_Alloc.
 *! 28-Mar-2000 rr: PCI Support added. L301 Specific. TBD.
 *! 03-Feb-2000 rr: GT and Module Init/exit Changes. Merged with kc.
 *! 19-Jan-2000 rr: DBC_Ensure in RequestPCMCIA moved within PCCARD ifdef
 *! 29-Dec-1999 rr: PCCard support for any slot.Bus type stored in the
 *!		 struct CFG_HOSTRES Structure.
 *! 17-Dec-1999 rr: if PCCARD_Init fails we return DSP_EFAIL.
 *!		 DBC_Ensure checks for sucess and pDevice != NULL
 *! 11-Dec-1999 ag: #define "Isa" renamed to "IsaBus".
 *! 09-Dec-1999 rr: windows.h included to remove warnings.
 *! 02-Dec-1999 rr: struct GT_Mask is with in if DEBUG. Request resources checks
 *!		 status while making call to Reg functions.
 *! 23-Nov-1999 rr: windows.h included
 *! 19-Nov-1999 rr: DRV_RELEASE bug while setting the registry to zero.
 *!		 fixed.
 *! 12-Nov-1999 rr: RequestResources() reads values from the registry.
 *!		 Hardcoded bIRQRegister define removed.
 *! 05-Nov-1999 rr: Added hardcoded device interrupt.
 *! 25-Oct-1999 rr: Resource structure removed. Now it uses the Host
 *!		 Resource structure directly.
 *! 15-Oct-1999 rr: Resource Structure modified. See drv.h
 *!		 dwBusType taken from the registry.Hard coded
 *!		 registry entries removed.
 *! 05-Oct-1999 rr: Calling DEV_StartDevice moved to wcdce.c. DRV_Register
 *!		 MiniDriver has been renamed to DRV_RequestResources.
 *!		 DRV_UnRegisterMiniDriver fxn removed.
 *! 24-Sep-1999 rr: Significant changes to the RegisterMiniDriver fxns.
 *!		 Now it is simpler. IT stores the dev node in the
 *!		 registry, assign resources and calls the DEV_Start.
 *! 10-Sep-1999 rr: Register Minidriver modified.
 *!		 - Resource structure follows the NT model
 *! 08-Aug-1999 rr: Adopted for WinCE. Exports Fxns removed. Hull Created.
 */

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

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

/*  ----------------------------------- Trace & Debug */
#include <dspbridge/dbc.h>
#include <dspbridge/gt.h>

/*  ----------------------------------- OS Adaptation Layer */
#include <dspbridge/cfg.h>
#include <dspbridge/csl.h>
#include <dspbridge/list.h>
#include <dspbridge/mem.h>
#include <dspbridge/reg.h>

/*  ----------------------------------- Others */
#include <dspbridge/dbreg.h>

/*  ----------------------------------- This */
#include <dspbridge/drv.h>
#include <dspbridge/dev.h>

#ifndef RES_CLEANUP_DISABLE
#include <dspbridge/node.h>
#include <dspbridge/proc.h>
#include <dspbridge/strm.h>
#include <dspbridge/nodepriv.h>
#include <dspbridge/wmdchnl.h>
#include <dspbridge/resourcecleanup.h>
#endif

/*  ----------------------------------- Defines, Data Structures, Typedefs */
#define SIGNATURE   0x5f52474d	/* "DRV_" (in reverse) */

struct DRV_OBJECT {
	u32 dwSignature;
	struct LST_LIST *devList;
	struct LST_LIST *devNodeString;
#ifndef RES_CLEANUP_DISABLE
	struct PROCESS_CONTEXT  *procCtxtList;
#endif
};

/*
 *  This is the Device Extension. Named with the Prefix
 *  DRV_ since it is living in this module
 */
struct DRV_EXT {
	struct LST_ELEM link;
	char szString[MAXREGPATHLENGTH];
};

/*  ----------------------------------- Globals */
static s32 cRefs;

#if GT_TRACE
extern struct GT_Mask curTrace;
#endif

/*  ----------------------------------- Function Prototypes */
static DSP_STATUS RequestBridgeResources(u32 dwContext, s32 fRequest);
static DSP_STATUS RequestBridgeResourcesDSP(u32 dwContext, s32 fRequest);

#ifndef RES_CLEANUP_DISABLE
/* GPP PROCESS CLEANUP CODE */

static DSP_STATUS PrintProcessInformation(void);
static DSP_STATUS DRV_ProcFreeNodeRes(HANDLE hPCtxt);
static DSP_STATUS  DRV_ProcFreeSTRMRes(HANDLE hPCtxt);
extern enum NODE_STATE NODE_GetState(HANDLE hNode);

/* Get the process context list from driver object */

/* Set the Process ID */
DSP_STATUS DRV_ProcSetPID(HANDLE hPCtxt, s32 hProcess)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;

	DBC_Assert(hPCtxt != NULL);

	pCtxt->pid = hProcess;
	return status;
}


/* Getting the head of the process context list */
DSP_STATUS DRV_GetProcCtxtList(struct PROCESS_CONTEXT **pPctxt,
				struct DRV_OBJECT *hDrvObject)
{
	DSP_STATUS status = DSP_SOK;
	struct DRV_OBJECT *pDrvObject = (struct DRV_OBJECT *)hDrvObject;

	DBC_Assert(hDrvObject != NULL);
	GT_2trace(curTrace, GT_ENTER,
		"DRV_GetProcCtxtList: 2 *pPctxt:%x, pDrvObject"
		":%x", *pPctxt, pDrvObject);
	*pPctxt = pDrvObject->procCtxtList;
	GT_2trace(curTrace, GT_ENTER,
		"DRV_GetProcCtxtList: 3 *pPctxt:%x, pDrvObject"
		":%x", *pPctxt, pDrvObject);
	return status;
}



/* Get a particular process context based on process handle (phProcess) */
DSP_STATUS DRV_GetProcContext(u32 phProcess,
				struct DRV_OBJECT *hDrvObject,
				HANDLE hPCtxt, DSP_HNODE hNode,
				u32 pMapAddr)
{
	struct PROCESS_CONTEXT **pCtxt = (struct PROCESS_CONTEXT **)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct PROCESS_CONTEXT *pCtxtList = NULL;
	struct DRV_OBJECT *pDrvObject = (struct DRV_OBJECT *)hDrvObject;
	struct NODE_RES_OBJECT *pTempNode2 = NULL;
	struct NODE_RES_OBJECT *pTempNode = NULL;
	struct DMM_RES_OBJECT *pTempDMM2 = NULL;
	struct DMM_RES_OBJECT *pTempDMM = NULL;
	s32 pCtxtFound = 0;

	DBC_Assert(pDrvObject != NULL);
	pCtxtList = pDrvObject->procCtxtList;
	GT_0trace(curTrace, GT_ENTER, "2DRV_GetProcContext: 2");
	while ((pCtxtList != NULL) && (pCtxtList->pid != phProcess)) {
		pCtxtList = pCtxtList->next;
		GT_0trace(curTrace, GT_ENTER, "2DRV_GetProcContext: 3");
	}
	if (pCtxtList == NULL) {
		if (hNode != NULL) {
			pCtxtList = pDrvObject->procCtxtList;
			while ((pCtxtList != NULL) && (pCtxtFound == 0)) {
				pTempNode = pCtxtList->pNodeList;
				while ((pTempNode != NULL) &&
				      (pTempNode->hNode != hNode)) {
					pTempNode2 = pTempNode;
					pTempNode = pTempNode->next;
				}
				if (pTempNode != NULL) {
					pCtxtFound = 1;
					status = DSP_SOK;
				} else {
					pCtxtList = pCtxtList->next;
				}
			}
		} else if ((pMapAddr != 0) && (pCtxtFound == 0)) {
			pCtxtList = pDrvObject->procCtxtList;
			while ((pCtxtList != NULL) && (pCtxtFound == 0)) {
				pTempDMM = pCtxtList->pDMMList;
				while ((pTempDMM != NULL) &&
				     (pTempDMM->ulDSPAddr != pMapAddr)) {
					pTempDMM2 = pTempDMM;
					pTempDMM = pTempDMM->next;
				}
				if (pTempDMM != NULL) {
					pCtxtFound = 1;
					status = DSP_SOK;
				} else {
					pCtxtList = pCtxtList->next;
				}
			}
			if (pCtxtList == NULL)
				status = DSP_ENOTFOUND;

		}
	} else{
		status = DSP_SOK;
	}
	GT_0trace(curTrace, GT_ENTER, "2DRV_GetProcContext: 4");
	*pCtxt = pCtxtList;
	return status;
}


/* Add a new process context to process context list */
DSP_STATUS DRV_InsertProcContext(struct DRV_OBJECT *hDrVObject, HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT **pCtxt = (struct PROCESS_CONTEXT **)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct PROCESS_CONTEXT *pCtxtList = NULL;
	struct DRV_OBJECT	     *hDRVObject;

	GT_0trace(curTrace, GT_ENTER, "\n In DRV_InsertProcContext\n");
	status = CFG_GetObject((u32 *)&hDRVObject, REG_DRV_OBJECT);
	DBC_Assert(hDRVObject != NULL);
	*pCtxt = MEM_Calloc(1 * sizeof(struct PROCESS_CONTEXT), MEM_PAGED);
	GT_0trace(curTrace, GT_ENTER,
		 "\n In DRV_InsertProcContext Calling "
		 "DRV_GetProcCtxtList\n");
	DRV_GetProcCtxtList(&pCtxtList, hDRVObject);
	GT_0trace(curTrace, GT_ENTER,
		 "\n In DRV_InsertProcContext After Calling "
		 "DRV_GetProcCtxtList\n");
	if (pCtxtList != NULL) {
		GT_0trace(curTrace, GT_ENTER,
			 "\n In DRV_InsertProcContext and pCtxt is "
			 "not Null\n");
		while (pCtxtList->next != NULL)
			pCtxtList = pCtxtList->next;

		pCtxtList->next = *pCtxt;
	} else {
		GT_0trace(curTrace, GT_ENTER,
			 "\n In DRV_InsertProcContext and "
			 "pCtxt is Null\n");
		hDRVObject->procCtxtList = *pCtxt;
	}
	return status;
}

/* Delete a process context from process resource context list */
DSP_STATUS DRV_RemoveProcContext(struct DRV_OBJECT *hDRVObject,
				     HANDLE hPCtxt, HANDLE hProcess)
{
	DSP_STATUS status = DSP_SOK;
	struct PROCESS_CONTEXT    *pCtxt2 = NULL;
	struct PROCESS_CONTEXT    *pTmp = NULL;
	struct PROCESS_CONTEXT    *pCtxtList = NULL;

	DBC_Assert(hDRVObject != NULL);
	DRV_GetProcContext((u32)hProcess, hDRVObject, &pCtxt2, NULL, 0);

	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 12");
	DRV_GetProcCtxtList(&pCtxtList, hDRVObject);
	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 13");
	pTmp = pCtxtList;
	while ((pCtxtList != NULL) && (pCtxtList != pCtxt2)) {
		pTmp = pCtxtList;
		pCtxtList = pCtxtList->next;
		GT_0trace(curTrace, GT_ENTER,
			 "DRV_RemoveProcContext: 2");
	}
	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 3");
	if (hDRVObject->procCtxtList == pCtxt2)
		hDRVObject->procCtxtList = pCtxt2->next;

	if (pCtxtList == NULL)
		return DSP_ENOTFOUND;
	else if (pTmp->next != NULL)
		pTmp->next = pTmp->next->next;

	MEM_Free(pCtxt2);
	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveProcContext: 7");

	return status;
}

/* Update the state of process context */
DSP_STATUS DRV_ProcUpdatestate(HANDLE hPCtxt, enum GPP_PROC_RES_STATE status)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status1 = DSP_SOK;
	if (pCtxt != NULL) {
		pCtxt->resState = status;
	} else {
		GT_0trace(curTrace, GT_ENTER,
			 "DRV_ProcUpdatestate: Failed to update "
			 "process state");
	}
	return status1;
}

/* Allocate and add a node resource element
* This function is called from .Node_Allocate.  */
DSP_STATUS DRV_InsertNodeResElement(HANDLE hNode, HANDLE hNodeRes,
					HANDLE hPCtxt)
{
	struct NODE_RES_OBJECT **pNodeRes = (struct NODE_RES_OBJECT **)hNodeRes;
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct NODE_RES_OBJECT   *pTempNodeRes = NULL;
	GT_0trace(curTrace, GT_ENTER, "DRV_InsertNodeResElement: 1");
	*pNodeRes = (struct NODE_RES_OBJECT *)MEM_Calloc
		    (1 * sizeof(struct NODE_RES_OBJECT), MEM_PAGED);
	DBC_Assert(hPCtxt != NULL);
	if ((*pNodeRes == NULL) || (hPCtxt == NULL)) {
		GT_0trace(curTrace, GT_ENTER, "DRV_InsertNodeResElement: 12");
		status = DSP_EHANDLE;
	}
	if (DSP_SUCCEEDED(status)) {
		(*pNodeRes)->hNode = hNode;
		if (pCtxt->pNodeList != NULL) {
			pTempNodeRes = pCtxt->pNodeList;
			while (pTempNodeRes->next != NULL)
				pTempNodeRes = pTempNodeRes->next;

			pTempNodeRes->next = *pNodeRes;
			GT_0trace(curTrace, GT_ENTER,
				 "DRV_InsertNodeResElement: 2");
		} else {
			pCtxt->pNodeList = *pNodeRes;
			GT_0trace(curTrace, GT_ENTER,
				 "DRV_InsertNodeResElement: 3");
		}
	}
	GT_0trace(curTrace, GT_ENTER, "DRV_InsertNodeResElement: 4");
	return status;
}

/* Release all Node resources and its context
* This is called from .Node_Delete.  */
DSP_STATUS DRV_RemoveNodeResElement(HANDLE hNodeRes, HANDLE hPCtxt)
{
	struct NODE_RES_OBJECT *pNodeRes = (struct NODE_RES_OBJECT *)hNodeRes;
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS	status = DSP_SOK;
	struct NODE_RES_OBJECT *pTempNode2 = pCtxt->pNodeList;
	struct NODE_RES_OBJECT *pTempNode = pCtxt->pNodeList;

	DBC_Assert(hPCtxt != NULL);
	GT_0trace(curTrace, GT_ENTER, "\nDRV_RemoveNodeResElement: 1\n");
	while ((pTempNode != NULL) && (pTempNode != pNodeRes)) {
		pTempNode2 = pTempNode;
		pTempNode = pTempNode->next;
	}
	if (pCtxt->pNodeList == pNodeRes)
		pCtxt->pNodeList = pNodeRes->next;

	if (pTempNode == NULL)
		return DSP_ENOTFOUND;
	else if (pTempNode2->next != NULL)
		pTempNode2->next = pTempNode2->next->next;

	MEM_Free(pTempNode);
	return status;
}

/* Actual Node De-Allocation */
static DSP_STATUS DRV_ProcFreeNodeRes(HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct NODE_RES_OBJECT *pNodeList = NULL;
	struct NODE_RES_OBJECT *pNodeRes = NULL;
	u32  nState;

	DBC_Assert(hPCtxt != NULL);
	pNodeList = pCtxt->pNodeList;
	while (pNodeList != NULL) {
		GT_0trace(curTrace, GT_ENTER, "DRV_ProcFreeNodeRes: 1");
		pNodeRes = pNodeList;
		pNodeList = pNodeList->next;
		if (pNodeRes->nodeAllocated) {
			nState = NODE_GetState(pNodeRes->hNode) ;
			GT_1trace(curTrace, GT_5CLASS,
				"DRV_ProcFreeNodeRes: Node state %x\n", nState);
			if (nState <= NODE_DELETING) {
				if ((nState == NODE_RUNNING) ||
					(nState == NODE_PAUSED) ||
					(nState == NODE_TERMINATING)) {
					GT_1trace(curTrace, GT_5CLASS,
					"Calling Node_Terminate for Node:"
					" 0x%x\n", pNodeRes->hNode);
					status = NODE_Terminate
						(pNodeRes->hNode, &status);
					GT_1trace(curTrace, GT_5CLASS,
						 "Calling Node_Delete for Node:"
						 " 0x%x\n", pNodeRes->hNode);
					status = NODE_Delete(pNodeRes->hNode);
					GT_1trace(curTrace, GT_5CLASS,
					"the status after the NodeDelete %x\n",
					status);
				} else if ((nState == NODE_ALLOCATED)
					|| (nState == NODE_CREATED))
					status = NODE_Delete(pNodeRes->hNode);
			}
		}
		pNodeRes->nodeAllocated = 0;
	}
	return status;
}

/* Allocate the DMM resource element
* This is called from Proc_Map. after the actual resource is allocated */
DSP_STATUS DRV_InsertDMMResElement(HANDLE hDMMRes, HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	struct DMM_RES_OBJECT **pDMMRes = (struct DMM_RES_OBJECT **)hDMMRes;
	DSP_STATUS	status = DSP_SOK;
	struct DMM_RES_OBJECT *pTempDMMRes = NULL;

	*pDMMRes = (struct DMM_RES_OBJECT *)
		    MEM_Calloc(1 * sizeof(struct DMM_RES_OBJECT), MEM_PAGED);
	DBC_Assert(hPCtxt != NULL);
	GT_0trace(curTrace, GT_ENTER, "DRV_InsertDMMResElement: 1");
	if ((*pDMMRes == NULL) || (hPCtxt == NULL)) {
		GT_0trace(curTrace, GT_5CLASS, "DRV_InsertDMMResElement: 2");
		status = DSP_EHANDLE;
	}
	if (DSP_SUCCEEDED(status)) {
		if (pCtxt->pDMMList != NULL) {
			GT_0trace(curTrace, GT_5CLASS,
				 "DRV_InsertDMMResElement: 3");
			pTempDMMRes = pCtxt->pDMMList;
			while (pTempDMMRes->next != NULL)
				pTempDMMRes = pTempDMMRes->next;

			pTempDMMRes->next = *pDMMRes;
		} else {
			pCtxt->pDMMList = *pDMMRes;
			GT_0trace(curTrace, GT_5CLASS,
				 "DRV_InsertDMMResElement: 4");
		}
	}
	GT_0trace(curTrace, GT_ENTER, "DRV_InsertDMMResElement: 5");
	return status;
}



/* Release DMM resource element context
* This is called from Proc_UnMap. after the actual resource is freed */
DSP_STATUS 	DRV_RemoveDMMResElement(HANDLE hDMMRes, HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	struct DMM_RES_OBJECT *pDMMRes = (struct DMM_RES_OBJECT *)hDMMRes;
	DSP_STATUS status = DSP_SOK;
	struct DMM_RES_OBJECT *pTempDMMRes2 = NULL;
	struct DMM_RES_OBJECT *pTempDMMRes = NULL;

	DBC_Assert(hPCtxt != NULL);
	pTempDMMRes2 = pCtxt->pDMMList;
	pTempDMMRes = pCtxt->pDMMList;
	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 1");
	while ((pTempDMMRes != NULL) && (pTempDMMRes != pDMMRes)) {
		GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 2");
		pTempDMMRes2 = pTempDMMRes;
		pTempDMMRes = pTempDMMRes->next;
	}
	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 3");
	if (pCtxt->pDMMList == pTempDMMRes)
		pCtxt->pDMMList = pTempDMMRes->next;

	if (pTempDMMRes == NULL)
		return DSP_ENOTFOUND;
	else if (pTempDMMRes2->next != NULL)
		pTempDMMRes2->next = pTempDMMRes2->next->next;

	MEM_Free(pDMMRes);
	GT_0trace(curTrace, GT_ENTER, "DRV_RemoveDMMResElement: 4");
	return status;
}

/* Update DMM resource status */
DSP_STATUS DRV_UpdateDMMResElement(HANDLE hDMMRes, u32 pMpuAddr, u32 ulSize,
				  u32 pReqAddr, u32 pMapAddr,
				  HANDLE hProcessor)
{
	struct DMM_RES_OBJECT *pDMMRes = (struct DMM_RES_OBJECT *)hDMMRes;
	DSP_STATUS status = DSP_SOK;

	DBC_Assert(hDMMRes != NULL);
	pDMMRes->ulMpuAddr = pMpuAddr;
	pDMMRes->ulDSPAddr = pMapAddr;
	pDMMRes->ulDSPResAddr = pReqAddr;
	pDMMRes->dmmSize = ulSize;
	pDMMRes->hProcessor = hProcessor;
	pDMMRes->dmmAllocated = 1;

	return status;
}

/* Actual DMM De-Allocation */
DSP_STATUS  DRV_ProcFreeDMMRes(HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct DMM_RES_OBJECT *pDMMList = pCtxt->pDMMList;
	struct DMM_RES_OBJECT *pDMMRes = NULL;

	DBC_Assert(hPCtxt != NULL);
	GT_0trace(curTrace, GT_ENTER, "\nDRV_ProcFreeDMMRes: 1\n");
	while (pDMMList != NULL) {
		pDMMRes = pDMMList;
		pDMMList = pDMMList->next;
		if (pDMMRes->dmmAllocated) {
			status = PROC_UnMap(pDMMRes->hProcessor,
				 (void *)pDMMRes->ulDSPResAddr);
			status = PROC_UnReserveMemory(pDMMRes->hProcessor,
				 (void *)pDMMRes->ulDSPResAddr);
			pDMMRes->dmmAllocated = 0;
		}
	}
	return status;
}


/* Release all DMM resources and its context
* This is called from .bridge_release. */
DSP_STATUS DRV_RemoveAllDMMResElements(HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct DMM_RES_OBJECT *pTempDMMRes2 = NULL;
	struct DMM_RES_OBJECT *pTempDMMRes = NULL;

	DBC_Assert(pCtxt != NULL);
	DRV_ProcFreeDMMRes(pCtxt);
	pTempDMMRes = pCtxt->pDMMList;
	while (pTempDMMRes != NULL) {
		pTempDMMRes2 = pTempDMMRes;
		pTempDMMRes = pTempDMMRes->next;
		MEM_Free(pTempDMMRes2);
	}
	pCtxt->pDMMList = NULL;
	return status;
}

DSP_STATUS DRV_GetDMMResElement(u32 pMapAddr, HANDLE hDMMRes, HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	struct DMM_RES_OBJECT **pDMMRes = (struct DMM_RES_OBJECT **)hDMMRes;
	DSP_STATUS status = DSP_SOK;
	struct DMM_RES_OBJECT *pTempDMM2 = NULL;
	struct DMM_RES_OBJECT *pTempDMM = NULL;

	DBC_Assert(hPCtxt != NULL);
	pTempDMM = pCtxt->pDMMList;
	while ((pTempDMM != NULL) && (pTempDMM->ulDSPAddr != pMapAddr)) {
		GT_3trace(curTrace, GT_ENTER,
			 "DRV_GetDMMResElement: 2 pTempDMM:%x "
			 "pTempDMM->ulDSPAddr:%x pMapAddr:%x\n", pTempDMM,
			 pTempDMM->ulDSPAddr, pMapAddr);
		pTempDMM2 = pTempDMM;
		pTempDMM = pTempDMM->next;
	}
	if (pTempDMM != NULL) {
		GT_0trace(curTrace, GT_ENTER, "DRV_GetDMMResElement: 3");
		*pDMMRes = pTempDMM;
	} else {
		status = DSP_ENOTFOUND;
	} GT_0trace(curTrace, GT_ENTER, "DRV_GetDMMResElement: 4");
	return status;
}

/* Update Node allocation status */
void DRV_ProcNodeUpdateStatus(HANDLE hNodeRes, s32 status)
{
	struct NODE_RES_OBJECT *pNodeRes = (struct NODE_RES_OBJECT *)hNodeRes;
	DBC_Assert(hNodeRes != NULL);
	pNodeRes->nodeAllocated = status;
}

/* Update Node Heap status */
void DRV_ProcNodeUpdateHeapStatus(HANDLE hNodeRes, s32 status)
{
	struct NODE_RES_OBJECT *pNodeRes = (struct NODE_RES_OBJECT *)hNodeRes;
	DBC_Assert(hNodeRes != NULL);
	pNodeRes->heapAllocated = status;
}

/* Release all Node resources and its context
* This is called from .bridge_release.
*/
DSP_STATUS 	DRV_RemoveAllNodeResElements(HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct NODE_RES_OBJECT *pTempNode2 = NULL;
	struct NODE_RES_OBJECT *pTempNode = NULL;

	DBC_Assert(hPCtxt != NULL);
	DRV_ProcFreeNodeRes(pCtxt);
	pTempNode = pCtxt->pNodeList;
	while (pTempNode != NULL) {
		pTempNode2 = pTempNode;
		pTempNode = pTempNode->next;
		MEM_Free(pTempNode2);
	}
	pCtxt->pNodeList = NULL;
	return status;
}

/* Getting the node resource element */

DSP_STATUS DRV_GetNodeResElement(HANDLE hNode, HANDLE hNodeRes, HANDLE hPCtxt)
{
	struct NODE_RES_OBJECT **nodeRes = (struct NODE_RES_OBJECT **)hNodeRes;
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct NODE_RES_OBJECT *pTempNode2 = NULL;
	struct NODE_RES_OBJECT *pTempNode = NULL;

	DBC_Assert(hPCtxt != NULL);
	pTempNode = pCtxt->pNodeList;
	GT_0trace(curTrace, GT_ENTER, "DRV_GetNodeResElement: 1");
	while ((pTempNode != NULL) && (pTempNode->hNode != hNode)) {
		pTempNode2 = pTempNode;
		pTempNode = pTempNode->next;
	}
	if (pTempNode != NULL)
		*nodeRes = pTempNode;
	else
		status = DSP_ENOTFOUND;

	return status;
}



/* Allocate the STRM resource element
* This is called after the actual resource is allocated
*/
DSP_STATUS DRV_ProcInsertSTRMResElement(HANDLE hStreamHandle, HANDLE hSTRMRes,
					HANDLE hPCtxt)
{
	struct STRM_RES_OBJECT **pSTRMRes = (struct STRM_RES_OBJECT **)hSTRMRes;
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct STRM_RES_OBJECT *pTempSTRMRes = NULL;
	DBC_Assert(hPCtxt != NULL);

	*pSTRMRes = (struct STRM_RES_OBJECT *)
		    MEM_Calloc(1 * sizeof(struct STRM_RES_OBJECT), MEM_PAGED);
	if ((*pSTRMRes == NULL) || (hPCtxt == NULL)) {
		GT_0trace(curTrace, GT_ENTER, "DRV_InsertSTRMResElement: 2");
		status = DSP_EHANDLE;
	}
	if (DSP_SUCCEEDED(status)) {
		(*pSTRMRes)->hStream = hStreamHandle;
		if (pCtxt->pSTRMList != NULL) {
			GT_0trace(curTrace, GT_ENTER,
				 "DRV_InsertiSTRMResElement: 3");
			pTempSTRMRes = pCtxt->pSTRMList;
			while (pTempSTRMRes->next != NULL)
				pTempSTRMRes = pTempSTRMRes->next;

			pTempSTRMRes->next = *pSTRMRes;
		} else {
			pCtxt->pSTRMList = *pSTRMRes;
			GT_0trace(curTrace, GT_ENTER,
				 "DRV_InsertSTRMResElement: 4");
		}
	}
	return status;
}



/* Release Stream resource element context
* This function called after the actual resource is freed
*/
DSP_STATUS 	DRV_ProcRemoveSTRMResElement(HANDLE hSTRMRes, HANDLE hPCtxt)
{
	struct STRM_RES_OBJECT *pSTRMRes = (struct STRM_RES_OBJECT *)hSTRMRes;
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct STRM_RES_OBJECT *pTempSTRMRes2 = pCtxt->pSTRMList;
	struct STRM_RES_OBJECT *pTempSTRMRes = pCtxt->pSTRMList;

	DBC_Assert(hPCtxt != NULL);
	while ((pTempSTRMRes != NULL) && (pTempSTRMRes != pSTRMRes)) {
		pTempSTRMRes2 = pTempSTRMRes;
		pTempSTRMRes = pTempSTRMRes->next;
	}
	if (pCtxt->pSTRMList == pTempSTRMRes)
		pCtxt->pSTRMList = pTempSTRMRes->next;

	if (pTempSTRMRes == NULL)
		status = DSP_ENOTFOUND;
	else if (pTempSTRMRes2->next != NULL)
		pTempSTRMRes2->next = pTempSTRMRes2->next->next;

	MEM_Free(pSTRMRes);
	return status;
}


/* Actual Stream De-Allocation */
static DSP_STATUS  DRV_ProcFreeSTRMRes(HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	DSP_STATUS status1 = DSP_SOK;
	u8 **apBuffer = NULL;
	struct STRM_RES_OBJECT *pSTRMList = NULL;
	struct STRM_RES_OBJECT *pSTRMRes = NULL;
	u8 *pBufPtr;
	u32 ulBytes;
	u32 dwArg;
	s32 ulBufSize;


	DBC_Assert(hPCtxt != NULL);
	pSTRMList = pCtxt->pSTRMList;
	while (pSTRMList != NULL) {
		pSTRMRes = pSTRMList;
		pSTRMList = pSTRMList->next;
		if (pSTRMRes->uNumBufs != 0) {
			apBuffer = MEM_Alloc((pSTRMRes->uNumBufs *
					    sizeof(u8 *)), MEM_NONPAGED);
			status = STRM_FreeBuffer(pSTRMRes->hStream, apBuffer,
						pSTRMRes->uNumBufs);
			MEM_Free(apBuffer);
		}
		status = STRM_Close(pSTRMRes->hStream);
		if (DSP_FAILED(status)) {
			if (status == DSP_EPENDING) {
				status = STRM_Reclaim(pSTRMRes->hStream,
						     &pBufPtr, &ulBytes,
						     (u32 *)&ulBufSize, &dwArg);
				if (DSP_SUCCEEDED(status))
					status = STRM_Close(pSTRMRes->hStream);

			}
		}
	}
	return status1;
}

/* Release all Stream resources and its context
* This is called from .bridge_release.
*/
DSP_STATUS	DRV_RemoveAllSTRMResElements(HANDLE hPCtxt)
{
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct STRM_RES_OBJECT *pTempSTRMRes2 = NULL;
	struct STRM_RES_OBJECT *pTempSTRMRes = NULL;

	DBC_Assert(hPCtxt != NULL);
	DRV_ProcFreeSTRMRes(pCtxt);
	pTempSTRMRes = pCtxt->pSTRMList;
	while (pTempSTRMRes != NULL) {
		pTempSTRMRes2 = pTempSTRMRes;
		pTempSTRMRes = pTempSTRMRes->next;
		MEM_Free(pTempSTRMRes2);
	}
	pCtxt->pSTRMList = NULL;
	return status;
}


/* Getting the stream resource element */
DSP_STATUS DRV_GetSTRMResElement(HANDLE hStrm, HANDLE hSTRMRes, HANDLE hPCtxt)
{
	struct STRM_RES_OBJECT **STRMRes = (struct STRM_RES_OBJECT **)hSTRMRes;
	struct PROCESS_CONTEXT *pCtxt = (struct PROCESS_CONTEXT *)hPCtxt;
	DSP_STATUS status = DSP_SOK;
	struct STRM_RES_OBJECT *pTempSTRM2 = NULL;
	struct STRM_RES_OBJECT *pTempSTRM = pCtxt->pSTRMList;

	DBC_Assert(hPCtxt != NULL);
	while ((pTempSTRM != NULL) && (pTempSTRM->hStream != hStrm)) {
		GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 2");
		pTempSTRM2 = pTempSTRM;
		pTempSTRM = pTempSTRM->next;
	}
	if (pTempSTRM != NULL) {
		GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 3");
		*STRMRes = pTempSTRM;
	} else {
		GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 4");
		status = DSP_ENOTFOUND;
	}
	GT_0trace(curTrace, GT_ENTER, "DRV_GetSTRMResElement: 5");
	return status;
}

/* Updating the stream resource element */
DSP_STATUS DRV_ProcUpdateSTRMRes(u32 uNumBufs, HANDLE hSTRMRes, HANDLE hPCtxt)
{
	DSP_STATUS status = DSP_SOK;
	struct STRM_RES_OBJECT **STRMRes = (struct STRM_RES_OBJECT **)hSTRMRes;

	DBC_Assert(hPCtxt != NULL);
	(*STRMRes)->uNumBufs = uNumBufs;
	return status;
}

/* Displaying the resources allocated by a process */
DSP_STATUS DRV_ProcDisplayResInfo(u8 *pBuf1, u32 *pSize)
{
	struct PROCESS_CONTEXT *pCtxt = NULL;
	struct NODE_RES_OBJECT *pNodeRes = NULL;
	struct DMM_RES_OBJECT *pDMMRes = NULL;
	struct STRM_RES_OBJECT *pSTRMRes = NULL;
	struct DSPHEAP_RES_OBJECT *pDSPHEAPRes = NULL;
	u32 tempCount = 1;
	HANDLE hDrvObject = NULL;
	void *pBuf = pBuf1;
	u8 pTempBuf[250];
	u32 tempStrLen = 0, tempStrLen2 = 0;
	DSP_STATUS status = DSP_SOK;

	CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT);
	DRV_GetProcCtxtList(&pCtxt, (struct DRV_OBJECT *)hDrvObject);
	GT_0trace(curTrace, GT_ENTER, "*********************"
		 "DRV_ProcDisplayResourceInfo:*\n");
	while (pCtxt != NULL) {
		tempStrLen2 = sprintf((char *)pTempBuf,
				     "-------------------------------------"
				     "-----------------------------------\n");
		tempStrLen2 += 2;
		memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
		tempStrLen += tempStrLen2;
		if (pCtxt->resState == PROC_RES_ALLOCATED) {
			tempStrLen2 = sprintf((char *)pTempBuf,
					"GPP Process Resource State: "
					"pCtxt->resState = PROC_RES_ALLOCATED, "
					" Process ID: %d\n", pCtxt->pid);
			tempStrLen2 += 2;
			memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
			tempStrLen += tempStrLen2;
		} else {
			tempStrLen2 = sprintf((char *)pTempBuf,
				"GPP Resource State: pCtxt->resState"
				" = PROC_RES_DEALLOCATED, Process ID:%d\n",
				pCtxt->pid);
			tempStrLen2 += 2;
			memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
			tempStrLen += tempStrLen2;
		}
		pNodeRes = pCtxt->pNodeList;
		tempCount = 1;
		while (pNodeRes != NULL) {
			GT_2trace(curTrace, GT_ENTER,
				 "DRV_ProcDisplayResourceInfo: #:%d "
				 "pCtxt->pNodeList->hNode:%x\n",
				 tempCount, pNodeRes->hNode);
			tempStrLen2 = sprintf((char *)pTempBuf,
					"Node Resource Information: Node #"
					" %d Node Handle hNode:0X%x\n",
					tempCount, (u32)pNodeRes->hNode);
			pNodeRes = pNodeRes->next;
			tempStrLen2 += 2;
			memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
			tempStrLen += tempStrLen2;
			tempCount++;
		}
		tempCount = 1;
		pDSPHEAPRes = pCtxt->pDSPHEAPList;
		while (pDSPHEAPRes != NULL) {
			GT_2trace(curTrace, GT_ENTER,
				 "DRV_ProcDisplayResourceInfo: #:%d "
				 "pCtxt->pDSPHEAPRList->ulMpuAddr:%x\n",
				 tempCount, pDSPHEAPRes->ulMpuAddr);
			tempStrLen2 = sprintf((char *)pTempBuf,
				 "DSP Heap Resource Info: HEAP # %d"
				 " Mapped GPP Address: 0x%x, size: 0x%x\n",
				 tempCount, (u32)pDSPHEAPRes->ulMpuAddr,
				 (u32)pDSPHEAPRes->heapSize);
			pDSPHEAPRes = pDSPHEAPRes->next;
			tempStrLen2 += 2;
			memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
			tempStrLen += tempStrLen2;
			tempCount++;
		}
		tempCount = 1;
		pDMMRes = pCtxt->pDMMList;
		while (pDMMRes != NULL) {
			GT_2trace(curTrace, GT_ENTER,
					"DRV_ProcDisplayResourceInfo: #:%d "
					" pCtxt->pDMMList->ulMpuAddr:%x\n",
					tempCount,
					pDMMRes->ulMpuAddr);
			tempStrLen2 = sprintf((char *)pTempBuf,
					 "DMM Resource Info: DMM # %d Mapped"
					 " GPP Address: 0x%x, size: 0x%x\n",
					 tempCount, (u32)pDMMRes->ulMpuAddr,
					 (u32)pDMMRes->dmmSize);
			pDMMRes = pDMMRes->next;
			tempStrLen2 += 2;
			memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
			tempStrLen += tempStrLen2;
			tempCount++;
		}
		tempCount = 1;
		pSTRMRes = pCtxt->pSTRMList;
		while (pSTRMRes != NULL) {
			GT_2trace(curTrace, GT_ENTER,
				 "DRV_ProcDisplayResourceInfo: #:%d "
				 "pCtxt->pSTRMList->hStream:%x\n", tempCount,
				 pSTRMRes->hStream);
			tempStrLen2 = sprintf((char *)pTempBuf,
					     "Stream Resource info: STRM # %d "
					     "Stream Handle: 0x%x \n",
					     tempCount, (u32)pSTRMRes->hStream);
			pSTRMRes = pSTRMRes->next;
			tempStrLen2 += 2;
			memmove(pBuf+tempStrLen, pTempBuf, tempStrLen2);
			tempStrLen += tempStrLen2;
			tempCount++;
		}
		pCtxt = pCtxt->next;
	}
	*pSize = tempStrLen;
	status = PrintProcessInformation();
	GT_0trace(curTrace, GT_ENTER, "*********************"
		"DRV_ProcDisplayResourceInfo:**\n");
	return status;
}

/*
 *  ======== PrintProcessInformation ========
 *  Purpose:
 *      This function prints the Process's information stored in
 *      the process context list. Some of the information that
 *      it displays is Process's state, Node, Stream, DMM, and
 *      Heap information.
 */
static DSP_STATUS PrintProcessInformation(void)
{
	struct DRV_OBJECT *hDrvObject = NULL;
	struct PROCESS_CONTEXT *pCtxtList = NULL;
	struct NODE_RES_OBJECT *pNodeRes = NULL;
	struct DMM_RES_OBJECT *pDMMRes = NULL;
	struct STRM_RES_OBJECT *pSTRMRes = NULL;
	struct DSPHEAP_RES_OBJECT *pDSPHEAPRes = NULL;
	DSP_STATUS status = DSP_SOK;
	u32 tempCount;
	u32  procID;

	/* Get the Process context list */
	CFG_GetObject((u32 *)&hDrvObject, REG_DRV_OBJECT);
	DRV_GetProcCtxtList(&pCtxtList, hDrvObject);
	GT_0trace(curTrace, GT_4CLASS, "\n### Debug information"
			" for DSP bridge ##\n");
	GT_0trace(curTrace, GT_4CLASS, " \n ###The  processes"
			" information is as follows ### \n") ;
	GT_0trace(curTrace, GT_4CLASS, "  ====================="
			"============ \n");
	/* Go through the entries in the Process context list */
	while (pCtxtList  != NULL) {
		GT_1trace(curTrace, GT_4CLASS, "\nThe process"
				" id is %d\n", pCtxtList->pid);
		GT_0trace(curTrace, GT_4CLASS, " -------------------"
				"---------\n");
		if (pCtxtList->resState == PROC_RES_ALLOCATED) {
			GT_0trace(curTrace, GT_4CLASS, " \nThe Process"
					" is in Allocated state\n");
		} else {
			GT_0trace(curTrace, GT_4CLASS, "\nThe Process"
					" is in DeAllocated state\n");
		}
		GT_1trace(curTrace, GT_4CLASS, "\nThe  hProcessor"
				" handle is: 0X%x\n",
				(u32)pCtxtList->hProcessor);
		if (pCtxtList->hProcessor != NULL) {
			PROC_GetProcessorId(pCtxtList->hProcessor, &procID);
			if (procID == DSP_UNIT) {
				GT_0trace(curTrace, GT_4CLASS,
					"\nProcess connected to"
					" DSP Processor\n");
			} else if (procID == IVA_UNIT) {
				GT_0trace(curTrace, GT_4CLASS,
					"\nProcess connected to"
					" IVA Processor\n");
			} else {
				GT_0trace(curTrace, GT_7CLASS,
					"\n***ERROR:Invalid Processor Id***\n");
			}
		}
		pNodeRes = pCtxtList->pNodeList;
		tempCount = 1;
		while (pNodeRes != NULL) {
			if (tempCount == 1)
				GT_0trace(curTrace, GT_4CLASS,
					"\n***The Nodes allocated by"
					" this Process are***\n");
			GT_2trace(curTrace, GT_4CLASS,
					"Node # %d Node Handle hNode:0x%x\n",
					tempCount, (u32)pNodeRes->hNode);
			pNodeRes = pNodeRes->next;
			tempCount++;
		}
		if (tempCount == 1)
			GT_0trace(curTrace, GT_4CLASS,
					"\n ***There are no Nodes"
					" allocated by this Process***\n");
		tempCount = 1;
		pDSPHEAPRes = pCtxtList->pDSPHEAPList;
		while (pDSPHEAPRes != NULL) {
			if (tempCount == 1)
				GT_0trace(curTrace, GT_4CLASS,
						"\n***The Heaps allocated by"
						" this Process are***\n");
			GT_3trace(curTrace, GT_4CLASS,
				"DSP Heap Resource Info: HEAP # %d "
				"Mapped GPP Address:0x%x, Size: 0x%lx\n",
				tempCount, (u32)pDSPHEAPRes->ulMpuAddr,
				pDSPHEAPRes->heapSize);
			pDSPHEAPRes = pDSPHEAPRes->next;
			tempCount++;
		}
		if (tempCount == 1)
			GT_0trace(curTrace, GT_4CLASS,
				"\n ***There are no Heaps allocated"
				" by this Process***\n");
		tempCount = 1;
		pDMMRes = pCtxtList->pDMMList;
		while (pDMMRes != NULL) {
			if (tempCount == 1)
				GT_0trace(curTrace, GT_4CLASS,
					"\n ***The DMM resources allocated by"
					" this Process are***\n");
			GT_3trace(curTrace, GT_4CLASS,
				"DMM Resource Info: DMM # %d "
				"Mapped GPP Address:0X%lx, Size: 0X%lx\n",
				tempCount, pDMMRes->ulMpuAddr,
				pDMMRes->dmmSize);
			pDMMRes = pDMMRes->next;
			tempCount++;
		}
		if (tempCount == 1)
			GT_0trace(curTrace, GT_4CLASS,
				"\n ***There are no DMM resources"
				" allocated by this Process***\n");
		tempCount = 1;
		pSTRMRes = pCtxtList->pSTRMList;
		while (pSTRMRes != NULL) {
			if (tempCount == 1)
				GT_0trace(curTrace, GT_4CLASS,
					"\n***The Stream resources allocated by"
					" this Process are***\n");
			GT_2trace(curTrace, GT_4CLASS,
				"Stream Resource info: STRM # %d"
				"Stream Handle:0X%x\n",	tempCount,
				(u32)pSTRMRes->hStream);
			pSTRMRes = pSTRMRes->next;
			tempCount++;
		}
		if (tempCount == 1)
			GT_0trace(curTrace, GT_4CLASS,
				"\n ***There are no Stream resources"
				"allocated by this Process***\n");
		pCtxtList = pCtxtList->next;
	}
	return status;
}

/* GPP PROCESS CLEANUP CODE END */
#endif

/*
 *  ======== = DRV_Create ======== =
 *  Purpose:
 *      DRV Object gets created only once during Driver Loading.
 */
DSP_STATUS DRV_Create(OUT struct DRV_OBJECT **phDRVObject)
{
	DSP_STATUS status = DSP_SOK;
	struct DRV_OBJECT *pDRVObject = NULL;

	DBC_Require(phDRVObject != NULL);
	DBC_Require(cRefs > 0);
	GT_1trace(curTrace, GT_ENTER, "Entering DRV_Create"
			" phDRVObject 0x%x\n", phDRVObject);
	MEM_AllocObject(pDRVObject, struct DRV_OBJECT, SIGNATURE);
	if (pDRVObject) {
		/* Create and Initialize List of device objects */
		pDRVObject->devList = LST_Create();
		if (pDRVObject->devList) {
			/* Create and Initialize List of device Extension */
			pDRVObject->devNodeString = LST_Create();
			if (!(pDRVObject->devNodeString)) {
				status = DSP_EFAIL;
				GT_0trace(curTrace, GT_7CLASS,
					 "Failed to Create DRV_EXT list ");
				MEM_FreeObject(pDRVObject);
			}
		} else {
			status = DSP_EFAIL;
			GT_0trace(curTrace, GT_7CLASS,
				 "Failed to Create Dev List ");
			MEM_FreeObject(pDRVObject);
		}
	} else {
		status = DSP_EFAIL;
		GT_0trace(curTrace, GT_7CLASS,
			 "Failed to Allocate Memory for DRV Obj");
	}
	if (DSP_SUCCEEDED(status)) {
		/* Store the DRV Object in the Registry */
		if (DSP_SUCCEEDED
		    (CFG_SetObject((u32) pDRVObject, REG_DRV_OBJECT))) {
			GT_1trace(curTrace, GT_1CLASS,
				 "DRV Obj Created pDrvObject 0x%x\n ",
				 pDRVObject);
			*phDRVObject = pDRVObject;
		} else {
			/* Free the DRV Object */
			status = DSP_EFAIL;
			MEM_Free(pDRVObject);
			GT_0trace(curTrace, GT_7CLASS,
				 "Failed to update the Registry with "
				 "DRV Object ");
		}
	}
	GT_2trace(curTrace, GT_ENTER,
		 "Exiting DRV_Create: phDRVObject: 0x%x\tstatus:"
		 "0x%x\n", phDRVObject, status);
	DBC_Ensure(DSP_FAILED(status) ||
		  MEM_IsValidHandle(pDRVObject, SIGNATURE));
	return status;
}

/*
 *  ======== DRV_Exit ========
 *  Purpose:
 *      Discontinue usage of the DRV module.
 */
void DRV_Exit(void)
{
	DBC_Require(cRefs > 0);

	GT_0trace(curTrace, GT_5CLASS, "Entering DRV_Exit \n");

	cRefs--;

	DBC_Ensure(cRefs >= 0);
}

/*
 *  ======== = DRV_Destroy ======== =
 *  purpose:
 *      Invoked during bridge de-initialization
 */
DSP_STATUS DRV_Destroy(struct DRV_OBJECT *hDRVObject)
{
	DSP_STATUS status = DSP_SOK;
	struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDRVObject;

	DBC_Require(cRefs > 0);
	DBC_Require(MEM_IsValidHandle(pDRVObject, SIGNATURE));

	GT_1trace(curTrace, GT_ENTER, "Entering DRV_Destroy"
			" hDRVObject 0x%x\n", hDRVObject);
	/*
	 *  Delete the List if it exists.Should not come here
	 *  as the DRV_RemoveDevObject and the Last DRV_RequestResources
	 *  removes the list if the lists are empty.
	 */
	if (pDRVObject->devList) {
		/* Could assert if the list is not empty  */
		LST_Delete(pDRVObject->devList);
	}
	if (pDRVObject->devNodeString) {
		/* Could assert if the list is not empty */
		LST_Delete(pDRVObject->devNodeString);
	}
	MEM_FreeObject(pDRVObject);
	/* Update the DRV Object in Registry to be 0 */
	(void)CFG_SetObject(0, REG_DRV_OBJECT);
	GT_2trace(curTrace, GT_ENTER,
		 "Exiting DRV_Destroy: hDRVObject: 0x%x\tstatus:"
		 "0x%x\n", hDRVObject, status);
	DBC_Ensure(!MEM_IsValidHandle(pDRVObject, SIGNATURE));
	return status;
}

/*
 *  ======== DRV_GetDevObject ========
 *  Purpose:
 *      Given a index, returns a handle to DevObject from the list.
 */
DSP_STATUS DRV_GetDevObject(u32 uIndex, struct DRV_OBJECT *hDrvObject,
			   struct DEV_OBJECT **phDevObject)
{
	DSP_STATUS status = DSP_SOK;
#if GT_TRACE	/* pDrvObject is used only for Assertions and debug messages.*/
	struct DRV_OBJECT *pDrvObject = (struct DRV_OBJECT *)hDrvObject;
#endif
	struct DEV_OBJECT *pDevObject;
	u32 i;
	DBC_Require(MEM_IsValidHandle(pDrvObject, SIGNATURE));
	DBC_Require(phDevObject != NULL);
	DBC_Require(uIndex >= 0);
	DBC_Require(cRefs > 0);
	DBC_Assert(!(LST_IsEmpty(pDrvObject->devList)));
	GT_3trace(curTrace, GT_ENTER,
		 "Entered DRV_GetDevObject, args:\n\tuIndex: "
		 "0x%x\n\thDrvObject:  0x%x\n\tphDevObject:  0x%x\n",
		 uIndex, hDrvObject, phDevObject);
	pDevObject = (struct DEV_OBJECT *)DRV_GetFirstDevObject();
	for (i = 0; i < uIndex; i++) {
		pDevObject =
		   (struct DEV_OBJECT *)DRV_GetNextDevObject((u32)pDevObject);
	}
	if (pDevObject) {
		*phDevObject = (struct DEV_OBJECT *) pDevObject;
		status = DSP_SOK;
	} else {
		*phDevObject = NULL;
		status = DSP_EFAIL;
		GT_0trace(curTrace, GT_7CLASS,
			 "DRV: Could not get the DevObject\n");
	}
	GT_2trace(curTrace, GT_ENTER,
		 "Exiting Drv_GetDevObject\n\tstatus: 0x%x\n\t"
		 "hDevObject: 0x%x\n", status, *phDevObject);
	return status;
}

/*
 *  ======== DRV_GetFirstDevObject ========
 *  Purpose:
 *      Retrieve the first Device Object handle from an internal linked list of
 *      of DEV_OBJECTs maintained by DRV.
 */
u32 DRV_GetFirstDevObject(void)
{
	u32 dwDevObject = 0;
	struct DRV_OBJECT *pDrvObject;

	if (DSP_SUCCEEDED
	    (CFG_GetObject((u32 *)&pDrvObject, REG_DRV_OBJECT))) {
		if ((pDrvObject->devList != NULL) &&
		   !LST_IsEmpty(pDrvObject->devList))
			dwDevObject = (u32) LST_First(pDrvObject->devList);
	}

	return dwDevObject;
}

/*
 *  ======== DRV_GetFirstDevNodeString ========
 *  Purpose:
 *      Retrieve the first Device Extension from an internal linked list of
 *      of Pointer to DevNode Strings maintained by DRV.
 */
u32 DRV_GetFirstDevExtension(void)
{
	u32 dwDevExtension = 0;
	struct DRV_OBJECT *pDrvObject;

	if (DSP_SUCCEEDED
	    (CFG_GetObject((u32 *)&pDrvObject, REG_DRV_OBJECT))) {

		if ((pDrvObject->devNodeString != NULL) &&
		   !LST_IsEmpty(pDrvObject->devNodeString)) {
			dwDevExtension = (u32)LST_First(pDrvObject->
							devNodeString);
		}
	}

	return dwDevExtension;
}

/*
 *  ======== DRV_GetNextDevObject ========
 *  Purpose:
 *      Retrieve the next Device Object handle from an internal linked list of
 *      of DEV_OBJECTs maintained by DRV, after having previously called
 *      DRV_GetFirstDevObject() and zero or more DRV_GetNext.
 */
u32 DRV_GetNextDevObject(u32 hDevObject)
{
	u32 dwNextDevObject = 0;
	struct DRV_OBJECT *pDrvObject;

	DBC_Require(hDevObject != 0);

	if (DSP_SUCCEEDED
	    (CFG_GetObject((u32 *)&pDrvObject, REG_DRV_OBJECT))) {

		if ((pDrvObject->devList != NULL) &&
		   !LST_IsEmpty(pDrvObject->devList)) {
			dwNextDevObject = (u32)LST_Next(pDrvObject->devList,
					  (struct LST_ELEM *)hDevObject);
		}
	}
	return dwNextDevObject;
}

/*
 *  ======== DRV_GetNextDevExtension ========
 *  Purpose:
 *      Retrieve the next Device Extension from an internal linked list of
 *      of pointer to DevNodeString maintained by DRV, after having previously
 *      called DRV_GetFirstDevExtension() and zero or more
 *      DRV_GetNextDevExtension().
 */
u32 DRV_GetNextDevExtension(u32 hDevExtension)
{
	u32 dwDevExtension = 0;
	struct DRV_OBJECT *pDrvObject;

	DBC_Require(hDevExtension != 0);

	if (DSP_SUCCEEDED(CFG_GetObject((u32 *)&pDrvObject,
	   REG_DRV_OBJECT))) {
		if ((pDrvObject->devNodeString != NULL) &&
		   !LST_IsEmpty(pDrvObject->devNodeString)) {
			dwDevExtension = (u32)LST_Next(pDrvObject->
				devNodeString,
				(struct LST_ELEM *)hDevExtension);
		}
	}

	return dwDevExtension;
}

/*
 *  ======== DRV_Init ========
 *  Purpose:
 *      Initialize DRV module private state.
 */
DSP_STATUS DRV_Init(void)
{
	s32 fRetval = 1;	/* function return value */

	DBC_Require(cRefs >= 0);

	if (fRetval)
		cRefs++;

	GT_1trace(curTrace, GT_5CLASS, "Entering DRV_Entry  crefs 0x%x \n",
		 cRefs);

	DBC_Ensure((fRetval && (cRefs > 0)) || (!fRetval && (cRefs >= 0)));

	return fRetval;
}

/*
 *  ======== DRV_InsertDevObject ========
 *  Purpose:
 *      Insert a DevObject into the list of Manager object.
 */
DSP_STATUS DRV_InsertDevObject(struct DRV_OBJECT *hDRVObject,
			       struct DEV_OBJECT *hDevObject)
{
	DSP_STATUS status = DSP_SOK;
	struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDRVObject;

	DBC_Require(cRefs > 0);
	DBC_Require(hDevObject != NULL);
	DBC_Require(MEM_IsValidHandle(pDRVObject, SIGNATURE));
	DBC_Assert(pDRVObject->devList);

	GT_2trace(curTrace, GT_ENTER,
		 "Entering DRV_InsertProcObject hDRVObject "
		 "0x%x\n, hDevObject 0x%x\n", hDRVObject, hDevObject);

	LST_PutTail(pDRVObject->devList, (struct LST_ELEM *)hDevObject);

	GT_1trace(curTrace, GT_ENTER,
		 "Exiting InsertDevObject status 0x%x\n", status);

	DBC_Ensure(DSP_SUCCEEDED(status) && !LST_IsEmpty(pDRVObject->devList));

	return status;
}

/*
 *  ======== DRV_RemoveDevObject ========
 *  Purpose:
 *      Search for and remove a DeviceObject from the given list of DRV
 *      objects.
 */
DSP_STATUS DRV_RemoveDevObject(struct DRV_OBJECT *hDRVObject,
			       struct DEV_OBJECT *hDevObject)
{
	DSP_STATUS status = DSP_EFAIL;
	struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDRVObject;
	struct LST_ELEM *pCurElem;

	DBC_Require(cRefs > 0);
	DBC_Require(MEM_IsValidHandle(pDRVObject, SIGNATURE));
	DBC_Require(hDevObject != NULL);

	DBC_Require(pDRVObject->devList != NULL);
	DBC_Require(!LST_IsEmpty(pDRVObject->devList));

	GT_2trace(curTrace, GT_ENTER,
		 "Entering DRV_RemoveDevObject hDevObject "
		 "0x%x\n, hDRVObject 0x%x\n", hDevObject, hDRVObject);
	/* Search list for pProcObject: */
	for (pCurElem = LST_First(pDRVObject->devList); pCurElem != NULL;
	    pCurElem = LST_Next(pDRVObject->devList, pCurElem)) {
		/* If found, remove it. */
		if ((struct DEV_OBJECT *) pCurElem == hDevObject) {
			LST_RemoveElem(pDRVObject->devList, pCurElem);
			status = DSP_SOK;
			break;
		}
	}
	/* Remove list if empty. */
	if (LST_IsEmpty(pDRVObject->devList)) {
		LST_Delete(pDRVObject->devList);
		pDRVObject->devList = NULL;
	}
	DBC_Ensure((pDRVObject->devList == NULL) ||
		  !LST_IsEmpty(pDRVObject->devList));
	GT_1trace(curTrace, GT_ENTER,
		 "DRV_RemoveDevObject returning 0x%x\n", status);
	return status;
}

/*
 *  ======== DRV_RequestResources ========
 *  Purpose:
 *      Requests  resources from the OS.
 */
DSP_STATUS DRV_RequestResources(u32 dwContext, u32 *pDevNodeString)
{
	DSP_STATUS status = DSP_SOK;
	struct DRV_OBJECT *pDRVObject;
	struct DRV_EXT *pszdevNode;

	DBC_Require(dwContext != 0);
	DBC_Require(pDevNodeString != NULL);
	GT_0trace(curTrace, GT_ENTER, "Entering DRV_RequestResources\n");
	/*
	 *  Allocate memory to hold the string. This will live untill
	 *  it is freed in the Release resources. Update the driver object
	 *  list.
	 */
	if (DSP_SUCCEEDED(CFG_GetObject((u32 *)&pDRVObject,
	   REG_DRV_OBJECT))) {
		pszdevNode = MEM_Calloc(sizeof(struct DRV_EXT), MEM_NONPAGED);
		if (pszdevNode) {
			LST_InitElem(&pszdevNode->link);
                       strncpy((char *) pszdevNode->szString,
				 (char *)dwContext, MAXREGPATHLENGTH);
			/* Update the Driver Object List */
			*pDevNodeString = (u32)pszdevNode->szString;
			LST_PutTail(pDRVObject->devNodeString,
				(struct LST_ELEM *)pszdevNode);
		} else {
			GT_0trace(curTrace, GT_7CLASS,
				"Failed to Allocate Memory devNodeString ");
			status = DSP_EFAIL;
			*pDevNodeString = 0;
		}
	} else {
		status = DSP_EFAIL;
		GT_0trace(curTrace, GT_7CLASS,
			 "Failed to get Driver Object from Registry");
		*pDevNodeString = 0;
	}

       if (!(strcmp((char *) dwContext, "TIOMAP1510"))) {
		GT_0trace(curTrace, GT_1CLASS,
			  " Allocating resources for UMA \n");
		status = RequestBridgeResourcesDSP(dwContext, DRV_ASSIGN);
	} else {
		status = DSP_EFAIL;
		GT_0trace(curTrace, GT_7CLASS, "Unknown Device ");
	}

	if (DSP_FAILED(status)) {
		GT_0trace(curTrace, GT_7CLASS,
			 "Failed to reserve bridge resources ");
	}
	DBC_Ensure((DSP_SUCCEEDED(status) && pDevNodeString != NULL &&
		  !LST_IsEmpty(pDRVObject->devNodeString)) ||
		  (DSP_FAILED(status) && *pDevNodeString == 0));

	return status;
}

/*
 *  ======== DRV_ReleaseResources ========
 *  Purpose:
 *      Releases  resources from the OS.
 */
DSP_STATUS DRV_ReleaseResources(u32 dwContext, struct DRV_OBJECT *hDrvObject)
{
	DSP_STATUS status = DSP_SOK;
	struct DRV_OBJECT *pDRVObject = (struct DRV_OBJECT *)hDrvObject;
	struct DRV_EXT *pszdevNode;

	GT_0trace(curTrace, GT_ENTER, "Entering DRV_Release Resources\n");

       if (!(strcmp((char *)((struct DRV_EXT *)dwContext)->szString,
	   "TIOMAP1510"))) {
		GT_0trace(curTrace, GT_1CLASS,
			 " Releasing DSP-Bridge resources \n");
		status = RequestBridgeResources(dwContext, DRV_RELEASE);
	} else {
		GT_0trace(curTrace, GT_1CLASS, " Unknown device\n");
	}

	if (DSP_SUCCEEDED(status)) {
		GT_0trace(curTrace, GT_1CLASS,
			 "Failed to relese bridge resources\n");
	}

	/*
	 *  Irrespective of the status go ahead and clean it
	 *  The following will over write the status.
	 */
	for (pszdevNode = (struct DRV_EXT *)DRV_GetFirstDevExtension();
	    pszdevNode != NULL; pszdevNode = (struct DRV_EXT *)
	    DRV_GetNextDevExtension((u32)pszdevNode)) {
		if ((u32)pszdevNode == dwContext) {
			/* Found it */
			/* Delete from the Driver object list */
			LST_RemoveElem(pDRVObject->devNodeString,
				      (struct LST_ELEM *)pszdevNode);
			MEM_Free((void *) pszdevNode);
			break;
		}
		/* Delete the List if it is empty */
		if (LST_IsEmpty(pDRVObject->devNodeString)) {
			LST_Delete(pDRVObject->devNodeString);
			pDRVObject->devNodeString = NULL;
		}
	}
	return status;
}

/*
 *  ======== RequestBridgeResources ========
 *  Purpose:
 *      Reserves shared memory for bridge.
 */
static DSP_STATUS RequestBridgeResources(u32 dwContext, s32 bRequest)
{
	DSP_STATUS status = DSP_SOK;
	struct CFG_HOSTRES *pResources;
	u32 dwBuffSize;

	struct DRV_EXT *driverExt;
	u32 shm_size;

	DBC_Require(dwContext != 0);

	GT_0trace(curTrace, GT_ENTER, "->RequestBridgeResources \n");

	if (!bRequest) {
		driverExt = (struct DRV_EXT *)dwContext;
		/* Releasing resources by deleting the registry key  */
		dwBuffSize = sizeof(struct CFG_HOSTRES);
		pResources = MEM_Calloc(dwBuffSize, MEM_NONPAGED);
		if (DSP_FAILED(REG_GetValue(NULL, (char *)driverExt->szString,
		   CURRENTCONFIG, (u8 *)pResources, &dwBuffSize))) {
			status = CFG_E_RESOURCENOTAVAIL;
			GT_0trace(curTrace, GT_1CLASS,
				 "REG_GetValue Failed \n");
		} else {
			GT_0trace(curTrace, GT_1CLASS,
				 "REG_GetValue Succeeded \n");
		}

		if (pResources != NULL) {
			dwBuffSize = sizeof(shm_size);
			status = REG_GetValue(NULL, CURRENTCONFIG, SHMSIZE,
				(u8 *)&shm_size, &dwBuffSize);
			if (DSP_SUCCEEDED(status)) {
				if ((pResources->dwMemBase[1]) &&
				   (pResources->dwMemPhys[1])) {
					MEM_FreePhysMem((void *)pResources->
					dwMemBase[1], pResources->dwMemPhys[1],
					shm_size);
				}
			} else {
				GT_1trace(curTrace, GT_7CLASS,
					"Error getting SHM size from registry: "
					"%x. Not calling MEM_FreePhysMem\n",
					status);
			}
			pResources->dwMemBase[1] = 0;
			pResources->dwMemPhys[1] = 0;

			if (pResources->dwPrmBase)
				iounmap(pResources->dwPrmBase);
#ifdef OMAP_3430
			if (pResources->dwCmBase)
				iounmap((void *)pResources->dwCmBase);
#endif
#ifdef OMAP_44XX
			if (pResources->dwCm1Base)
				iounmap((void *)pResources->dwCm1Base);
			if (pResources->dwCm2Base)
				iounmap((void *)pResources->dwCm2Base);
#endif
			if (pResources->dwMboxBase)
				iounmap(pResources->dwMboxBase);
			if (pResources->dwMemBase[0])
				iounmap((void *)pResources->dwMemBase[0]);
			if (pResources->dwMemBase[2])
				iounmap((void *)pResources->dwMemBase[2]);
			if (pResources->dwMemBase[3])
				iounmap((void *)pResources->dwMemBase[3]);
			if (pResources->dwMemBase[4])
				iounmap((void *)pResources->dwMemBase[4]);
			if (pResources->dwWdTimerDspBase)
				iounmap(pResources->dwWdTimerDspBase);
			if (pResources->dwDmmuBase)
				iounmap(pResources->dwDmmuBase);
			if (pResources->dwPerBase)
				iounmap(pResources->dwPerBase);
                       if (pResources->dwPerPmBase)
                               iounmap((void *)pResources->dwPerPmBase);
                       if (pResources->dwCorePmBase)
                               iounmap((void *)pResources->dwCorePmBase);
			if (pResources->dwSysCtrlBase) {
				iounmap(pResources->dwSysCtrlBase);
				/* don't set pResources->dwSysCtrlBase to null
				 * as it is used in BOARD_Stop */
			}
			pResources->dwPrmBase = NULL;
#ifdef OMAP_3430
			pResources->dwCmBase = NULL;
#endif
#ifdef OMAP_44XX
			pResources->dwCm1Base = (u32) NULL;
			pResources->dwCm2Base = (u32) NULL;
#endif
			pResources->dwMboxBase = NULL;
			pResources->dwMemBase[0] = (u32) NULL;
			pResources->dwMemBase[2] = (u32) NULL;
			pResources->dwMemBase[3] = (u32) NULL;
			pResources->dwMemBase[4] = (u32) NULL;
			pResources->dwWdTimerDspBase = NULL;
			pResources->dwDmmuBase = NULL;

			dwBuffSize = sizeof(struct CFG_HOSTRES);
			status = REG_SetValue(NULL, (char *)driverExt->szString,
				 CURRENTCONFIG, REG_BINARY, (u8 *)pResources,
				 (u32)dwBuffSize);
			/*  Set all the other entries to NULL */
			MEM_Free(pResources);
		}
		GT_0trace(curTrace, GT_ENTER, " <- RequestBridgeResources \n");
		return status;
	}
	dwBuffSize = sizeof(struct CFG_HOSTRES);
	pResources = MEM_Calloc(dwBuffSize, MEM_NONPAGED);
	if (pResources != NULL) {
		/* wNumMemWindows must not be more than CFG_MAXMEMREGISTERS */
		pResources->wNumMemWindows = 2;
		/* First window is for DSP internal memory */

		pResources->dwPrmBase = ioremap(OMAP_IVA2_PRM_BASE,
							OMAP_IVA2_PRM_SIZE);

#ifdef OMAP44XX
                pResources->dwCm1Base = (u32)ioremap(OMAP_IVA2_CM1_BASE,
                                                        OMAP_IVA2_CM1_SIZE);
                pResources->dwCm2Base = (u32)ioremap(OMAP_IVA2_CM2_BASE,
                                                        OMAP_IVA2_CM2_SIZE);
#else
				pResources->dwCmBase = ioremap(OMAP_IVA2_CM_BASE,
													OMAP_IVA2_CM_SIZE);
#endif

		pResources->dwMboxBase = ioremap(OMAP_MBOX_BASE,
							OMAP_MBOX_SIZE);
		pResources->dwSysCtrlBase = ioremap(OMAP_SYSC_BASE,
							OMAP_SYSC_SIZE);
		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[0] 0x%x\n",
			 pResources->dwMemBase[0]);
		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[3] 0x%x\n",
			 pResources->dwMemBase[3]);
		GT_1trace(curTrace, GT_2CLASS, "dwPrmBase 0x%x\n",
							pResources->dwPrmBase);
#ifdef OMAP44XX
		GT_1trace(curTrace, GT_2CLASS, "dwCm1Base 0x%x\n",
							pResources->dwCm1Base);
		GT_1trace(curTrace, GT_2CLASS, "dwCm2Base 0x%x\n",
							pResources->dwCm2Base);
#else
		GT_1trace(curTrace, GT_2CLASS, "dwCmBase 0x%x\n",
							pResources->dwCmBase);
#endif
		GT_1trace(curTrace, GT_2CLASS, "dwWdTimerDspBase 0x%x\n",
						pResources->dwWdTimerDspBase);
		GT_1trace(curTrace, GT_2CLASS, "dwMboxBase 0x%x\n",
						pResources->dwMboxBase);
		GT_1trace(curTrace, GT_2CLASS, "dwDmmuBase 0x%x\n",
						pResources->dwDmmuBase);

		/* for 24xx base port is not mapping the mamory for DSP
		 * internal memory TODO Do a ioremap here */
		/* Second window is for DSP external memory shared with MPU */
		if (DSP_SUCCEEDED(status)) {
			/* for Linux, these are hard-coded values */
			pResources->bIRQRegisters = 0;
			pResources->bIRQAttrib = 0;
			pResources->dwOffsetForMonitor = 0;
			pResources->dwChnlOffset = 0;
			/* CHNL_MAXCHANNELS */
			pResources->dwNumChnls = CHNL_MAXCHANNELS;
			pResources->dwChnlBufSize = 0x400;
			dwBuffSize = sizeof(struct CFG_HOSTRES);
			status = REG_SetValue(NULL, (char *) dwContext,
					     CURRENTCONFIG, REG_BINARY,
					     (u8 *)pResources,
					     sizeof(struct CFG_HOSTRES));
			if (DSP_SUCCEEDED(status)) {
				GT_0trace(curTrace, GT_1CLASS,
					 " Successfully set the registry "
					 "value for CURRENTCONFIG\n");
			} else {
				GT_0trace(curTrace, GT_7CLASS,
					 " Failed to set the registry "
					 "value for CURRENTCONFIG\n");
			}
		}
		MEM_Free(pResources);
	}
	/* End Mem alloc */
	return status;
}

/*
 *  ======== RequestBridgeResourcesDSP ========
 *  Purpose:
 *      Reserves shared memory for bridge.
 */
static DSP_STATUS RequestBridgeResourcesDSP(u32 dwContext, s32 bRequest)
{
	DSP_STATUS status = DSP_SOK;
	struct CFG_HOSTRES *pResources;
	u32 dwBuffSize;
	u32 dmaAddr;
	u32 shm_size;

	DBC_Require(dwContext != 0);

	GT_0trace(curTrace, GT_ENTER, "->RequestBridgeResourcesDSP \n");

	dwBuffSize = sizeof(struct CFG_HOSTRES);

	pResources = MEM_Calloc(dwBuffSize, MEM_NONPAGED);

	if (pResources != NULL) {
		if (DSP_FAILED(CFG_GetHostResources((struct CFG_DEVNODE *)
		   dwContext, pResources))) {
			/* Call CFG_GetHostResources to get reserve resouces */
			status = RequestBridgeResources(dwContext, bRequest);
			if (DSP_SUCCEEDED(status)) {
				status = CFG_GetHostResources
					((struct CFG_DEVNODE *) dwContext,
					pResources);
			}
		}
		/* wNumMemWindows must not be more than CFG_MAXMEMREGISTERS */
		pResources->wNumMemWindows = 4;

		pResources->dwMemBase[0] = 0;
		pResources->dwMemBase[2] = (u32)ioremap(OMAP_DSP_MEM1_BASE,
							OMAP_DSP_MEM1_SIZE);
		pResources->dwMemBase[3] = (u32)ioremap(OMAP_DSP_MEM2_BASE,
							OMAP_DSP_MEM2_SIZE);
		pResources->dwMemBase[4] = (u32)ioremap(OMAP_DSP_MEM3_BASE,
							OMAP_DSP_MEM3_SIZE);
#ifdef OMAP_3430
		pResources->dwPerBase = ioremap(OMAP_PER_CM_BASE,
							OMAP_PER_CM_SIZE);
        pResources->dwPerPmBase = (u32)ioremap(OMAP_PER_PRM_BASE,
                                                     OMAP_PER_PRM_SIZE);
        pResources->dwCorePmBase = (u32)ioremap(OMAP_CORE_PRM_BASE,
                                                       OMAP_CORE_PRM_SIZE);
#else

        pResources->dwCm1Base = (u32)ioremap(OMAP_IVA2_CM1_BASE,
                            OMAP_IVA2_CM1_SIZE);
        pResources->dwCm2Base = (u32)ioremap(OMAP_IVA2_CM2_BASE,
                            OMAP_IVA2_CM2_SIZE);
#endif
		pResources->dwDmmuBase = ioremap(OMAP_DMMU_BASE,
							OMAP_DMMU_SIZE);
		pResources->dwWdTimerDspBase = NULL;

		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[0] 0x%x\n",
						pResources->dwMemBase[0]);
		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[1] 0x%x\n",
						pResources->dwMemBase[1]);
		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[2] 0x%x\n",
						pResources->dwMemBase[2]);
		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[3] 0x%x\n",
						pResources->dwMemBase[3]);
		GT_1trace(curTrace, GT_2CLASS, "dwMemBase[4] 0x%x\n",
						pResources->dwMemBase[4]);
		GT_1trace(curTrace, GT_2CLASS, "dwPrmBase 0x%x\n",
						pResources->dwPrmBase);
#ifdef OMAP44XX
		GT_1trace(curTrace, GT_2CLASS, "dwCm1Base 0x%x\n",
							pResources->dwCm1Base);
		GT_1trace(curTrace, GT_2CLASS, "dwCm2Base 0x%x\n",
							pResources->dwCm2Base);
#else
		GT_1trace(curTrace, GT_2CLASS, "dwCmBase 0x%x\n",
						pResources->dwCmBase);
#endif
		GT_1trace(curTrace, GT_2CLASS, "dwWdTimerDspBase 0x%x\n",
						pResources->dwWdTimerDspBase);
		GT_1trace(curTrace, GT_2CLASS, "dwMboxBase 0x%x\n",
						pResources->dwMboxBase);
		GT_1trace(curTrace, GT_2CLASS, "dwDmmuBase 0x%x\n",
						pResources->dwDmmuBase);
		dwBuffSize = sizeof(shm_size);
		status = REG_GetValue(NULL, CURRENTCONFIG, SHMSIZE,
				     (u8 *)&shm_size, &dwBuffSize);
		if (DSP_SUCCEEDED(status)) {
			/* Allocate Physically contiguous,
			 * non-cacheable  memory */
			pResources->dwMemBase[1] =
				(u32)MEM_AllocPhysMem(shm_size, 0x100000,
							&dmaAddr);
			if (pResources->dwMemBase[1] == 0) {
				status = DSP_EMEMORY;
				GT_0trace(curTrace, GT_7CLASS,
					 "SHM reservation Failed\n");
			} else {
				pResources->dwMemLength[1] = shm_size;
				pResources->dwMemPhys[1] = dmaAddr;

				GT_3trace(curTrace, GT_1CLASS,
					 "Bridge SHM address 0x%x dmaAddr"
					 " %x size %x\n",
					 pResources->dwMemBase[1],
					 dmaAddr, shm_size);
			}
		}
		if (DSP_SUCCEEDED(status)) {
			/* for Linux, these are hard-coded values */
			pResources->bIRQRegisters = 0;
			pResources->bIRQAttrib = 0;
			pResources->dwOffsetForMonitor = 0;
			pResources->dwChnlOffset = 0;
			/* CHNL_MAXCHANNELS */
			pResources->dwNumChnls = CHNL_MAXCHANNELS;
			pResources->dwChnlBufSize = 0x400;
			dwBuffSize = sizeof(struct CFG_HOSTRES);
			status = REG_SetValue(NULL, (char *)dwContext,
					     CURRENTCONFIG, REG_BINARY,
					     (u8 *)pResources,
					     sizeof(struct CFG_HOSTRES));
			if (DSP_SUCCEEDED(status)) {
				GT_0trace(curTrace, GT_1CLASS,
					 " Successfully set the registry"
					 " value for CURRENTCONFIG\n");
			} else {
				GT_0trace(curTrace, GT_7CLASS,
					 " Failed to set the registry value"
					 " for CURRENTCONFIG\n");
			}
		}
		MEM_Free(pResources);
	}
	/* End Mem alloc */
	return status;
}