tmhal.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
//
//	960510	Tilakraj Roy 	Created
//	979527  Tilakraj Roy  Ported to Windows NT with TMMan V4.0 interfaces
//	970806	Tilakraj Roy Ported to Windows NT with TMMan V5.0 interfaces
//	982005	Volker Schildwach	Ported to Windwos CE
//	981021	Tilakraj Roy	Changes for integrating into common source base
//
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
//				SYSTEM INCLUDE FILES
//////////////////////////////////////////////////////////////////////////////


#include <windows.h>
#include "ceddk.h"
#include "NkIntr.h"
#define SYSINTR_TRIMEDIA (SYSINTR_FIRMWARE + Hal->Irql)

//////////////////////////////////////////////////////////////////////////////
//				DRIVER SPECIFIC INCLUDE FILES
//////////////////////////////////////////////////////////////////////////////

#include "tmmanlib.h"
#include "platform.h"
#include "mmio.h"

//////////////////////////////////////////////////////////////////////////////
//				MANIFEST CONSTANTS
//////////////////////////////////////////////////////////////////////////////

#define		HalFourCC		tmmanOBJECTID ( 'H', 'A', 'L', ' ' )

//////////////////////////////////////////////////////////////////////////////
//				TYPEDEFS
//////////////////////////////////////////////////////////////////////////////

typedef struct tagHalObject
{
	GenericObject		Object;
    ULONG				TMDeviceVendorID;
	ULONG				TMSubsystemID;
	ULONG				TMClassRevisionID;

    ULONG				BridgeDeviceVendorID;
    ULONG				BridgeSubsystemID;
	ULONG				BridgeClassRevisionID;

	ULONG				SelfInterrupt;	// from Target -> Host 
	ULONG				PeerInterrupt;	// Host -> Target 
	HalInterruptHandler	Handler;
	Pointer				Context;

	HalControl*			Control;
	/*	true -  target processor is running in different indianess */
	/*	false -  target processor is running in different indianess */
	Bool				Swapping;	

	ULONG				PeerMajorVersion;
	ULONG				PeerMinorVersion;

	/* BEGIN Platform Specific */

    ULONG				BusNumber;
    PCI_SLOT_NUMBER		SlotNumber;

    PHYSICAL_ADDRESS    MMIOAddrPhysical;
    ULONG               MMIOLength;
	PHYSICAL_ADDRESS	MMIOAddrTranslated;
	PUCHAR				MMIOAddrKernel;

    PHYSICAL_ADDRESS    SDRAMAddrPhysical;
    ULONG               SDRAMLength;
	PHYSICAL_ADDRESS	SDRAMAddrTranslated;
	PUCHAR				SDRAMAddrKernel;
	

	ULONG				MappedInterruptVector;

	BOOLEAN				FirstTimeReset;

    HANDLE              hThreadHandle;
    DWORD               dwThreadId;
    HANDLE              InterruptEvent;
    UINT				Irql;


	ULONG				DSPNumber;
	PDEVICE_OBJECT		TMManDeviceObject;
	PDEVICE_OBJECT		DeviceObject;
	PDRIVER_OBJECT		DriverObject;
	PADAPTER_OBJECT		AdapterObject;
	ULONG				NumberOfMapRegisters;
	ULONG				SpeculativeLoadFix;

	ULONG				SDRAMMapCount;

	ULONG				PCIRegisters[constTMMANPCIRegisters];

}	HalObject;

#define		PCI_CONFIG_ADDR_PORT		((PULONG)0xcf8)
#define		PCI_CONFIG_DATA_PORT		((PULONG)0xcfc)

typedef		struct _PCI_CONFIG_ADDRESS
{
	union
	{
		struct{
			ULONG	Zeros:2;
			ULONG	RegisterNumber:6;
			ULONG	FunctionNumber:3;
			ULONG	DeviceNumber:5;
			ULONG	BusNumber:8;
			ULONG	Reserved:7;
			ULONG	Enable:1;
		}BitField;
		ULONG	Long;
	}u;
}	PCI_CONFIG_ADDRESS, *PPCI_CONFIG_ADDRESS;

//////////////////////////////////////////////////////////////////////////////
//				PROTOTYPES
//////////////////////////////////////////////////////////////////////////////
void	halDumpObject (
 	UInt32	HalHandle );


DWORD  WINAPI halHardwareInterruptHandler(PVOID pContext);

//////////////////////////////////////////////////////////////////////////////
//				IMPLEMENTATION
//////////////////////////////////////////////////////////////////////////////

