tmman.c

wince host 和 target PCI驱动程序

/*
	TriMedia MANager DSP Interface

	HISTORY
	#define TR	Tilakraj Roy
	960531	TR	Created
	960602	TR	Updated to map to ipcXXX interface 
	960913	TR	Added functions to support tmman v4.0
	980226	TR	Added MaxMessageCount & MaxTaskCount
	980227	TR	Changed format of DT to pass level seperately.

*/

/* standard external includes */
#include "tmman.h"
#include "tmdbg.h"
#include "tmhd.h"


/* internal includes */
#include "tmmmio.h"
#include "tmhal.h"
#include "tmhd.h"
#include "tmipc.h"
#include "tmchnl.h"
#include "tmmsg.h"

#include "tmlib/IODrivers.h"
#include "tmlib/HostCall.h"
#include "tm1/tmProcessor.h"
#include "errno.h"


#include "stdio.h"


/*
	tmInitilize
	This funciton is called in by the RTOS root task. No parameters are passed
	to this function.
	This value of the global variable "tmmanParameterBlock" is pathced by the
	host based loader at the time of loading the combined RTOS + libtmman.a
	image. So (tmmanParameterBlock)->XXXXXXXXXXX can be
	used to access all the parameters that are passed by the host to the 
	target. 

	After the tmman system task is created with the RTOS, and all the protocol
	layers are initialized, the target ( slave ) should send an interrupt to
	the host advising it that it is ready to accept commands.

*/


/*
typedef struct _TMHD_TMMAN_PARAMETER_BLOCK
{
	DWORD	Flags;
	DWORD	Size;
	DWORD	MMIOBase;
	DWORD	SDRAMBase;
	DWORD	SDRAMSize;
	DWORD	HostInterrupt;
	DWORD	IPCSharedMem;

	DWORD	ChnlSharedMem;
	DWORD	ChnlCount;

	DWORD	MsgCount;

	DWORD	StrmCount;
	DWORD	SharedMemBuffer;
}	TMHD_TMMAN_PARAMETER_BLOCK, *PTMHD_TMMAN_PARAMETER_BLOCK;
*/

typedef struct _TMMAN_GLOBAL_STRUCT
{

	TMSTD_VERSION_INFO	HostVersion;
		
	PVOID				pHAL;
	PVOID				pIPC;
	PVOID				pMsgMgr;
	PVOID				pChnlMgr;

	PTMCHNL_OBJECT		pChnlToHost;
	PTMCHNL_OBJECT		pChnlFromHost;

	PDWORD				pParameterDWORD;
	DWORD				ParameterCount;

	DWORD				MessageCount;
	DWORD				TaskCount;

}	TMMAN_GLOBAL_STRUCT, *PTMMAN_GLOBAL_STRUCT;

/* GLOBAL VARIABLES */
TMMAN_GLOBAL_STRUCT		Global;

extern PTMHD_BOARD_SHARED TMMANSharedPatch[];
PTMHD_BOARD_SHARED	TMMANShared = TMMANSharedPatch;

volatile DWORD _TMMan_Version = ( TMSTD_MAJOR_VERSION  << 16 ) | TMSTD_MINOR_VERSION;
volatile DWORD DummyVersion;

DWORD Host2TargetIntPtr = 0;
DWORD Target2HostIntPtr = 0;

DWORD	*MMIODebugPtr;

custom_op DWORD cycles(VOID);



/*(xtern PVOID PTMHD_BOARD_SHARED	TMMANShared[]; */

extern	PBYTE	_MMIO_base;
/*
	this global symbol points to the base of the parameter table that 
	is used to pass parameters to all the other objects in TMManager 
	This symbol is patched by the loader at the time of image downloading.
*/
PVOID	TMManParams = NULL;

PCHAR CPUType[] = {
	"TM1000 \0",
	"TM1000 S\0",
	"TM1100 \0",
	"Unknown\0"
};

PCHAR FabType[] = {
	"ST\0",
	"MOS4\0",
	"TSMC\0",
	"Unkown\0"
};


STATUS	tmTMMANOnRecvPacket ( PVOID pContext, PVOID pPacketArg )
{
	PVOID pChnl			= *(PVOID *)pContext;
	PTMSTD_PACKET pPacket  = (PTMSTD_PACKET)pPacketArg;

	DT(11,( "tmman:tmTMMANOnRecvPacket:Msg[%x]:Arg0[%x]:Arg1[%x]:Arg2[%x]\n",
		pPacket->dwCommand,
		pPacket->dwArgument[0],
		pPacket->dwArgument[1],
		pPacket->dwArgument[2] ));
	return TMOK;
}

PVOID	GetIPCObject ( VOID )
{
	return Global.pIPC;
}

PVOID	GetChnlMgrObject ( VOID )
{
	return Global.pChnlMgr;
}

PVOID	GetMsgMgrObject ( VOID )
{
	return Global.pMsgMgr;
}

PVOID	GetHalObject ( VOID )
{
	return Global.pHAL;
}

STATUS tmTMMANOnSendReady ( DWORD Handle, PVOID pContext )
{
	return TMOK;
}

BOOL	tmTMMANCreate ( VOID )
{
	STATUS	Status;
	
	DWORD	Options,Idx;
	DWORD	CPU;
	DWORD	Dummy;

	MMIODebugPtr = (DWORD*)( ((PBYTE)_MMIO_base) + 0x00102010);

	/* *MMIODebugPtr = 0x12345678; */

	DummyVersion = Dummy = _TMMan_Version;
	_TMMan_Version = _TMMan_Version;

	/* this will be read by the host to verify that the right version of target is running */
	TMMANShared->TargetVersion.dwMajor = verGetFileMajorVersion();
	TMMANShared->TargetVersion.dwMinor = verGetFileMinorVersion();
	TMMANShared->TargetVersion.dwBuild = verGetFileBuildVersion();

	/* the host will zero out the above structure before the target is run */

	Global.pParameterDWORD = TMMANShared->Parameter;
	Global.ParameterCount = TMHD_PARAM_COUNT;
	Global.HostVersion = TMMANShared->HostVersion;
	Global.MessageCount = 0x20;
	Global.TaskCount = 0x10;

	/* dbgInit ( &pDBG ); */
	
	/* cannot use print before C runtime library is up and hopefully running 
	Options = tmDBGOptions( 0 );
	tmDBGOptions( Options & ~(TMSTD_DBG_OPTIONSTDOUT | TMSTD_DBG_OPTIONSTDERR) ); 
	*/

	DT (0, ("tmman:TARGET:Version[%d.%d.%d]\n", 
		verGetFileMajorVersion(), verGetFileMinorVersion(), verGetFileBuildVersion() ));

	DT (0, ("tmman:TMMANShared[%x]\n", TMMANShared ));
		
	DT (0, ("tmman:HOST:Version[%d.%d.%d]:Type[%s1.%d %s]\n",
		TMMANShared->HostVersion.dwMajor,
		TMMANShared->HostVersion.dwMinor,
		TMMANShared->HostVersion.dwBuild,
		CPUType[TMSTD_GETTMTYPE(TMMANShared->CPUVersion)],
		TMSTD_GETTMREV(TMMANShared->CPUVersion),
		FabType[TMSTD_GETTMFAB(TMMANShared->CPUVersion)] ));

	DT (0, ("tmman:MessageCount[%x]\n", Global.MessageCount ));
	DT (0, ("tmman:TaskCount[%x]\n", Global.TaskCount ));
	for ( Idx = 0 ; Idx < 10 ; Idx ++ )
		DT(11, ("tmman:Param[%x] [%x]\n", Idx, TMMANShared->Parameter[Idx] ));

	Global.pHAL = NULL;

	if ( ( Status = halCreate ( 
	*((PDWORD)(((PBYTE)_MMIO_base) + 0x100000)), _MMIO_base,
		TMMANShared->CPUVersion, &Global.pHAL ) ) != TMOK )
	{
		DT(0, ("tmman:tmTMMANCreate:halCreate:FAIL[%x]\n", Status ));
	}


	Global.pIPC = NULL;

	if ( ( Status = ipcCreate ( &Global.pIPC, TMMANShared->CPUVersion ) ) != TMOK )
	{
		DT(0, ("tmman:tmTMMANCreate:ipcCreate:FAIL[%x]\n", Status ));
	}

	Global.pChnlMgr = NULL;

	if ( (Status = 
		chnlmCreate ( &Global, ( Global.MessageCount * 2 ), (PVOID *)&Global.pChnlMgr ) ) != TMOK )
	{
		DT(0,  ("tmman:tmTMMANCreate:chnlmCreate:FAIL[%x]\n", Status ));
	}

	Global.pMsgMgr = NULL;

	if ( (Status = 
		msgmCreate ( &Global, Global.MessageCount, (PVOID *)&Global.pMsgMgr ) ) != TMOK )
	{
		DT(0,  ("tmman:tmTMMANCreate:msgmCreate:FAIL[%x]\n", Status ));
	}
	
	/*
	tmDBGOptions( Options );
	
	*MMIODebugPtr = 0x1234567c;
	*/

	return TRUE;
}

