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
	010828	Wim de Haan		Changed code to remove compiler warnings:
							Line 904: 'tmmanInitExit1' : unreferenced label
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/

#include "wdm.h"

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

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


/*----------------------------------------------------------------------------
          FUNCTION PROTOTYPES
----------------------------------------------------------------------------*/

NTSTATUS DriverEntry(
    IN PDRIVER_OBJECT pDriverObject,
    IN PUNICODE_STRING RegistryPath );

VOID DriverExit(
    IN PDRIVER_OBJECT pDriverObject );

NTSTATUS tmmanOpen(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp );

NTSTATUS tmmanClose(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp );

NTSTATUS tmmanDeviceControl(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp );

NTSTATUS tmmanRead(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp );

NTSTATUS tmmanWrite(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp );

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

BOOLEAN 
InitTriMedia (
	halParameters* Config );

BOOLEAN
InitBridge ( 
	halParameters* Config );

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

//#ifdef ALLOC_PRAGMA
//#pragma alloc_text(INIT,DriverEntry)
//#pragma alloc_text(INIT,tmmanInit)
//#endif

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

NTSTATUS DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
)
{
	ULONG				Idx;
	NTSTATUS			NTStatus;
    UNICODE_STRING		UserDeviceNameString;
    UNICODE_STRING		KernelDeviceNameString;
	PDEVICE_OBJECT		DeviceObject;
    OBJECT_ATTRIBUTES	RegistryObjectAttributes;
	UNICODE_STRING		TMManRegistryPath;
	debugParameters		DebugParameters;
    ULONG				Disposition;


	RtlInitUnicodeString ( &UserDeviceNameString, L"\\DosDevices\\TMMAN" );
	RtlInitUnicodeString ( &KernelDeviceNameString, L"\\Device\\TriMedia" );

	DbgPrint ( "\nRegistryPath[%wZ]\n",
		RegistryPath );
	
	DbgPrint ( "UserName[%wZ]\n",
		&UserDeviceNameString );

	DbgPrint ( "KernelName[%wZ]\n",
		&KernelDeviceNameString );

	// Create the device object
    NTStatus = IoCreateDevice(
		 DriverObject,
		 sizeof (GlobalObject),
		 &KernelDeviceNameString,
		 FILE_DEVICE_UNKNOWN,
		 0,                        // No standard device characteristics
		 FALSE,                    // This isn't an exclusive device
		 &DeviceObject  );

    if ( ! NT_SUCCESS(NTStatus) )
    {
		DbgPrint ( "tmman:DriverEntryIoCreateDevice:FAIL[%x]\n", NTStatus );
		goto DriverEntryExit1;
	}

    // Create a link from our device name to a name in the Win32 namespace.
    NTStatus = IoCreateSymbolicLink ( 
		&UserDeviceNameString, 
		&KernelDeviceNameString);

    if ( ! NT_SUCCESS(NTStatus) )
    {
		DbgPrint ( "tmman:DriverEntry:IoCreateSymbolicLink:FAIL[%x]\n", NTStatus );
		goto DriverEntryExit2;
    }

    // set the io flags
    DeviceObject->Flags |= DO_BUFFERED_IO;

	TMManGlobal = (GlobalObject*)DeviceObject->DeviceExtension;

	// begin registry param reads here

	RtlInitUnicodeString ( &TMManRegistryPath , L"\\REGISTRY\\Machine\\HARDWARE\\PhilipsSemiconductors\\TriMedia\\TMMan" );

	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;


    InitializeObjectAttributes(
        &RegistryObjectAttributes,
        RegistryPath, //&TMManRegistryPath, // RegisdtryPath is inserted by Boghos in order to use the tmman Key under the Services key in the registry
        OBJ_CASE_INSENSITIVE,				// Add the tmman initialisation constants like MemorySize to the key
        NULL,								// HlocalMachine\system\currentcontrolset\services\tmman
        NULL                    
        );

    NTStatus = ZwCreateKey(
		&TMManGlobal->RegistryHandle,
		KEY_READ,
		&RegistryObjectAttributes,
		0,                 
		NULL,              
		0,                 
		&Disposition);     

	if ( ! NT_SUCCESS ( NTStatus ) )
	{
		DbgPrint ( "tmman:ZwCreateKey(%wZ):FAIL[%x]\n", &TMManRegistryPath, NTStatus );
	}
	else
	{
		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 );

		NTStatus = ZwClose(
			TMManGlobal->RegistryHandle );
	}

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

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

	TMManGlobal->DriverObject = DriverObject;

	TMManGlobal->DriverRegistryPath.Length = 0;

	TMManGlobal->DriverRegistryPath.Buffer = 
		ExAllocatePool ( PagedPool, RegistryPath->Length );
		
	if ( TMManGlobal->DriverRegistryPath.Buffer == NULL )
	{
		DPF(0,("tmman:DriverEntry:ExAllocatePool:RegistryPath:FAIL\n"));
		goto DriverEntryExit3;
	}

	TMManGlobal->DriverRegistryPath.MaximumLength = RegistryPath->Length;

	RtlCopyUnicodeString ( &TMManGlobal->DriverRegistryPath,  RegistryPath );

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

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

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

    //Create dispatch points
	DriverObject->MajorFunction[IRP_MJ_CREATE]			= tmmanOpen;
	DriverObject->MajorFunction[IRP_MJ_CLOSE]			= tmmanClose;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]	= tmmanDeviceControl;
	DriverObject->MajorFunction[IRP_MJ_PNP]				= tmmanPnp;
