tmman.c

wince host 和 target PCI驱动程序

	// via MmAllocateContiguousMemory instead of ExAllocatePool

    // Volker : added memory pool size to allocate all at one place
	TMManDevice->SharedData = MmAllocateContiguousMemory (
 		TMManControlSize + HalControlSize + NameSpaceControlSize + MemoryControlSize,
		HighestPhysicalAddress);

	if ( TMManDevice->SharedData== NULL )
	{
		DPF(0,("tmman:tmmanInit:MmAllocateContiguousMemory:SharedData:FAIL\n"));
		goto tmmanInitExit2;
	}

	TMManDevice->TMManSharedAddress = MmGetPhysicalAddress(
		TMManDevice->SharedData );

	//
	// HAL object
	//

	// most of halParameters has already been intialized by pnpConfigStart
	//	NOTE : halInitization has to be done before anything else since the
	//	endianness fucntions are in Hal 
	HalParameters->PCIIrq = TMManGlobal->PCIInterruptNumber;
	HalParameters->TMIrq = TMManGlobal->MMIOInterruptNumber;
	HalParameters->DeviceObject = TMManGlobal->DeviceObject;
	HalParameters->DriverObject = TMManGlobal->DriverObject;
	HalParameters->DSPNumber = TMManDevice->DSPNumber;
	HalParameters->SharedData = 
		TMManDevice->HalSharedData =
		( ((UInt8*)TMManDevice->SharedData) + TMManControlSize );

	HalParameters->SpeculativeLoadFix = TMManGlobal->SpeculativeLoadFix;

    TMManDevice->HalSharedAddress = MmGetPhysicalAddress( 
		HalParameters->SharedData );

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

	//
	// name space object
	//

	NameSpaceParameters.HalHandle = TMManDevice->HalHandle;
	NameSpaceParameters.NameSpaceCount = TMManGlobal->NameSpaceCount;
	NameSpaceParameters.SharedData =
		TMManDevice->NameSpaceSharedData = 
		( ((UInt8*)TMManDevice->SharedData) + 
		TMManControlSize + HalControlSize );


	TMManDevice->NameSpaceSharedAddress = MmGetPhysicalAddress( 
		NameSpaceParameters.SharedData);

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

	//
	// memory object
	//

	MemoryParameters.MemoryCount = TMManGlobal->MemoryCount;
	MemoryParameters.MemorySize = TMManGlobal->MemorySize;
	MemoryParameters.HalHandle = TMManDevice->HalHandle;
	MemoryParameters.NameSpaceManagerHandle = TMManDevice->NameSpaceManagerHandle;
	MemoryParameters.SharedData = 
		TMManDevice->MemorySharedData = 
		( ((UInt8*)TMManDevice->SharedData) + 
		TMManControlSize + HalControlSize  + NameSpaceControlSize );

	TMManDevice->MemorySharedAddress = MmGetPhysicalAddress(
		MemoryParameters.SharedData);

    // memory block is alread allocated
    //MemoryParameters.MemoryBlock =
	//    TMManDevice->MemoryBlock =
    //    ( ((UInt8*)TMManDevice->SharedData) + 
	//	TMManControlSize + HalControlSize  + NameSpaceControlSize + MemoryControlSize);


    // allocate the contuguous memory from which all the other components 
	// will be sub-allocating.
	HighestPhysicalAddress.LowPart = 0xffffffff;
	HighestPhysicalAddress.HighPart = 0x00000000;

	TMManDevice->MemoryBlock = 
		MemoryParameters.MemoryBlock = MmAllocateContiguousMemory (
 		MemoryParameters.MemorySize, 
		HighestPhysicalAddress );
	
	if ( MemoryParameters.MemoryBlock == NULL )
	{
		DPF(0,("tmman:tmmanInit:MmAllocateContiguousMemory:MemoryBlock:FAIL\n"));
		goto tmmanInitExit5;
	}

	TMManDevice->MemoryBlockSize = MemoryParameters.MemorySize;
	TMManDevice->MemoryBlockAddress = MmGetPhysicalAddress (
		TMManDevice->MemoryBlock );

	DPF(0,("tmman:tmmanInit:TMManDevice->MemoryBlockAddress:Hi[%x]:Lo[%x]\n",
		 TMManDevice->MemoryBlockAddress.HighPart, TMManDevice->MemoryBlockAddress.LowPart ));

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

	//
	// virtual interrupt object
	//

	VIntrParameters.HalHandle = TMManDevice->HalHandle;
	VIntrParameters.VIntrCount = TMManGlobal->VIntrCount;

	Status = memoryCreate(
		TMManDevice->MemoryManagerHandle,
		(Pointer)PsGetCurrentProcess(),
		"TMManVIntr", 
		vintrSharedDataSize ( TMManGlobal->VIntrCount ), 
		&VIntrParameters.SharedData,
		&TMManDevice->VIntrSharedData );

	if ( Status != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:memoryCreate:VIntr:FAIL[%x]\n", Status));
		goto tmmanInitExit7;
	}
	
	TMManDevice->VIntrSharedAddress = MmGetPhysicalAddress( 
		VIntrParameters.SharedData);

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

	//
	// interprocessor mailbox object
	//

	ChannelParameters.ChannelCount = TMManGlobal->ChannelCount; 
	ChannelParameters.MailboxCount = TMManGlobal->MailboxCount;
	ChannelParameters.PacketSize = constTMManPacketSize;
	ChannelParameters.HalHandle = TMManDevice->HalHandle;
	ChannelParameters.VIntrManagerHandle = TMManDevice->VIntrManagerHandle;
	ChannelParameters.NameSpaceManagerHandle = TMManDevice->NameSpaceManagerHandle;

	Status = memoryCreate(
		TMManDevice->MemoryManagerHandle,
		(Pointer)PsGetCurrentProcess(),
		"TMManChannel", 
		channelSharedDataSize( TMManGlobal->MailboxCount, constTMManPacketSize ),
		&ChannelParameters.SharedData,
		&TMManDevice->ChannelSharedData );

	if ( Status != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:memoryCreate:Channel:FAIL[%x]\n", Status));
		goto tmmanInitExit9;
	}
	
	TMManDevice->ChannelSharedAddress = MmGetPhysicalAddress(
		ChannelParameters.SharedData);

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

	//
	// interprocessor event object
	//

	EventParameters.EventCount = TMManGlobal->EventCount; 
	EventParameters.HalHandle = TMManDevice->HalHandle;
	EventParameters.VIntrManagerHandle = TMManDevice->VIntrManagerHandle;
	EventParameters.NameSpaceManagerHandle = TMManDevice->NameSpaceManagerHandle;

	Status = memoryCreate(
		TMManDevice->MemoryManagerHandle,
		(Pointer)PsGetCurrentProcess(),
		"TMManEvent", 
		eventSharedDataSize ( TMManGlobal->EventCount ), 
		&EventParameters.SharedData,
		&TMManDevice->EventSharedData );

	if ( Status != statusSuccess )
	{
		DPF(0,("tmman:tmmanInit:memoryCreate:Event:FAIL[%x]\n", Status));
		goto tmmanInitExit11;
	}

	TMManDevice->EventSharedAddress = MmGetPhysicalAddress(
		EventParameters.SharedData);

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

	//
	// interprocessor message packet object
	//

	MessageParameters.MessageCount = TMManGlobal->MessageCount; 
	MessageParameters.PacketSize = constTMManPacketSize;
	MessageParameters.HalHandle = TMManDevice->HalHandle;
	MessageParameters.ChannelManagerHandle = TMManDevice->ChannelManagerHandle;
	MessageParameters.NameSpaceManagerHandle = TMManDevice->NameSpaceManagerHandle;


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

	//
	// scatter gather buffer object
	//

	SGBufferParameters.SGBufferCount = TMManGlobal->SGBufferCount;
	SGBufferParameters.HalHandle = TMManDevice->HalHandle;
	SGBufferParameters.MemoryManagerHandle = TMManDevice->MemoryManagerHandle;
	SGBufferParameters.NameSpaceManagerHandle = TMManDevice->NameSpaceManagerHandle;

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

	return TMManDevice;


