?? tmhal.c
字號:
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 );
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -