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
	982005	Volker Schildwach	Ported to WinCE User Mode DLL
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#include <windows.h>
#include "ceddk.h"

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


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


/*----------------------------------------------------------------------------
          FUNCTION PROTOTYPES
----------------------------------------------------------------------------*/
// Windows CE entry exit and IOCTL function calls are different
BOOLEAN RegistryOpen ( 
	HANDLE	*RegistryHandle, 
	PWCHAR	RegistryKey );

VOID	RegistryClose ( 
	HANDLE RegistryHandle );

BOOLEAN RegistryReadDWORD ( 
	HANDLE	RegistryHandle, 
	PWCHAR	ValueName,
	PULONG	ValuePtr );

Pointer PsGetCurrentProcess( VOID );


DWORD TMM_Init(
	DWORD	dwRegistryPath);

BOOL
TMM_Deinit(
	DWORD	dwDeviceContext);


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


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

BOOL WINAPI
DllMain(
	HINSTANCE   hDllInstance, 
	ULONG       uReason, 
	LPVOID      lpReserved
   )
{
	switch (uReason) 
	{
		case DLL_PROCESS_ATTACH:
			OutputDebugString(TEXT("TMM: DLL_PROCESS_ATTACH\n"));
			break;
		case DLL_PROCESS_DETACH:
			OutputDebugString(TEXT("TMM: DLL_PROCESS_DETACH\n"));
			break;
    } 
    return TRUE;
}

DWORD TMM_Init(
	DWORD	dwRegistryPath )
{
	ULONG				Idx;
	NTSTATUS			NTStatus;
	USHORT				TMManRegistryPath[256];
    static DWORD        dwDeviceHandle = 0;
	debugParameters		DebugParameters;

	OutputDebugString(TEXT("tmman:TMM_Init:ENTER\n"));    
    
	if (dwDeviceHandle)
    {
	    DPF(0,("tmman:tmmanInit:already initialized!\n"));
        goto TMM_InitExit1;
    }
    
    if( ( TMManGlobal =  
		(GlobalObject*)memAllocate ( sizeof(GlobalObject)) ) == NULL )
	{
	    DPF(0,("tmman:tmmanInit:memAllocate:FAILED\n"));
        goto TMM_InitExit1;
	}
    
    wsprintf ( TMManRegistryPath , L"SOFTWARE\\PhilipsSemiconductors\\TriMedia\\TMMan" );


	DebugParameters.TraceBufferSize = constTMManHostTraceBufferSize;
	DebugParameters.LevelBitmap = 0x1;
	DebugParameters.Type = constTMManDebugTypeOutput;
	TMManGlobal->TargetTraceBufferSize = constTMManTargetTraceBufferSize;
	TMManGlobal->TargetTraceLeveBitmap = 0x0;
	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;

	// specific to WinCE
	TMManGlobal->OEMIOCTLBase = constTMMANOEMIoctlBase;
	TMManGlobal->PageLockedMemoryBase = constTMMANPageLockedMemoryBase;
	TMManGlobal->PageLockedMemorySize = constTMMANPageLockedMemorySize;

    if ( RegistryOpen (
		&TMManGlobal->RegistryHandle,
		TMManRegistryPath ) != TRUE )
	{
		OutputDebugString(TEXT("tmman:TMM_Init:RegistryOpen:FAIL\n"));    
        DPF(0,("tmman:RegistryOpen(%wZ) : FAILED\n", TMManRegistryPath));
	}
	else
	{
		OutputDebugString(TEXT("tmman:TMM_Init:RegistryOpen:OK\n"));    
		RegistryReadDWORD (
			TMManGlobal->RegistryHandle,
			L"HostTraceBufferSize",
			&DebugParameters.TraceBufferSize );

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


		RegistryClose(
			TMManGlobal->RegistryHandle );
	}

	// end registry

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

	// initialize the Global Object 
	TMManGlobal->DeviceObject = 0;

	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  ( constTMMANTM1000VendorID, constTMMANTM1000DeviceID );

	pnpFindPCIDevices  ( constTMMANTM2000VendorID, constTMMANTM2000DeviceID );

    // increase device handle
    dwDeviceHandle++;
	OutputDebugString(TEXT("tmman:TMM_Init:EXIT:OK\n"));    
    return dwDeviceHandle;

TMM_InitExit1:
	OutputDebugString(TEXT("tmman:TMM_Init:EXIT:FAIL\n"));    
	return NULL;

}

BOOL
TMM_Deinit(
	DWORD	dwDeviceContext )
{
	ULONG	Idx;
	
	for ( Idx = 0 ; Idx < TMManGlobal->DeviceCount ;
		Idx++ )
	{
		if ( TMManGlobal->DeviceList[Idx] )
		{
			tmmanExit ( Idx );
			TMManGlobal->DeviceList[Idx] = NULL;
		}
	}

	debugExit( );


    // free allocated structure
    memFree (TMManGlobal);      

    return TRUE;
}

//////////////////////////////////////////////////////////////////////////////
//
//	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;

	TMStatus					Status;

	// 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:memAllocate:TMManDevice:FAIL\n"));
		goto tmmanInitExit1;			
	}
	
	// for back reference
	TMManDevice->Status = constTMManDSPStatusReset;
	TMManDevice->DSPNumber = DSPNumber;

	// allocate shared memory for TMMan Control, Hal, NameSpace, Memory 
	// allocating these toghether provides optimum usage of Contiguous Memory

	//calculate the total size required
	TMManControlSize = sizeof ( TMManSharedStruct );
	HalControlSize = sizeof  ( HalControl );
	NameSpaceControlSize = namespaceSharedDataSize ( TMManGlobal->NameSpaceCount );
	MemoryControlSize = memorySharedDataSize ( TMManGlobal->MemoryCount );

	// allocate all the contiguous memeory at one shot, that will optimize 
	// IA32 page usage.
	HighestPhysicalAddress.LowPart = 0xffffffff;
	HighestPhysicalAddress.HighPart = 0x00000000;

	// any shred memory that is allocate outside memoryCreate should be done