TMStatus	halCreate ( 
	Pointer Parameters,
	UInt32* HalHandlePointer )
{
	TMStatus		Status = statusHalInitializationFail;
	NTSTATUS		NTStatus;
	HalObject*		Hal;
	ULONG			AddressSpace, Idx;

	if ( ( Hal = objectAllocate ( 
		sizeof ( HalObject ),
		HalFourCC ) ) == NULL )
	{
	    DPF(0,("tmman:halCreate:objectAllocate:FAIL\n" ));
		Status = statusObjectAllocFail; 
		goto halCreateExit1;
	}


	Hal->SelfInterrupt = ((halParameters*)Parameters)->PCIIrq;// from Target -> Host 
	Hal->PeerInterrupt = ((halParameters*)Parameters)->TMIrq;// Host -> Target 

    Hal->InterruptEvent = NULL;
    Hal->Handler = Null;
	Hal->Context = Null;
	Hal->Swapping = False; // target running in same endianness

    Hal->TMDeviceVendorID = ((halParameters*)Parameters)->TMDeviceVendorID;
	Hal->TMSubsystemID = ((halParameters*)Parameters)->TMSubsystemID;
	Hal->TMClassRevisionID = ((halParameters*)Parameters)->TMClassRevisionID;

    Hal->BridgeDeviceVendorID = ((halParameters*)Parameters)->BridgeDeviceVendorID;
    Hal->BridgeSubsystemID = ((halParameters*)Parameters)->BridgeSubsystemID;
	Hal->BridgeClassRevisionID = ((halParameters*)Parameters)->BridgeClassRevisionID;

	/* BEGIN Platform Specific */
    Hal->BusNumber	= ((halParameters*)Parameters)->BusNumber;
	Hal->SlotNumber			= ((halParameters*)Parameters)->SlotNumber;
	Hal->TMManDeviceObject	= ((halParameters*)Parameters)->DeviceObject;
	Hal->DriverObject	= ((halParameters*)Parameters)->DriverObject;
	Hal->DSPNumber	= ((halParameters*)Parameters)->DSPNumber;
    Hal->MMIOAddrPhysical	= ((halParameters*)Parameters)->MMIOAddrPhysical;
	Hal->MMIOLength			= ((halParameters*)Parameters)->MMIOLength;

    Hal->SDRAMAddrPhysical	= ((halParameters*)Parameters)->SDRAMAddrPhysical;
	Hal->SDRAMLength		= ((halParameters*)Parameters)->SDRAMLength;
	Hal->Control			= ((halParameters*)Parameters)->SharedData;

	Hal->SpeculativeLoadFix	= ((halParameters*)Parameters)->SpeculativeLoadFix;
	Hal->SDRAMMapCount = 0;

	for ( Idx = 0 ; Idx < constTMMANPCIRegisters ; Idx ++ )
	{
		Hal->PCIRegisters[Idx] = 
			((halParameters*)Parameters)->PCIRegisters[Idx];
	}
   
    // get a handle to the physical memory for mapping user sections

	// create a device object for this physical hardware

   	// Map MMIO address space
    // Map Registers into our address space.
	
    if ((Hal->MMIOAddrKernel=(char*)VirtualAlloc(
		0,
		Hal->MMIOLength,
		MEM_RESERVE,
		PAGE_NOACCESS))==NULL)
	{
        DPF(0,("tmman:halCreate:VirtualAlloc:MMIO:FAIL size = 0x%x\n",Hal->MMIOLength ));
        goto	halCreateExit4;
	}

	if(!VirtualCopy(
			(void *)Hal->MMIOAddrKernel,
			(void *)(Hal->MMIOAddrPhysical.LowPart>>8),
			Hal->MMIOLength,
			PAGE_READWRITE|PAGE_PHYSICAL|PAGE_NOCACHE))
	{
		DPF(0,("tmman:halCreate:MmMapIoSpace:MMIO:FAIL \n" ));
        goto	halCreateExit5;
	}


    // Now map in the SDRAM Window (just allocate one page as we only have 32MByte of virtual memory)

	if ( TMManGlobal->MapSDRAM )
	{

		if ((Hal->SDRAMAddrKernel=(char*)VirtualAlloc(
			0,
			Hal->SDRAMLength,
			MEM_RESERVE,
			PAGE_NOACCESS))==NULL)
		{
			DPF(0,("tmman:halCreate:VirtualAlloc:SDRAM:FAIL size=0x%x\n",Hal->SDRAMLength ));
			goto	halCreateExit5;
		}

		if(!VirtualCopy(
			(void *)Hal->SDRAMAddrKernel,
			(void *)(Hal->SDRAMAddrPhysical.LowPart>>8),
			Hal->SDRAMLength,
			PAGE_READWRITE|PAGE_PHYSICAL|PAGE_NOCACHE))
		{
			DPF(0,("tmman:halCreate:MmMapIoSpace:SDRAM:FAIL\n" ));
			goto	halCreateExit6;
		}
	}


	/* do the interrupt stuff */
    Hal->hThreadHandle = NULL;
    Hal->dwThreadId    = 0;
    Hal->Irql = ((halParameters*)Parameters)->InterruptLevel; 
    DPF(8,("HAL->Irql = %x\n", Hal->Irql));


    // Create event
    if ( ( Hal->InterruptEvent = CreateEvent( NULL, FALSE, FALSE,NULL) ) == NULL )
    {
		DPF(0,("tmman:halCreate:CreateEvent:Interrupt:FAIL[%x]\n", GetLastError ));
		goto	halCreateExit6;
    }

	if ( InterruptInitialize (SYSINTR_TRIMEDIA, Hal->InterruptEvent, NULL, 0) != TRUE )
	{
		DPF(0,("tmman:halCreate:InterruptInitialize:SYSINTR[%x]:FAIL[%x]\n", SYSINTR_TRIMEDIA, GetLastError() ));
		goto	halCreateExit7;
	}

    DPF (8,("tmman:halCreate:InterruptInitialize:ISR[%x]:HANDLE[%x]\n", 
		Hal->Irql, Hal->InterruptEvent));


    // create thread with current Windows CE restrictions
    if ( (Hal->hThreadHandle = CreateThread (
		NULL,         // security attributes not supported
		0,            // stack size must be 0
		halHardwareInterruptHandler,     
		(void*)Hal,   // ServiceContext
		CREATE_SUSPENDED, // only suspended mode is supported
		&Hal->dwThreadId )) != NULL )// returns thread ID
		
    {
        // as thread was created in suspended mode, we want to start it now
        ResumeThread(Hal->hThreadHandle);  
    }
    else
    {
		DPF(0,("tmman:halCreate:CreateThread:halHardwareInterruptHandler:FAIL[%x]\n", GetLastError() ));
        goto halCreateExit7;
    }

	/* do this only if we have to run in INTEL MODE */

    // assume TM1S+
    if ( ( *(PULONG)(Hal->MMIOAddrKernel + BIU_CTL) &
        (constTMManBIU_CTL_SE | constTMManBIU_CTL_BO | constTMManBIU_CTL_HE) ) == 0x0 )
    {	// virgin biu control
		ULONG	SwappedBIUControl;
		UCHAR	TempByte;

        SwappedBIUControl = 
            ( constTMManBIU_CTL_SE | constTMManBIU_CTL_BO | constTMManBIU_CTL_HE | constTMManBIU_CTL_SR );
        // do a dword swap
        TempByte = ((PUCHAR)&SwappedBIUControl)[0];
        ((PUCHAR)&SwappedBIUControl)[0] = ((PUCHAR)&SwappedBIUControl)[3];
        ((PUCHAR)&SwappedBIUControl)[3] = TempByte;
        TempByte = ((PUCHAR)&SwappedBIUControl)[1];
        ((PUCHAR)&SwappedBIUControl)[1] = ((PUCHAR)&SwappedBIUControl)[2];
        ((PUCHAR)&SwappedBIUControl)[2] = TempByte;

        *(PULONG)(Hal->MMIOAddrKernel + BIU_CTL) = SwappedBIUControl;
        Hal->FirstTimeReset = TRUE;
    }
    else
    {
        Hal->FirstTimeReset  = FALSE;
    }


    // set the cache details every time this function is called
    *(PULONG)(Hal->MMIOAddrKernel + DRAM_LIMIT) = Hal->SDRAMAddrPhysical.LowPart + Hal->SDRAMLength; 
    //this->MMIO.pCache->dwDRAMCacheableLimit = this->dwSDRAMPhys;
    *(PULONG)(Hal->MMIOAddrKernel + DRAM_CACHEABLE_LIMIT) = Hal->SDRAMAddrPhysical.LowPart + Hal->SDRAMLength;


	*(PULONG)(Hal->MMIOAddrKernel + ICLEAR) = (ULONG)(0x0);
	*(PULONG)(Hal->MMIOAddrKernel + IMASK) = (ULONG)(~0x0);

	Status = statusSuccess;
	*HalHandlePointer = (UInt32)Hal;
	halDumpObject ( (UInt32)Hal );

	return Status;
	/* SEH code */

halCreateExit7:
	CloseHandle ( Hal->InterruptEvent );

halCreateExit6:
	if ( TMManGlobal->MapSDRAM )
	{
	    VirtualFree(Hal->SDRAMAddrKernel,0,MEM_RELEASE);
	}

halCreateExit5:
    VirtualFree(Hal->MMIOAddrKernel,0,MEM_RELEASE);

halCreateExit4:

halCreateExit3:

halCreateExit2:
	objectFree ( Hal );

halCreateExit1:
	return Status;
}

TMStatus	halDestroy ( 
	UInt32 HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;


	if ( objectValidate ( Hal, HalFourCC ) != True )
	{
        DPF(0,("tmman:halDestroy:objectValidate:FAIL\n" ));
		return statusInvalidHandle;
	}

    TerminateThread(  Hal->hThreadHandle,  0  );

    if ( Hal->InterruptEvent )
    {
        InterruptDisable(SYSINTR_TRIMEDIA);
        CloseHandle(Hal->InterruptEvent);
        Hal->InterruptEvent = NULL;
    }