tmman.c

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

    		"MMIOBaseAddress", 
    		&HalParameters->MMIOBaseAddress );

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

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

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

		NTStatus = _RegCloseKey (
    		RegistryHandle );
	}
	else
	{
			DPF(0,("tmman:tmmanInit:_RegOpenKey(%s):FAIL[0x%x]\n", RegKey, NTStatus ));
	}

	if( HalParameters->BridgeDeviceVendorID == 
	(( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ))
	{

		Status = InitBridge(HalParameters);
		
		if( Status != True )
		{
		   DPF(0,("TM:tmmanInit:BridgeInit:Fail\n"));
		   goto tmmanInitExit2;
		}

		Status = InitTriMedia(HalParameters);
		
		if( Status != True )
		{
		   DPF(0,("TM:tmmanInit:TrimediaInit:Fail\n"));
		   goto tmmanInitExit2;
		}
	}
	
	// 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
	// via MmAllocateContiguousMemory instead of ExAllocatePool
	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 );

	if ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->TMManSharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}


	//
	// 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->DSPNumber = TMManDevice->DSPNumber;
	HalParameters->SharedData = 
		TMManDevice->HalSharedData =
		( ((UInt8*)TMManDevice->SharedData) + TMManControlSize );
	
	HalParameters->SpeculativeLoadFix = TMManGlobal->SpeculativeLoadFix;

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

	if ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->HalSharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}

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

	TMManDevice->DevNode = HalParameters->DevNode;

	//
	// 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 ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->NameSpaceSharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}

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

	if ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->MemorySharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}


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

	if ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->MemoryBlockAddress.LowPart += HalParameters->SystemBaseAddress;
	}


	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 ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->VIntrSharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}


	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 ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->ChannelSharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}

	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 ( HalParameters->BridgeDeviceVendorID == 
		( ( constTMMANDECBridgeDeviceID << 16 ) | constTMMANDECBridgeVendorID ) )
	{
		TMManDevice->EventSharedAddress.LowPart += HalParameters->SystemBaseAddress;
	}

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