tmman.c

wince host 和 target PCI驱动程序

/*
	tmman.c

	TriMedia Manager DSP Interface



	HISTORY
	960531	Tilakraj Roy	Created
	960602	Tilakraj Roy	Updated to map to ipcXXX interface 
	960913	Tilakraj Roy	Added functions to support tmman v4.0
	970523	Tilakraj Roy	Rewrite for generic host support 
	970707	Tilakraj Roy	Ported to multiple peocessor interfaces
	970711	Tilakraj Roy	Changed for running on TM1 target tmman v5.0
*/

/* standard external includes */
#include "stdio.h"
#include "stdarg.h"

#include "tmmanapi.h"
#include "tmmanlib.h"
#include "platform.h"
#include "tm1/mmio.h"


extern	Address	TMManShared[];
UInt8*	volatile RealTMManShared = (UInt8*)TMManShared;

UInt32 _TMMan_Version = ( constTMManDefaultVersionMajor  << 16 ) | constTMManDefaultVersionMinor;

/* Globals to be used by candidates contending for MMIO->BIU->INT_CTL */
UInt32* Host2TargetIntPtr = 0;
UInt32* Target2HostIntPtr = 0;

/* Global Arrary containing DSP / Board specific in formation */
/* this is the only global structure in the progaram */

TMManObject		TMManArray[1];

