tmhal.c

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

	for ( Idx = 3 ; Idx < constTMMANPCIRegisters ; Idx ++ )
	{
		if ( pciWriteConfigDW ((BYTE)Hal->BusNumber,
			DevFunc2BYTE(Hal->DeviceNumber, Hal->FunctionNumber), 
			(WORD)Idx*4, Hal->PCIRegisters[Idx] ) == FALSE )
		{
			return statusPCIConfigAccessFail; 
		}
	}

	if ( pciWriteConfigDW ((BYTE)Hal->BusNumber,
		DevFunc2BYTE(Hal->DeviceNumber, Hal->FunctionNumber), 
		(WORD)1*4, Hal->PCIRegisters[1] ) == FALSE )
	{
		return statusPCIConfigAccessFail; 
	}


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

    }

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

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

}

TMStatus	halGetMMIOInfo (
	UInt32	HalHandle,
	Pointer *MMIOPhysical, 
	Pointer *MMIOKernelMapped, 
	UInt32 *MMIOSize )

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

	*MMIOPhysical = (Pointer)Hal->MMIOAddrPhysical.LowPart;
	*MMIOKernelMapped = Hal->MMIOAddrKernel;
	*MMIOSize = Hal->MMIOLength;
	return statusSuccess;
}

TMStatus	halGetSDRAMInfo ( 
	UInt32	HalHandle,
	Pointer *SDRAMPhysical, 
	Pointer *SDRAMKernelMapped, 
	UInt32 *SDRAMSize )
{
	HalObject*	Hal = (HalObject*)HalHandle;

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

	*SDRAMPhysical = (Pointer)Hal->SDRAMAddrPhysical.LowPart;
	*SDRAMKernelMapped = Hal->SDRAMAddrKernel;
	*SDRAMSize = Hal->SDRAMLength;
	return statusSuccess;

}

TMStatus	halGetTMPCIInfo ( 
	UInt32	HalHandle,
	UInt32* DeviceVendorID,
	UInt32* SubsystemID,
	UInt32* ClassRevisionID )
{
	HalObject*	Hal = (HalObject*)HalHandle;

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

	*DeviceVendorID = Hal->TMDeviceVendorID;
	*SubsystemID = Hal->TMSubsystemID;
	*ClassRevisionID = Hal->TMClassRevisionID;

	return statusSuccess;
}

TMStatus	halGetBridgePCIInfo ( 
	UInt32	HalHandle,
	UInt32* DeviceVendorID,
	UInt32* SubsystemID,
	UInt32* ClassRevisionID )
{
	HalObject*	Hal = (HalObject*)HalHandle;

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

	*DeviceVendorID = Hal->BridgeDeviceVendorID;
	*SubsystemID = Hal->BridgeSubsystemID;
	*ClassRevisionID = Hal->BridgeClassRevisionID;


	return statusSuccess;
}

TMStatus	halInstallHandler ( 
	UInt32	HalHandle,
	HalInterruptHandler Handler, 
	Pointer Context )
{
	HalObject*	Hal = (HalObject*)HalHandle;


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

	Hal->Handler = Handler;
	Hal->Context = Context;
	return statusSuccess;
}

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

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

	Hal->Handler = NULL;
	return statusSuccess;
}

TMStatus	halDisableInterrupts ( 
	UInt32	HalHandle,
	UInt32* Saved );

TMStatus	halRestoreInterrupts ( 
	UInt32	HalHandle,
	UInt32* Saved );

TMStatus	halDisableIRQ ( 
	UInt32	HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;
	ULONG	InterruptControl;

	if ( objectValidate ( Hal, HalFourCC ) != True )
	{
		DPF(0,("tmman:halDisableIRQ:objectValidate:FAIL\n" ));
		return statusInvalidHandle;
	}
	InterruptControl = *(Hal->MMIOAddrKernel + INT_CTL);

	// here SelfInterrupt indicates PCI Interrupt A
	// INT#A = 0, INT#B = 1, INT#C = 2, INT#D = 3
	// disable interrupts from the target by INT_CTL->IE off.
	InterruptControl &= ~( 0x10 << ( Hal->SelfInterrupt ) );

	*(PULONG)(Hal->MMIOAddrKernel + INT_CTL) = InterruptControl;

	return statusSuccess;
}

TMStatus	halEnableIRQ ( 
	UInt32	HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;
	ULONG	InterruptControl;

	if ( objectValidate ( Hal, HalFourCC ) != True )
	{
		DPF(0,("tmman:halEnableIRQ:objectValidate:FAIL\n" ));
		return statusInvalidHandle;
	}
	InterruptControl = *(Hal->MMIOAddrKernel + INT_CTL);
	InterruptControl |= ( 0x10 << ( Hal->SelfInterrupt ) );
	*(PULONG)(Hal->MMIOAddrKernel + INT_CTL) = InterruptControl;

	return statusSuccess;
}

TMStatus	halGenerateInterrupt ( 
	UInt32	HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;
	if ( objectValidate ( Hal, HalFourCC ) != True )
	{
		DPF(0,("tmman:halGenerateInterrupt:objectValidate:FAIL\n" ));
		return statusInvalidHandle;
	}
/*
	DPF(0,("tmman:halGenerateInterrupt1:IPENDING[%x]:ICLEAR[%x]:IMASK[%x]\n",
		*(PULONG)(Hal->MMIOAddrKernel + IPENDING),
		*(PULONG)(Hal->MMIOAddrKernel + ICLEAR),
		*(PULONG)(Hal->MMIOAddrKernel + IMASK ) ));	
*/
	*(PULONG)(Hal->MMIOAddrKernel + IPENDING) = ( 1<< Hal->PeerInterrupt ); 
/*
	DPF(0,("tmman:halGenerateInterrupt2:IPENDING[%x]:ICLEAR[%x]:IMASK[%x]\n",
		*(PULONG)(Hal->MMIOAddrKernel + IPENDING),
		*(PULONG)(Hal->MMIOAddrKernel + ICLEAR),
		*(PULONG)(Hal->MMIOAddrKernel + IMASK ) ));	
*/
	return statusSuccess;
}

TMStatus	halAcknowledgeInterrupt (
	UInt32	HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;
	ULONG	InterruptControl;

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

	/* FOR TM1 */
	/*
		reset	MMIO->dwInterruptControl:INT(3..0)
		reset	MMIO->dwInterruptControl:IE(7..4)
	*/
	while ( 1 )
	{
		if ( halAccess32 ( HalHandle, 
			Hal->Control->TargetInterruptSpinLock  ) == False )
		{
			Hal->Control->HostInterruptSpinLock = 
				halAccess32 ( HalHandle, True  );

			if ( halAccess32 ( HalHandle, 
				Hal->Control->TargetInterruptSpinLock  ) == True )
			{
				Hal->Control->HostInterruptSpinLock = 
					halAccess32 ( HalHandle, False  );			
			}
			else
			{
				InterruptControl = *(Hal->MMIOAddrKernel + INT_CTL);

				// here SelfInterrupt indicates PCI Interrupt A
				// INT#A = 0, INT#B = 1, INT#C = 2, INT#D = 3
				InterruptControl &=
					( ~( 1 << ( Hal->SelfInterrupt ) )  &
					~( 0x10 << ( Hal->SelfInterrupt ) ) );

				*(PULONG)(Hal->MMIOAddrKernel + INT_CTL) = InterruptControl;

				Hal->Control->HostInterruptSpinLock = 
					halAccess32 ( HalHandle, False  );
				break;
			}

		}
	}

	return statusSuccess;
}

BOOL	halHardwareInterruptHandler (
	ULONG VMHandle, 
	ULONG IRQHandle, 
	PVOID Context )
{
	// we should be getting the board handle from the IRQHandle
	HalObject*	Hal = (HalObject*)Context;
	UInt32	InterruptControl;


	InterruptControl = *(Hal->MMIOAddrKernel + INT_CTL);

	// here SelfInterrupt indicates PCI Interrupt A
	// INT#A = 0, INT#B = 1, INT#C = 2, INT#D = 3

	if ( ( InterruptControl &
		( (1 << Hal->SelfInterrupt)  | (0x10 << Hal->SelfInterrupt) ) ) !=
		( (1 << Hal->SelfInterrupt)  | (0x10 << Hal->SelfInterrupt) ) )
	{
		return FALSE;
	}

	/*
	DPF(0,("tmman:halHardwareInterruptHandler:Interrupt[%x]:ServiceContext[%x]\n",
		Interrupt, ServiceContext ));	
	*/

	winSchedule_VM_Event( 
		winGet_Sys_VM_Handle(),
		vxdDPCHandlerA, 
		Hal, 
		&Hal->DPCObject);

	halAcknowledgeInterrupt ( (UInt32)Hal ); 

	winVPICD_Phys_EOI( Hal->InterruptObject );

    return TRUE;
}

VOID    halDeferredInterruptHandler  ( 
	ULONG VMHandle, 
	PVOID Context,
	PVOID ClientRegister )
{
	HalObject*	Hal = (HalObject*)Context;
	/*	DPF(0,("HL{")); */
	/*
	DPF(0,("tmman:halDeferredInterruptHandler:DPC[%x]:DeviceObject[%x]:Irp[%x]:Context[%x]\n",
		Dpc, DeviceObject, Irp, Context ));	
	*/
	Hal->Handler(Hal->Context);
	/*	DPF(0,("}HL" )); */
}


UInt32	halAccess32( 
	UInt32	HalHandle,
	UInt32 volatile Value )
{
	UInt32	SwappedValue,TempValue;
	TempValue = Value;

	/* we don't validate the object for efficiency reasons */
	if ( ((HalObject*)HalHandle)->Swapping )
	{
		((UInt8*)&SwappedValue)[3] = ((UInt8*)&TempValue)[0];
		((UInt8*)&SwappedValue)[2] = ((UInt8*)&TempValue)[1];
		((UInt8*)&SwappedValue)[1] = ((UInt8*)&TempValue)[2];
		((UInt8*)&SwappedValue)[0] = ((UInt8*)&TempValue)[3];
/*		DPF(0,("[%x->%x]",TempValue, SwappedValue )); */
		return ( SwappedValue );
	}
	else
	{
		return Value;
	}
	
}