/*
tmmanInitExit15:
	sgbufferManagerDestroy ( TMManDevice->SGBufferManagerHandle );
*/

tmmanInitExit14:
	messageManagerDestroy ( TMManDevice->MessageManagerHandle );

tmmanInitExit13:
	eventManagerDestroy ( TMManDevice->EventManagerHandle );

tmmanInitExit12:
	memoryDestroy( TMManDevice->EventSharedData );

tmmanInitExit11:
	channelManagerDestroy ( TMManDevice->ChannelManagerHandle );

tmmanInitExit10:
	memoryDestroy( TMManDevice->ChannelSharedData );

tmmanInitExit9:
	vintrManagerDestroy ( TMManDevice->VIntrManagerHandle );

tmmanInitExit8:
	memoryDestroy( TMManDevice->VIntrSharedData );

tmmanInitExit7:
	memoryManagerDestroy ( TMManDevice->MemoryManagerHandle );

tmmanInitExit6:
	MmFreeContiguousMemory ( TMManDevice->MemoryBlock );

tmmanInitExit5:
	namespaceManagerDestroy ( TMManDevice->NameSpaceManagerHandle );

tmmanInitExit4:
	halDestroy ( TMManDevice->HalHandle );
	
tmmanInitExit3:
	MmFreeContiguousMemory ( TMManDevice->SharedData );

