tmman.c

PNX系列设备驱动 PNX系列设备驱动

/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1997 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
----------------------------------------------------------------------------*/
/*
	HISTORY
	970804	Tilakraj Roy	Created from vtmman sources for NT Workstation
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#define WANTVXDWRAPS 
#include <basedef.h>
#include <vmm.h>
#include <vmmreg.h>
#include <vxdwraps.h>
#include <vpicd.h>
#include <configmg.h>
#include <vwin32.h>

#include "vxstd.h"
#include "vxwin.h"
/*----------------------------------------------------------------------------
          DRIVER SPECIFIC INCLUDE FILES
----------------------------------------------------------------------------*/
#include "tmmanapi.h"
#include "tmmanlib.h"
#include "platform.h"

/*----------------------------------------------------------------------------
          GLOBAL DATA STRUCTURE INSTANSCIATION
----------------------------------------------------------------------------*/
GlobalObject *TMManGlobal;


/*----------------------------------------------------------------------------
          FUNCTION PROTOTYPES
----------------------------------------------------------------------------*/
/*
DWORD DriverEntry(
	VOID );

VOID DriverExit(
    VOID );
*/

BOOLEAN RegistryReadDWORD ( 
	ULONG	RegistryHandle, 
	PCHAR	ValueName,
	PULONG	ValuePtr );

STATUS InitBridge(halParameters* pConfig);
STATUS InitTriMedia(halParameters* pConfig);

/*----------------------------------------------------------------------------
          PAGE LOCKING
----------------------------------------------------------------------------*/

#pragma VxD_LOCKED_CODE_SEG
#pragma	VxD_LOCKED_DATA_SEG

/*----------------------------------------------------------------------------
          FUNCTION DEFINITIONS
----------------------------------------------------------------------------*/

DWORD _stdcall DriverEntry(
	VOID )
{
	DWORD				Idx;
	DWORD				NTStatus;
	debugParameters		DebugParameters;


	if ( ( TMManGlobal = memAllocate(sizeof(GlobalObject)) ) == NULL )	
	{
		goto DriverEntryExit1;
	}


	// begin registry param reads here

	NTStatus = _RegOpenKey (
		HKEY_LOCAL_MACHINE, 
		"SOFTWARE\\PhilipsSemiconductors\\TriMedia\\TMMan",
		&TMManGlobal->RegistryHandle );

	DebugParameters.TraceBufferSize = constTMManHostTraceBufferSize;
	DebugParameters.LevelBitmap = constTMManHostTraceLeveBitmap;
	DebugParameters.Type = constTMManHostTraceType;

	TMManGlobal->TargetTraceBufferSize = constTMManTargetTraceBufferSize;
	TMManGlobal->TargetTraceLeveBitmap = constTMManTargetTraceLeveBitmap;
	TMManGlobal->TargetTraceType = constTMManTargetTraceType;
	TMManGlobal->MemorySize = constTMManMemorySize;
	TMManGlobal->MailboxCount = constTMManMailboxCount;
	TMManGlobal->ChannelCount = constTMManChannelCount;
	TMManGlobal->VIntrCount = constTMManVIntrCount;
	TMManGlobal->MessageCount = constTMManMessageCount;
	TMManGlobal->EventCount = constTMManEventCount;
	TMManGlobal->NameSpaceCount = constTMManNameSpaceCount;
	TMManGlobal->MemoryCount = constTMManMemoryCount;
	TMManGlobal->SGBufferCount = constTMManSGBufferCount;
	TMManGlobal->StreamCount = constTMManStreamCount;
	TMManGlobal->SpeculativeLoadFix = 0;
	TMManGlobal->PCIInterruptNumber = constTMMANTargetToHostIRQ;
	TMManGlobal->MMIOInterruptNumber = constTMMANHostToTargetIRQ;
	TMManGlobal->MapSDRAM = TRUE;

	if ( NTStatus == ERROR_SUCCESS )
	{
		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"HostTraceBufferSize",
			&DebugParameters.TraceBufferSize );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"HostTraceLevelBitmap",
			&DebugParameters.LevelBitmap );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"HostTraceType",
			&DebugParameters.Type );


		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"TargetTraceBufferSize",
			&TMManGlobal->TargetTraceBufferSize );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"TargetTraceLevelBitmap",
			&TMManGlobal->TargetTraceLeveBitmap );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"TargetTraceType",
			&TMManGlobal->TargetTraceType );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"MemorySize",
			&TMManGlobal->MemorySize );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"MailboxCount",
			&TMManGlobal->MailboxCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"ChannelCount",
			&TMManGlobal->ChannelCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"VIntrCount",
			&TMManGlobal->VIntrCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"MessageCount",
			&TMManGlobal->MessageCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"EventCount",
			&TMManGlobal->EventCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"StreamCount",
			&TMManGlobal->StreamCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"NameSpaceCount",
			&TMManGlobal->NameSpaceCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"MemoryCount",
			&TMManGlobal->MemoryCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"SGBufferCount",
			&TMManGlobal->SGBufferCount );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			"SpeculativeLoadFix",
			&TMManGlobal->SpeculativeLoadFix );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			L"PCIInterruptNumber",
			&TMManGlobal->PCIInterruptNumber );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			L"MMIOInterruptNumber",
			&TMManGlobal->MMIOInterruptNumber );

		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			L"MapSDRAM",
			&TMManGlobal->MapSDRAM );

		NTStatus = _RegCloseKey (
			TMManGlobal->RegistryHandle );
	}

	// end registry

	// initialize the debugging subsystem so that we can start dumping stuff
	debugInit ( &DebugParameters );

	// initialize the Global Object 

	TMManGlobal->BitFlags = 0;
	TMManGlobal->MaximumDevices = constTMMANMaximumDeviceCount;
	TMManGlobal->MaximumClients = constTMMANMaximumClientCount;
	TMManGlobal->DeviceCount = 0;
	TMManGlobal->ClientCount = 0;

	for ( Idx = 0 ; Idx < TMManGlobal->MaximumDevices ; Idx++ )
	{
			TMManGlobal->DeviceList[Idx] = NULL;
	}

	
	for ( Idx = 0 ; Idx < TMManGlobal->MaximumClients ; Idx++ )
	{
			TMManGlobal->ClientList[Idx] = NULL;
	}


	// enumerate all the PCI devices in the sytem that have a matching
	// device and vendor ID and call the tmman initializaiton routine
	// to allocate resources for the specifc device object

	// this function call the function tmmanInit with the halParameters
	// structures.
	
	//pnpFindPCIDevices  ( constTMMANVendorID, constTMMANDeviceID );

	// if we haven't found atleast one board to run on, then unload
	/*
	if ( TMManGlobal->DeviceCount  == 0 )
	{
		goto DriverEntryExit4;	
	}
	*/
	return VXD_SUCCESS;