BOOL	tmTMMANDestroy ( VOID )
{
	msgmDestroy ( Global.pMsgMgr );
	chnlmDestroy ( Global.pChnlMgr );
	ipcDestroy ( Global.pIPC );
	halDestroy ( Global.pHAL );
	return TRUE;
}

STATUS	tmNegotiateVersion ( PTMSTD_VERSION_INFO Version )
{
	STATUS	Status = TMOK;

	if ( Version->dwMajor != verGetFileMajorVersion() )
	{
		Status = TM_STATUS ( TMMAN_ERR_INCOMPATIBLEVERSION );
		DT(0,  ("tmman:tmNegotiateVersion:MajorVersion:FAIL\n" ));
		goto tmNegotiateVersionExit1;
	}

	if ( Version->dwMinor != verGetFileMinorVersion()  )
	{
		Status = TM_STATUS ( TMMAN_ERR_INCOMPATIBLEVERSION );
		DT(0,  ("tmman:tmNegotiateVersion:MinorVersion:FAIL\n" ));
		goto tmNegotiateVersionExit1;
	}

tmNegotiateVersionExit1 :
	Version->dwMajor = verGetFileMajorVersion();
	Version->dwMinor = verGetFileMinorVersion();
	Version->dwBuild = verGetFileBuildVersion();
	return Status;
}


/* EXPORTED INTERFACES */
STATUS	tmDSPOpen  ( DWORD DSPNumer, PDWORD pDSPHandle )
{
	TMSTD_VERSION_INFO Version;
	STATUS	Status;
/*
	Version = Global.HostVersion;
	if ( ( Status = tmNegotiateVersion ( &Version ) ) != TMOK )
	{
		DT (0, ("tmman:tmDSPOpen:Incompaitle Version of vtmman.vxd:FAIL[%x]\n",Status ));
		return Status;
	}
*/
	*pDSPHandle = 0;
	return TMOK;	
}

STATUS	tmDSPGetCaps  ( DWORD DSPHandle, PTMMAN_DSP_CAPS pDSPCaps )
{
    pprocCapabilities_t caps;
    procGetCapabilities(&caps);


    pDSPCaps->CPUVersion = TMMANShared->CPUVersion;
    pDSPCaps->SDRAM = TMMANShared->SDRAM;
    pDSPCaps->MMIO = TMMANShared->MMIO;
    pDSPCaps->User = TMMANShared->User;
	pDSPCaps->ClockFreq= caps->cpuClockFrequency;
	return TMOK;
}

STATUS	tmDSPClose  ( DWORD DSPHandle )
{
	return TMOK;	
}