tmmanInitExit2:
	memFree ( TMManDevice );

tmmanInitExit1:
	return NULL;
}

void	tmmanExit (  
	UInt32 DSPNumber )
{

	TMManDeviceObject* TMManDevice = 
		(TMManDeviceObject*)TMManGlobal->DeviceList[DSPNumber];

	sgbufferManagerDestroy ( TMManDevice->SGBufferManagerHandle );

	messageManagerDestroy ( TMManDevice->MessageManagerHandle );

	eventManagerDestroy ( TMManDevice->EventManagerHandle );

	memoryDestroy( TMManDevice->EventSharedData );

	channelManagerDestroy ( TMManDevice->ChannelManagerHandle );

	memoryDestroy( TMManDevice->ChannelSharedData );

	vintrManagerDestroy ( TMManDevice->VIntrManagerHandle );

	memoryDestroy( TMManDevice->VIntrSharedData );

	memoryManagerDestroy ( TMManDevice->MemoryManagerHandle );

	MmFreeContiguousMemory ( TMManDevice->MemoryBlock );

	namespaceManagerDestroy ( TMManDevice->NameSpaceManagerHandle );

	halDestroy ( TMManDevice->HalHandle );

	MmFreeContiguousMemory ( TMManDevice->SharedData );

    memFree ( TMManDevice );
	
}

//////////////////////////////////////////////////////////////////////////////
//
//	HELPER DATA ACCESS FUNCTIONS
//
//////////////////////////////////////////////////////////////////////////////

BOOLEAN RegistryOpen ( 
	HANDLE	*RegistryHandle, 
	PWCHAR	RegistryKey )
{
    LONG                lReturn;
    ULONG				Disposition;

	lReturn = RegCreateKeyEx(
		HKEY_LOCAL_MACHINE,
		RegistryKey,
		0,
		NULL,
		0,
		0,
		NULL,
		RegistryHandle,
		&Disposition);

	if ( lReturn != ERROR_SUCCESS)
	{
        DPF(0,("tmman:RegistryOpen(%wZ) failed\n", RegistryKey));
		return FALSE;
	}

	return TRUE;
}

VOID	RegistryClose ( 
	HANDLE RegistryHandle )
{
	RegCloseKey ( RegistryHandle );
}

BOOLEAN RegistryReadDWORD ( 
	HANDLE	RegistryHandle, 
	PWCHAR	ValueName,
	PULONG	ValuePtr )
{
	ULONG	BytesXfered;	
    LONG        Status;
    DWORD       dwType;
    DWORD      dwValue;

    Status = RegQueryValueEx(
		RegistryHandle,
		ValueName,
        NULL,
        &dwType,
		(BYTE*)&dwValue,
		&BytesXfered );
    
    if (Status == ERROR_SUCCESS)
    {
        *ValuePtr = dwValue;
        return TRUE;
    }
    else
        return FALSE;

}