/*
DriverEntryExit2:
	memAllocate( TMManGlobal );
*/

DriverEntryExit1:
	return VXD_FAILURE;

}

VOID _stdcall DriverExit (
    VOID )
{
	ULONG	Idx;
	for ( Idx = 0 ; Idx < TMManGlobal->DeviceCount ;
		Idx++ )
	{
		if ( TMManGlobal->DeviceList[Idx] )
		{
			tmmanExit ( Idx );
			TMManGlobal->DeviceList[Idx] = NULL;
		}
	}

	debugExit( );

	memFree ( TMManGlobal );
}

//////////////////////////////////////////////////////////////////////////////
//
//	STANDARD ENTRY POINTS
//
//////////////////////////////////////////////////////////////////////////////

Pointer	tmmanInit ( 
	UInt32 DSPNumber, 
	Pointer Configuration )
{

	halParameters*				HalParameters = (halParameters*)Configuration;
	channelManagerParameters	ChannelParameters;
	vintrManagerParameters		VIntrParameters;
	eventManagerParameters		EventParameters;
	messageManagerParameters	MessageParameters;
	memoryManagerParameters		MemoryParameters;
	namespaceManagerParameters	NameSpaceParameters;
	sgbufferManagerParameters	SGBufferParameters;

	UInt32						TMManControlSize;
	UInt32						HalControlSize;
	UInt32						NameSpaceControlSize;
	UInt32						MemoryControlSize;

    ULONG						RegistryHandle;
	TMStatus					Status;
	DWORD				        NTStatus;
    CHAR                        RegKey[100];


	// required by MmAllocateContigiousPhysicalMemory
	PHYSICAL_ADDRESS			HighestPhysicalAddress;

	TMManDeviceObject* TMManDevice;

	// all this has to be done on a device specific basis

	TMManDevice = memAllocate ( 
		sizeof ( TMManDeviceObject ) );

	if ( TMManDevice == NULL )
	{
		DPF(0,("tmman:tmmanInit:ExAllocatePool:TMManDevice:FAIL\n"));
		goto tmmanInitExit1;			
	}

	HalParameters->SystemBaseAddress = constTMMANSystemBaseAddress;
	HalParameters->MMIOBaseAddress = constTMMANMMIOBaseAddress;
	HalParameters->SDRAMBaseAddress = constTMMANSDRAMBaseAddress;

	_Sprintf(RegKey,"SOFTWARE\\PhilipsSemiconductors\\TriMedia\\TMMan\\Device%d",DSPNumber);

	NTStatus = _RegOpenKey (
		HKEY_LOCAL_MACHINE, 
		RegKey,
		&RegistryHandle );

	if ( NTStatus == ERROR_SUCCESS )
	{

		RegistryReadDWORD (
			RegistryHandle,
			"SDRAMSize",
			&HalParameters->SDRAMLength );

		DPF(0,("tmman:tmmanInit:RegistryReadDWORD:SDRAMSize:[0x%x]\n", HalParameters->SDRAMLength ));

		RegistryReadDWORD (
    		RegistryHandle,
       		"SystemBaseAddress", 
			&HalParameters->SystemBaseAddress);

		DPF(0,("tmman:tmmanInit:RegistryReadDWORD:SystemBaseAddress:[0x%x]\n", HalParameters->SystemBaseAddress ));

		RegistryReadDWORD (
    		RegistryHandle,