UInt16	halAccess16 ( 
	UInt32	HalHandle,
	UInt16 volatile Value )
{
	/* we don't validate the object for efficiency reasons */
	UInt16	SwappedValue,TempValue;
	TempValue = Value;

	if ( ((HalObject*)HalHandle)->Swapping )
	{
		((UInt8*)&SwappedValue)[1] = ((UInt8*)&TempValue)[0];
		((UInt8*)&SwappedValue)[0] = ((UInt8*)&TempValue)[1];
		/* DPF(0,("[%x->%x]",TempValue, SwappedValue )); */
		return ( SwappedValue );
	}
	else
	{
		return Value;
	}
	return Value;
}

void	halCopyback( Pointer CacheBlock, UInt32 BlockCount  )
{
	/*	no implementation for this platform */
}

void	halAccessEnable ( 
	UInt32	HalHandle )
{
	/*	no implementation for this platform */
}

void	halAccessDisable ( 
	UInt32	HalHandle )
{
	/*	no implementation for this platform */
}

void	halDumpObject (
 	UInt32	HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;

    DPF(1,("\ntmman:halDumpObject\n"));
	
    DPF(1,("[SelfInterrupt:%x]\n", Hal->SelfInterrupt));
	DPF(1,("[PeerInterrupt:%x]\n", Hal->PeerInterrupt));
	DPF(1,("[Handler:%x]\n", Hal->Handler));
	DPF(1,("[Context:%x]\n", Hal->Context));
	DPF(1,("[BusNumber:%x]\n", Hal->BusNumber));

//	DPF(1,("[SlotNumber|DeviceNumber:%x|FunctionNumber:%x]\n",
//		Hal->SlotNumber.u.bits.DeviceNumber, Hal->SlotNumber.u.bits.FunctionNumber));

	DPF(1,("[MMIOAddrPhysical|HighPart:%x|LowPart:%x]\n", 
		Hal->MMIOAddrPhysical.HighPart, Hal->MMIOAddrPhysical.LowPart));
	DPF(1,("[MMIOLength:%x]\n", Hal->MMIOLength));
	DPF(1,("[MMIOAddrKernel:%x]\n", Hal->MMIOAddrKernel));


	DPF(1,("[SDRAMAddrPhysical|HighPart:%x|LowPart:%x]\n", 
		Hal->SDRAMAddrPhysical.HighPart, Hal->SDRAMAddrPhysical.LowPart));
	DPF(1,("[SDRAMLength:%x]\n", Hal->SDRAMLength));
	DPF(1,("[SDRAMAddrKernel:%x]\n", Hal->SDRAMAddrKernel));

	DPF(1,("[InterruptObject:%x]\n", Hal->InterruptObject));
	DPF(1,("\n"));

}    



TMStatus	halSwapEndianess ( 
	UInt32	HalHandle,
	Bool	SwapEnable )
{
	HalObject*	Hal = (HalObject*)HalHandle;
	Hal->Swapping = SwapEnable;
	DPF(0,("tmman:halSwapEndianess:Swapping[%x]\n", SwapEnable )); 

	return statusSuccess;
}

TMStatus	halGetEndianess ( 
	UInt32	HalHandle,
	Bool*	SwapEnablePtr )
{
	HalObject*	Hal = (HalObject*)HalHandle;
	*SwapEnablePtr = Hal->Swapping;

	return statusSuccess;
}

void halAdjustOffset(UInt32	HalHandle,UInt32 *address)
{
	HalObject*	Hal = (HalObject*)HalHandle;

    *address += Hal->Offset;
}


BOOLEAN	halMapSDRAM ( UInt32 HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;

	if ( TMManGlobal->MapSDRAM )
	{
		return TRUE;
	}


	if ( InterlockedIncrement ( &Hal->SDRAMMapCount ) != 1 )
	{
		return TRUE;
	}


	if ( ( Hal->SDRAMAddrKernel = (PUCHAR)winMapPhysToLinear (
		Hal->SDRAMHostAddrPhysical.LowPart,
		Hal->SDRAMLength,
		0 ) ) == (PUCHAR)0xFFFFFFFF )
	{
		DPF(0,("tmman:halMapSDRAM:winMapPhysToLinear:SDRAM:FAIL\n" ));
		return  FALSE;

	}

	return TRUE;

}

BOOLEAN	halUnmapSDRAM ( UInt32 HalHandle )
{
	HalObject*	Hal = (HalObject*)HalHandle;

	if ( TMManGlobal->MapSDRAM )
	{
		return TRUE;
	}

	if ( Hal->SDRAMMapCount == 0 )
	{
		return FALSE;
	}

	if ( InterlockedDecrement  ( &Hal->SDRAMMapCount ) != 0 )
	{
		return TRUE;
	}

	return TRUE;
}

UInt32	halTranslateTargetPhysicalAddress ( 
	UInt32 HalHandle, 
	UInt32 PhysicalAddress )
{
	HalObject*	Hal = (HalObject*)HalHandle;

	return ( PhysicalAddress + Hal->Offset );
}