//	DriverObject->MajorFunction[IRP_MJ_POWER]			= tmmanPower;
    DriverObject->DriverUnload							= DriverExit;
	DriverObject->DriverExtension->AddDevice			= tmmanPnpAddDevice;

	return STATUS_SUCCESS;

//DriverEntryExit4:
//	ExFreePool (TMManGlobal->DriverRegistryPath.Buffer  );

DriverEntryExit3:
	IoDeleteSymbolicLink ( &UserDeviceNameString );

DriverEntryExit2:
	IoDeleteDevice ( DeviceObject );

DriverEntryExit1:
	return STATUS_UNSUCCESSFUL;

}

VOID DriverExit (
    IN PDRIVER_OBJECT DriverObject )
{
	ULONG	Idx;
    UNICODE_STRING	UserDeviceNameString;
	RtlInitUnicodeString ( &UserDeviceNameString, L"\\DosDevices\\TMMAN" );
	
	for ( Idx = 0 ; Idx < TMManGlobal->DeviceCount ;
		Idx++ )
	{
		if ( TMManGlobal->DeviceList[Idx] )
		{
			tmmanExit ( Idx );
			TMManGlobal->DeviceList[Idx] = NULL;
		}
	}

	debugExit( );

	ExFreePool ( TMManGlobal->DriverRegistryPath.Buffer  );

	IoDeleteSymbolicLink ( &UserDeviceNameString );

	IoDeleteDevice ( TMManGlobal->DeviceObject );
}

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

	NTSTATUS					NTStatus;
	TMStatus					Status;
	PHYSICAL_ADDRESS			HighestPhysicalAddress;
	TMManDeviceObject* TMManDevice = HalParameters->FunctionalDeviceObject->DeviceExtension;

	HANDLE						RegistryHandle;
	OBJECT_ATTRIBUTES			RegistryObjectAttributes;
	ULONG						Disposition;
	CHAR						TMManRegistryPathCHAR[100];
	UNICODE_STRING				TMManRegistryPath;
	ANSI_STRING					TMManRegistryPathANSI;


	TMManDevice->Status = constTMManDSPStatusReset;
	TMManDevice->DSPNumber = DSPNumber;

	TMManDevice->Stopped = FALSE;
	TMManDevice->Removed = FALSE;
	TMManDevice->References = 0;

    KeInitializeEvent(&TMManDevice->RemoveEvent, NotificationEvent, TRUE);
    KeInitializeEvent(&TMManDevice->StopEvent, NotificationEvent, TRUE);


	strSprintf ( TMManRegistryPathCHAR, 
		"\\REGISTRY\\Machine\\SOFTWARE\\PhilipsSemiconductors\\TriMedia\\TMMan\\Device%d", 
		TMManDevice->DSPNumber );

	RtlInitAnsiString ( &TMManRegistryPathANSI, TMManRegistryPathCHAR );

	if ( RtlAnsiStringToUnicodeString(
		&TMManRegistryPath, 
		&TMManRegistryPathANSI, 
		TRUE) != STATUS_SUCCESS  )
	{
		DPF(0,("tmman:tmmanInit:RtlAnsiStringToUnicodeString:FAIL\n" ));
		goto tmmanInitExit2;
	}

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

	InitializeObjectAttributes(
		&RegistryObjectAttributes,
		&TMManRegistryPath,           
		OBJ_CASE_INSENSITIVE,   
		NULL,                   
		NULL );

	NTStatus = ZwCreateKey(