Pointer	tmmanInit(
	UInt32 DSPNumber,
	Pointer Configuration )
{
	TMStatus					Status;
	halParameters				HalParameters;
	channelManagerParameters	ChannelParameters;
	vintrManagerParameters		VIntrParameters;
	eventManagerParameters		EventParameters;
	debugParameters				DebugParameters;
	messageManagerParameters	MessageParameters;
	memoryManagerParameters		MemoryParameters;
	namespaceManagerParameters	NameSpaceParameters;
	sgbufferManagerParameters	SGBufferParameters;



	TMManObject *TMMan = &TMManArray[DSPNumber];


	/* on the target there is only one board to deal with */
	if ( DSPNumber != 0 )
		return False;

	TMMan->SharedData = (TMManSharedStruct*)RealTMManShared;


    *(UInt32*)( ((char*)_MMIO_base) + DC_LOCK_CTL) = 
		/* read the value of DC_LOCK_CTL - retain all bits except bits 5 & 6 */
		( ( (*(UInt32*)( ((char*)_MMIO_base) + DC_LOCK_CTL)) & (~constTMManDC_LOCK_CTL_MASK) ) | 
		/* or it with the new values of bits 5 & 6 */
        ( constTMManDC_LOCK_CTL_MASK  & ( ( constTMManDC_LOCK_CTL_HEN ) << constTMManDC_LOCK_CTL_POSITION ) ) );

	/* BEGIN SHARED MEMEORY ACCESS */

	DebugParameters.TraceBufferSize = TMMan->SharedData->TargetTraceBufferSize;
    DebugParameters.LevelBitmap = TMMan->SharedData->TargetTraceLeveBitmap;
    DebugParameters.Type = TMMan->SharedData->TargetTraceType;

	/* endianness swap is not required here since target always its own endinness */
	/*HalParameters.CPURevision = TMMan->SharedData->CPURevision;
	HalParameters.BoardRevision = TMMan->SharedData->BoardRevision; */

	HalParameters.SharedData = (Pointer)TMMan->SharedData->HalShared;
	HalParameters.SpeculativeLoadFix = TMMan->SharedData->SpeculativeLoadFix;
	HalParameters.PCIIrq = TMMan->SharedData->PCIInterruptNumber;
	HalParameters.TMIrq = TMMan->SharedData->MMIOInterruptNumber;

	if ( HalParameters.SpeculativeLoadFix )
	{
		*(UInt32*)( ((char*)_MMIO_base)  + DC_LOCK_CTL) = 
			/* read the value of DC_LOCK_CTL - retain all bits except bits 5 & 6 */
			( ( (*(UInt32*)( ((char*)_MMIO_base) + DC_LOCK_CTL)) & (~constTMManDC_LOCK_CTL_MASK) ) | 
			/* or it with the new values of bits 5 & 6 */
			( constTMManDC_LOCK_CTL_MASK  & ( ( constTMManDC_LOCK_CTL_PDS ) << constTMManDC_LOCK_CTL_POSITION ) ) );
	}

	/* END SHARED MEMORY ACCESS */

	/* until symbol patching everything is debugged  use this */
	debugInit ( &DebugParameters );

/*
	*(UInt32*) ( ((char*)_MMIO_base) + INT_CTL ) = 
		*(UInt32*)( ((char*)_MMIO_base) + INT_CTL) | ( 1 ) | ( 0x10 );
*/

	TMMan->DSPNumber = DSPNumber;
	TMMan->HalHandle = 0;
	TMMan->ChannelManagerHandle = 0;
	TMMan->VIntrManagerHandle = 0;
	TMMan->MessageManagerHandle = 0;
	TMMan->EventManagerHandle = 0;
	TMMan->MessageManagerHandle = 0;
	TMMan->MemoryManagerHandle = 0;
	TMMan->NameSpaceManagerHandle = 0;
	TMMan->SGBufferManagerHandle = 0;

	HalParameters.MMIOBase = (UInt32) _MMIO_base;
	HalParameters.MMIOLength = 0x200000; /* HARDCODED */
	HalParameters.DSPNumber = DSPNumber;


	if ( ( Status = halCreate ( &HalParameters, &TMMan->HalHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:halCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit1;
	}

	halAccessEnable ( TMMan->HalHandle );

	DPF(0,("tmman:TimeStamp:[%x]:[%x]\n", 
		TMMan->SharedData->DebuggingHi, TMMan->SharedData->DebuggingLo ));

	/* debugInit ( &DebugParameters ); */
	DPF(1,("tmman:TMManShared:[%x]\n",
		RealTMManShared ));
	DPF(1,("tmman:TMManShared:HostKernelMajorVersion[%x]\n",
		TMMan->SharedData->HostKernelMajorVersion ));
	DPF(1,("tmman:TMManShared:HostKernelMinorVersion[%x]\n",
		TMMan->SharedData->HostKernelMinorVersion ));
	DPF(1,("tmman:TMManShared:TargetKernelMajorVersion[%x]\n",
		TMMan->SharedData->TargetKernelMajorVersion ));
	DPF(1,("tmman:TMManShared:TargetKernelMinorVersion[%x]\n",
		TMMan->SharedData->TargetKernelMinorVersion ));
	DPF(1,("tmman:TMManShared:HalShared[%x]\n",
		TMMan->SharedData->HalShared ));
	DPF(1,("tmman:TMManShared:ChannelShared[%x]\n",
		TMMan->SharedData->ChannelShared ));
	DPF(1,("tmman:TMManShared:VIntrShared[%x]\n",
		TMMan->SharedData->VIntrShared ));
	DPF(1,("tmman:TMManShared:EventShared[%x]\n",
		TMMan->SharedData->EventShared ));
	DPF(1,("tmman:TMManShared:DebugShared[%x]\n",
		TMMan->SharedData->DebugShared ));
	DPF(1,("tmman:TMManShared:MemoryShared[%x]\n",
		TMMan->SharedData->MemoryShared ));
	DPF(1,("tmman:TMManShared:NameSpaceShared[%x]\n",
		TMMan->SharedData->NameSpaceShared ));
	DPF(1,("tmman:TMManShared:SGBufferShared[%x]\n",
		TMMan->SharedData->SGBufferShared ));

	DPF(1,("tmman:TMManShared:TMDeviceVendorID[%x]\n",
		TMMan->SharedData->TMDeviceVendorID ));
	DPF(1,("tmman:TMManShared:TMSubsystemID[%x]\n",
		TMMan->SharedData->TMSubsystemID ));
	DPF(1,("tmman:TMManShared:TMClassRevisionID[%x]\n",
		TMMan->SharedData->TMClassRevisionID ));
	DPF(1,("tmman:TMManShared:BridgeDeviceVendorID[%x]\n",
		TMMan->SharedData->BridgeDeviceVendorID ));
	DPF(1,("tmman:TMManShared:BridgeSubsystemID[%x]\n",
		TMMan->SharedData->BridgeSubsystemID ));
	DPF(1,("tmman:TMManShared:BridgeClassRevisionID[%x]\n",
		TMMan->SharedData->BridgeClassRevisionID ));

	DPF(1,("tmman:TMManShared:TargetTraceBufferSize[%x]\n",
		TMMan->SharedData->TargetTraceBufferSize ));
	DPF(1,("tmman:TMManShared:TargetTraceLeveBitmap[%x]\n",
		TMMan->SharedData->TargetTraceLeveBitmap ));
	DPF(1,("tmman:TMManShared:TargetTraceType[%x]\n",
		TMMan->SharedData->TargetTraceType ));
	DPF(1,("tmman:TMManShared:SpeculativeLoadFix[%x]\n",
		TMMan->SharedData->SpeculativeLoadFix ));

	halAccessDisable ( TMMan->HalHandle );

	NameSpaceParameters.HalHandle = TMMan->HalHandle;

	halAccessEnable ( TMMan->HalHandle );
	NameSpaceParameters.NameSpaceCount = TMMan->SharedData->TMManNameSpaceCount;
	NameSpaceParameters.SharedData = (Pointer)TMMan->SharedData->NameSpaceShared;
	halAccessDisable ( TMMan->HalHandle );

	if ( namespaceManagerCreate ( 
		&NameSpaceParameters,
		&TMMan->NameSpaceManagerHandle ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:namespaceCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit2;		
	}


	halAccessEnable ( TMMan->HalHandle );
	MemoryParameters.MemoryCount = TMMan->SharedData->TMManMemoryCount;
	MemoryParameters.MemorySize = TMMan->SharedData->TMManMemorySize;
	MemoryParameters.SharedData = (Pointer)TMMan->SharedData->MemoryShared;
	MemoryParameters.MemoryBlock = (Pointer)TMMan->SharedData->MemoryBlock;
	halAccessDisable ( TMMan->HalHandle );

	MemoryParameters.HalHandle = TMMan->HalHandle;
	MemoryParameters.NameSpaceManagerHandle = TMMan->NameSpaceManagerHandle;

	if ( memoryManagerCreate ( 
		&MemoryParameters,
		&TMMan->MemoryManagerHandle ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:memoryManagerCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit3;
	}

	halAccessEnable ( TMMan->HalHandle );
	VIntrParameters.VIntrCount = TMMan->SharedData->TMManVIntrCount;
	VIntrParameters.SharedData = (Pointer)TMMan->SharedData->VIntrShared; 
	halAccessDisable ( TMMan->HalHandle );

	VIntrParameters.HalHandle = TMMan->HalHandle;

	if ( ( Status = vintrManagerCreate ( 
		&VIntrParameters,
		&TMMan->VIntrManagerHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:vintrManagerCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit4;
	}

	halAccessEnable ( TMMan->HalHandle );
	ChannelParameters.ChannelCount = TMMan->SharedData->TMManChannelCount; 
	ChannelParameters.MailboxCount = TMMan->SharedData->TMManMailboxCount;
	ChannelParameters.SharedData = (Pointer)TMMan->SharedData->ChannelShared;
	halAccessDisable ( TMMan->HalHandle );

	ChannelParameters.PacketSize = constTMManPacketSize;
	ChannelParameters.HalHandle = TMMan->HalHandle;
	ChannelParameters.VIntrManagerHandle = TMMan->VIntrManagerHandle;
	ChannelParameters.NameSpaceManagerHandle = TMMan->NameSpaceManagerHandle;


	if ( ( Status = channelManagerCreate ( 
		&ChannelParameters,
		&TMMan->ChannelManagerHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:channelManagerCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit5;
	}

	halAccessEnable ( TMMan->HalHandle );
	EventParameters.EventCount = TMMan->SharedData->TMManEventCount; 
	EventParameters.SharedData = (Pointer)TMMan->SharedData->EventShared;
	halAccessDisable ( TMMan->HalHandle );

	EventParameters.HalHandle = TMMan->HalHandle;
	EventParameters.VIntrManagerHandle = TMMan->VIntrManagerHandle;
	EventParameters.NameSpaceManagerHandle = TMMan->NameSpaceManagerHandle;

	if ( ( Status = eventManagerCreate ( 
		&EventParameters,
		&TMMan->EventManagerHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:eventManagerCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit6;
	}

	halAccessEnable ( TMMan->HalHandle );
	MessageParameters.MessageCount = TMMan->SharedData->TMManMessageCount; 
	halAccessDisable ( TMMan->HalHandle );

	MessageParameters.PacketSize = constTMManPacketSize;
	MessageParameters.HalHandle = TMMan->HalHandle;
	MessageParameters.ChannelManagerHandle = TMMan->ChannelManagerHandle;
	MessageParameters.NameSpaceManagerHandle = TMMan->NameSpaceManagerHandle;


	if ( ( Status = messageManagerCreate ( 
		&MessageParameters,
		&TMMan->MessageManagerHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:messageManagerCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit7;
	}

	halAccessEnable ( TMMan->HalHandle );
	SGBufferParameters.SGBufferCount = TMMan->SharedData->TMManSGBufferCount;
	halAccessDisable ( TMMan->HalHandle );

	SGBufferParameters.HalHandle = TMMan->HalHandle;
	SGBufferParameters.MemoryManagerHandle = TMMan->MemoryManagerHandle;
	SGBufferParameters.NameSpaceManagerHandle = TMMan->NameSpaceManagerHandle;

	if ( sgbufferManagerCreate ( 
		&SGBufferParameters,
		&TMMan->SGBufferManagerHandle ) != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:sgbufferManagerCreate:FAIL[%x]\n",Status ));
		goto tmmanInitExit8;
	}


	return TMMan;
/*
tmmanInitExit9:
	sgbufferManagerDestroy ( TMMan->SGBufferManagerHandle );
*/

tmmanInitExit8:
	messageManagerDestroy ( TMMan->MessageManagerHandle );

tmmanInitExit7:
	eventManagerDestroy ( TMMan->EventManagerHandle );

tmmanInitExit6:
	channelManagerDestroy ( TMMan->ChannelManagerHandle );

tmmanInitExit5:
	vintrManagerDestroy ( TMMan->VIntrManagerHandle );

tmmanInitExit4:
	memoryManagerDestroy ( TMMan->MemoryManagerHandle );

tmmanInitExit3:
	namespaceManagerDestroy ( TMMan->NameSpaceManagerHandle );

tmmanInitExit2:
	halDestroy ( TMMan->HalHandle );

tmmanInitExit1:
	return Null;
}

void	tmmanExit (  UInt32 DSPNumber )
{


	TMManObject *TMMan = &TMManArray[DSPNumber];

	messageManagerDestroy ( TMMan->MessageManagerHandle );

	eventManagerDestroy ( TMMan->EventManagerHandle );

	channelManagerDestroy ( TMMan->ChannelManagerHandle );

	vintrManagerDestroy ( TMMan->VIntrManagerHandle );

	memoryManagerDestroy ( TMMan->MemoryManagerHandle );

	namespaceManagerDestroy ( TMMan->NameSpaceManagerHandle );

	halDestroy ( TMMan->HalHandle );

}


/* DSP related API. */

Int8*	tmmanGetErrorString (
	TMStatus	StatusCode )
{
	return (Int8*)errorGetErrorString(StatusCode);
}

TMStatus  tmmanNegotiateVersion ( 
	UInt32	ModuleID, 
	tmmanVersion* Version )
{
	TMStatus				Status = statusSuccess;
	tmmanVersion			ReturnedVersion;
	TMManObject *TMMan = &TMManArray[0];

	switch ( ModuleID )
	{

		case constTMManModuleTargetKernel :
		case constTMManModuleTargetUser :
		case	constTMManDefault :
		ReturnedVersion.Major = verGetFileMajorVersion();
		ReturnedVersion.Minor = verGetFileMinorVersion();
		ReturnedVersion.Build = verGetFileBuildVersion();

		if ( Version->Major < verGetFileMajorVersion()  )
		{
			DPF(0,("tmman:tmmanNegotiateVersion:MajorVesion:FAIL\n" ));
			Status = statusMajorVersionError;
			goto tmmanNegotiateVersionExit1;
		}

		if ( Version->Minor < verGetFileMinorVersion() )
		{
			DPF(0,("tmman:tmmanNegotiateVersion:MinorVesion:FAIL\n" ));
			Status = statusMinorVersionError;
			goto tmmanNegotiateVersionExit1;
		}
		break;

		case	constTMManModuleHostUser :
		case	constTMManModuleHostKernel :
		ReturnedVersion.Major = TMMan->SharedData->HostKernelMajorVersion;
		ReturnedVersion.Minor = TMMan->SharedData->HostKernelMinorVersion;
		ReturnedVersion.Build = 0;
		break;

		default :
		Status  = statusUnknownComponent;
		break;
	}


tmmanNegotiateVersionExit1: