mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
856 lines
17 KiB
856 lines
17 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
amdk7.c
|
|
|
|
Abstract:
|
|
|
|
This module implements code specific to the AMDK7 processor
|
|
|
|
|
|
Author:
|
|
|
|
Todd Carpenter (1/30/01) - create file
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Notes:
|
|
|
|
DeviceInst = "ACPI\AuthenticAMD_-_x86_Family_6_Model_6"
|
|
ServiceName = "amdk7"
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
#include "..\lib\processor.h"
|
|
#include "amdk7.h"
|
|
|
|
#if DBG
|
|
PUCHAR DebugName = "AmdK7.sys";
|
|
#endif
|
|
|
|
PFDO_DATA DeviceExtensions[MAX_SUPPORTED_PROCESSORS];
|
|
UCHAR DevExtIndex;
|
|
ULONG AmdK7HackFlags;
|
|
|
|
extern GLOBALS Globals;
|
|
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text (PAGE, InitializeDriver)
|
|
#pragma alloc_text (PAGE, GetProcessorBrandString)
|
|
#pragma alloc_text (PAGE, InitializeAcpi2PStates)
|
|
#pragma alloc_text (PAGE, InitializeAcpi2Cstates)
|
|
#pragma alloc_text (PAGE, MergePerformanceStates)
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
InitializeDriver(
|
|
PUNICODE_STRING ServiceKeyRegPath
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Get AmdK7 Hack Flags
|
|
//
|
|
|
|
GetRegistryDwordValue((PWCHAR) AMDK7_PARAMETERS_KEY,
|
|
L"HackFlags",
|
|
&AmdK7HackFlags);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
FASTCALL
|
|
SetPerfLevel(
|
|
IN UCHAR Throttle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PFDO_DATA DeviceExtension;
|
|
ULONG apicId;
|
|
ULONG index = 0;
|
|
|
|
DebugEnter();
|
|
|
|
|
|
//
|
|
// Get APIC Id and retrieve Device Extension index
|
|
//
|
|
|
|
if (!Globals.SingleProcessorProfile) {
|
|
apicId = GetApicId();
|
|
index = Globals.ProcInfo.ApicIdToDevExtIndex[apicId];
|
|
}
|
|
|
|
//
|
|
// Get the DeviceExtension.
|
|
//
|
|
|
|
DeviceExtension = DeviceExtensions[index];
|
|
|
|
//
|
|
// This driver only supports FFH addresses, but SetPerfLevelGeneric
|
|
// only finds the correct state, it will then call Acpi2PerfStateTransition
|
|
//
|
|
|
|
return SetPerfLevelGeneric(Throttle, DeviceExtension);
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
FASTCALL
|
|
SetThrottleLevel(
|
|
IN UCHAR Throttle
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
PFDO_DATA DeviceExtension;
|
|
ULONG apicId;
|
|
ULONG index = 0;
|
|
|
|
DebugEnter();
|
|
|
|
//
|
|
// Get APIC Id and retrieve Device Extension index
|
|
//
|
|
|
|
if (!Globals.SingleProcessorProfile) {
|
|
apicId = GetApicId();
|
|
index = Globals.ProcInfo.ApicIdToDevExtIndex[apicId];
|
|
}
|
|
|
|
|
|
//
|
|
// Get the DeviceExtension.
|
|
//
|
|
|
|
DeviceExtension = DeviceExtensions[index];
|
|
|
|
|
|
//
|
|
// This driver supports Acpi 1.0b style of throttling, use
|
|
// generic function
|
|
//
|
|
|
|
return SetThrottleLevelGeneric(Throttle, DeviceExtension);
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
GetProcessorBrandString (
|
|
PUCHAR BrandString,
|
|
PULONG Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// This processor supports the CpuId based brand string
|
|
//
|
|
|
|
return GetCPUIDProcessorBrandString(BrandString, Size);
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
InitializeAcpi2PStates(
|
|
IN PFDO_DATA DevExt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
|
|
status = InitializeAcpi2PStatesGeneric(DevExt);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
if ((DevExt->PctPackage.Control.AddressSpaceID != AcpiGenericSpaceFixedFunction) ||
|
|
(DevExt->PctPackage.Status.AddressSpaceID != AcpiGenericSpaceFixedFunction)) {
|
|
|
|
DebugPrint((WARN, "ONLY Acpi 2.0 FFH addresses are supported\n"));
|
|
DebugPrint((WARN, "NOT using Acpi 2.0 Performance States\n"));
|
|
|
|
//
|
|
// Undo what InitializeAcpi2PStatesGeneric() did
|
|
//
|
|
|
|
if (DevExt->PssPackage) {
|
|
ExFreePool(DevExt->PssPackage);
|
|
DevExt->PssPackage = NULL;
|
|
}
|
|
|
|
return STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
//
|
|
// Walk through _PSS states to calculate latency values
|
|
//
|
|
|
|
ValidatePssLatencyValues(DevExt);
|
|
|
|
//
|
|
// Need to merge this new data with our perfstates
|
|
//
|
|
|
|
MergePerformanceStates(DevExt);
|
|
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
InitializeAcpi2Cstates(
|
|
PFDO_DATA DevExt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function looks to see if there is an ACPI 2.0 _CST object in the
|
|
namespace, and, if there is, it replaces the functions found by
|
|
InitializeAcpi1Cstates.
|
|
|
|
Further note: This function leaves the filling in of throttling functions
|
|
to the InitializePerformanceStates functions.
|
|
|
|
Arguments:
|
|
|
|
DeviceExtension
|
|
|
|
Return Value:
|
|
|
|
A NTSTATUS code to indicate the result of the initialization.
|
|
|
|
--*/
|
|
{
|
|
ULONG apicId;
|
|
ULONG index = 0;
|
|
|
|
DebugEnter();
|
|
|
|
|
|
//
|
|
// Record the address of this processor's DeviceExtension, as the
|
|
// throttling API doesn't give it to us.
|
|
//
|
|
|
|
if (!Globals.SingleProcessorProfile) {
|
|
|
|
//
|
|
// save the index into the DeviceExtension[] for later retrieval based
|
|
// on APIC Id.
|
|
//
|
|
|
|
apicId = Globals.ProcInfo.ProcIdToApicId[DevExt->ProcObjInfo.PhysicalID];
|
|
Globals.ProcInfo.ApicIdToDevExtIndex[apicId] = DevExtIndex;
|
|
|
|
index = DevExtIndex++;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// save Device Extension pointer
|
|
//
|
|
|
|
DeviceExtensions[index] = DevExt;
|
|
|
|
|
|
|
|
//
|
|
// This processor driver only supports I/O Space based Cstates.
|
|
// InitializeAcpi2IoSpaceCstates() will fail if it finds Cstates with
|
|
// non AcpiGenericSpaceIO type addresses.
|
|
//
|
|
|
|
return InitializeAcpi2IoSpaceCstates(DevExt);
|
|
|
|
}
|
|
|
|
NTSTATUS
|
|
MergePerformanceStates(
|
|
IN PFDO_DATA DeviceExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine looks at the performance states stored in the device extension.
|
|
|
|
Arguments:
|
|
|
|
DeviceExtension
|
|
|
|
|
|
Return Value:
|
|
|
|
A NTSTATUS code to indicate the result of the initialization.
|
|
|
|
NOTE:
|
|
|
|
- The caller must hold PerfStateLock.
|
|
|
|
- This is called during START_DEVICE, and after recieving a Notify(0x80)
|
|
on the processor.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
NTSTATUS findStatus;
|
|
ULONG pssState = 0xdeadbeef;
|
|
|
|
DebugEnter();
|
|
|
|
//
|
|
// This function just merges available _PSS and stop clock throttle states
|
|
//
|
|
|
|
status = MergePerformanceStatesGeneric(DeviceExtension);
|
|
|
|
//
|
|
// With amdk7.sys, the order of transition execution differs if going from a
|
|
// higher state to a lower state when compared to going from a lower state to
|
|
// a higher state... Therefore, it is important that we set the current state
|
|
// before registering new performance states with the kernel.
|
|
//
|
|
// NOTE: MergePerformanceStatesGeneric() will invalidate CurrentPerfState,
|
|
// so it must be set here.
|
|
//
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
findStatus = FindCurrentPssPerfState(DeviceExtension->PssPackage, &pssState);
|
|
|
|
if (NT_SUCCESS(findStatus)) {
|
|
DebugAssert(pssState < DeviceExtension->PssPackage->NumPStates);
|
|
DeviceExtension->CurrentPerfState = pssState;
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
Acpi2PerfStateTransition(
|
|
IN PFDO_DATA DeviceExtension,
|
|
IN ULONG NewState
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine changes the performance state of the processor
|
|
based on ACPI 2.0 performance state objects.
|
|
|
|
Arguments:
|
|
|
|
State - Index into _PSS object
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
ULONG transitionStatus;
|
|
ULONG pssControl;
|
|
ULONG64 fidControl;
|
|
ULONG64 vidControl;
|
|
ULONG64 fidVidStatus;
|
|
|
|
DebugEnter();
|
|
DebugAssert(DeviceExtension->PssPackage)
|
|
DebugAssert(NewState >= DeviceExtension->PpcResult);
|
|
DebugAssert(NewState < DeviceExtension->PssPackage->NumPStates);
|
|
DebugAssert(DeviceExtension->PssPackage->State[NewState].Control);
|
|
|
|
|
|
if (DeviceExtension->PctPackage.Control.AddressSpaceID != AcpiGenericSpaceFixedFunction) {
|
|
DebugAssert(!"Acpi2PerfStateTransition ONLY understands FFH addresses");
|
|
status = STATUS_UNSUCCESSFUL;
|
|
goto Acpi2PerfStateTransitionExit;
|
|
}
|
|
|
|
if (NewState == DeviceExtension->CurrentPssState) {
|
|
DebugPrint((WARN, "Acpi2PerfStateTransition() CurrentState == TargetState, exiting...\n"));
|
|
goto Acpi2PerfStateTransitionExit;
|
|
}
|
|
|
|
//
|
|
// Transitioning the Mobile Athlon Processor requires two steps:
|
|
//
|
|
// If transitioning from a higher state to a lower state, then:
|
|
// 1) core frequency transition
|
|
// 2) core voltage transition
|
|
//
|
|
// If transitioning from a lower state to a higher state, then:
|
|
// 1) core voltage transition
|
|
// 2) core frequency transition
|
|
//
|
|
|
|
//
|
|
// Get Frequency and Voltage value to write to MSR
|
|
//
|
|
|
|
pssControl = DeviceExtension->PssPackage->State[NewState].Control;
|
|
fidControl = ConvertPssControlToFidVidControl(pssControl, TRUE);
|
|
vidControl = ConvertPssControlToFidVidControl(pssControl, FALSE);
|
|
|
|
if (NewState > DeviceExtension->CurrentPssState) {
|
|
|
|
//
|
|
// High -> Low
|
|
//
|
|
|
|
DebugPrint((TRACE, "Perf Transition: state %u -> state %u\n", DeviceExtension->CurrentPssState, NewState));
|
|
DebugPrint((TRACE, "FidControl = 0x%I64x, VidControl = 0x%I64x\n", fidControl, vidControl));
|
|
AmdK7FidVidTransition(fidControl);
|
|
AmdK7FidVidTransition(vidControl);
|
|
|
|
|
|
} else {
|
|
|
|
//
|
|
// Low -> High
|
|
//
|
|
|
|
DebugPrint((TRACE, "Perf Transition: state %u -> state %u\n", DeviceExtension->CurrentPssState, NewState));
|
|
DebugPrint((TRACE, "VidControl = 0x%I64x, FidControl = 0x%I64x\n", vidControl, fidControl));
|
|
AmdK7FidVidTransition(vidControl);
|
|
AmdK7FidVidTransition(fidControl);
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// check status
|
|
//
|
|
|
|
fidVidStatus = ReadMSR(AMDK7_FID_VID_STATUS_MSR);
|
|
transitionStatus = ConvertFidVidStatusToPssStatus(fidVidStatus);
|
|
|
|
if (transitionStatus == DeviceExtension->PssPackage->State[NewState].Status) {
|
|
|
|
DeviceExtension->CurrentPssState = NewState;
|
|
|
|
} else {
|
|
|
|
DebugPrint((ERROR, "ERROR! Expected 0x%x status value, recieved 0x%x\n",
|
|
DeviceExtension->PssPackage->State[NewState].Status,
|
|
transitionStatus));
|
|
|
|
DebugPrint((ERROR, "_PSS[%u]->Status:\n", NewState));
|
|
DumpPssStatus(DeviceExtension->PssPackage->State[NewState].Status);
|
|
|
|
DebugPrint((ERROR, "FidVidStatus MSR:\n", fidVidStatus));
|
|
DumpFidVidStatus(fidVidStatus);
|
|
|
|
status = STATUS_UNSUCCESSFUL;
|
|
|
|
}
|
|
|
|
|
|
Acpi2PerfStateTransitionExit:
|
|
|
|
DebugExitStatus(status);
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ProcessResumeFromSleepState(
|
|
SYSTEM_POWER_STATE PreviousState,
|
|
PFDO_DATA DeviceExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
DebugEnter();
|
|
|
|
//
|
|
// if we are resuming from Hibernate, and this is an Acpi 2.0 system,
|
|
// we must re-claim perf state and cstate control from the bios.
|
|
//
|
|
|
|
if (PreviousState == PowerSystemHibernate) {
|
|
|
|
if (DeviceExtension->PssPackage) {
|
|
AssumeProcessorPerformanceControl();
|
|
}
|
|
|
|
if (DeviceExtension->CstPresent) {
|
|
AssumeCStateControl();
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// restore previous state
|
|
//
|
|
|
|
return RestoreToSavedPerformanceState(DeviceExtension);
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ProcessSuspendToSleepState(
|
|
SYSTEM_POWER_STATE TargetState,
|
|
PFDO_DATA DeviceExtension
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
{
|
|
DebugEnter();
|
|
|
|
//
|
|
// save previous state, transition to lowest non-throttled perf state
|
|
//
|
|
|
|
return SaveCurrentStateGoToLowVolts(DeviceExtension);
|
|
}
|
|
|
|
|
|
ULONG64
|
|
ConvertPssControlToFidVidControl(
|
|
ULONG PssControlValue,
|
|
BOOLEAN Fid
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
NOTES:
|
|
|
|
_PSS Control field:
|
|
|
|
Bit Name
|
|
---- ----
|
|
4:0 FID
|
|
9:5 VID
|
|
29:10 SGTC
|
|
31:30 Reserved
|
|
|
|
|
|
FidVidCtl:
|
|
|
|
Bit Name Function
|
|
---- ---- --------
|
|
4:0 FID[4:0] New 5-bit FID to transition to
|
|
7:5 reserved
|
|
12:8 VID[4:0] New 5-bit VID to transition to
|
|
15:13 reserved
|
|
16 FIDC FID Control bit
|
|
17 VIDC VID Control bit
|
|
19:18 reserved
|
|
20 FidChgRatio Fid Change Ratio (always set to 1)
|
|
31:21 reserved
|
|
51:32 SGTC[19:0] Stop-Grant Timeout Count (write only)
|
|
63:52 reserved
|
|
|
|
--*/
|
|
{
|
|
FID_VID_CONTROL fidVidControl = {0};
|
|
PSS_CONTROL pssControl;
|
|
|
|
//DebugEnter();
|
|
DebugAssert(PssControlValue);
|
|
|
|
pssControl.AsDWord = PssControlValue;
|
|
fidVidControl.Fid = pssControl.Fid;
|
|
fidVidControl.Vid = pssControl.Vid;
|
|
fidVidControl.FidChngRatio = 1;
|
|
|
|
//
|
|
// The timeout needed for the Frequency Transion (FID) is exactly half that
|
|
// needed by the Voltage Transion (VID). We do this because of the latency
|
|
// savings
|
|
//
|
|
|
|
if (Fid) {
|
|
|
|
fidVidControl.SGTC = pssControl.SGTC / 2;
|
|
fidVidControl.FidControl = 1;
|
|
|
|
} else {
|
|
|
|
fidVidControl.SGTC = pssControl.SGTC;
|
|
fidVidControl.VidControl = 1;
|
|
|
|
}
|
|
|
|
return fidVidControl.AsQWord;
|
|
|
|
}
|
|
|
|
|
|
ULONG
|
|
ConvertFidVidStatusToPssStatus(
|
|
ULONG64 FidVidStatusValue
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
NOTES:
|
|
|
|
FidVidStatus:
|
|
|
|
Bit Name Function
|
|
---- ---- --------
|
|
4:0 CFID[4:0] Current 5-bit FID
|
|
7:5 reserved
|
|
12:8 SFID[4:0] Startup 5-bit FID
|
|
15:13 reserved
|
|
20:16 MFID[4:0] Maximum 5-bit FID
|
|
31:21 reserved
|
|
36:32 CVID[4:0] Current 5-bit VID
|
|
39:37 reserved
|
|
44:40 SVID[4:0] Startup 5-bit VID
|
|
47:45 reserved
|
|
52:48 MVID[4:0] Maximum 5-bit VID
|
|
63:53 reserved
|
|
|
|
_PSS Status Field:
|
|
|
|
Bit Name
|
|
---- ----
|
|
4:0 FID current frequency
|
|
9:5 VID current voltage
|
|
31:10 reserved
|
|
|
|
|
|
--*/
|
|
{
|
|
PSS_STATUS pssStatus;
|
|
FID_VID_STATUS fidVidStatus;
|
|
|
|
//DebugEnter();
|
|
DebugAssert(FidVidStatusValue);
|
|
|
|
fidVidStatus.AsQWord = FidVidStatusValue;
|
|
pssStatus.Fid = fidVidStatus.CFid;
|
|
pssStatus.Vid = fidVidStatus.CVid;
|
|
pssStatus.Reserved = 0;
|
|
|
|
return pssStatus.AsDWord;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
FindCurrentPssPerfState(
|
|
PACPI_PSS_PACKAGE PssPackage,
|
|
PULONG PssState
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS status = STATUS_UNSUCCESSFUL;
|
|
ULONG x;
|
|
ULONG transitionStatus;
|
|
ULONG64 fidVidStatus;
|
|
|
|
DebugEnter();
|
|
DebugAssert(PssPackage);
|
|
DebugAssert(PssState);
|
|
|
|
fidVidStatus = ReadMSR(AMDK7_FID_VID_STATUS_MSR);
|
|
transitionStatus = ConvertFidVidStatusToPssStatus(fidVidStatus);
|
|
|
|
for (x=0; x < PssPackage->NumPStates; x++) {
|
|
|
|
if (transitionStatus == PssPackage->State[x].Status) {
|
|
status = STATUS_SUCCESS;
|
|
*PssState = x;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
DebugExitStatus(status);
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
#if DBG
|
|
VOID
|
|
DumpFidVidStatus(
|
|
IN ULONG64 FidVidStatus
|
|
)
|
|
{
|
|
FID_VID_STATUS status;
|
|
|
|
status.AsQWord = FidVidStatus;
|
|
|
|
DebugPrint((MAXTRACE, " CFid: 0x%x\n", status.CFid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved1));
|
|
DebugPrint((MAXTRACE, " SFid: 0x%x\n", status.SFid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved2));
|
|
DebugPrint((MAXTRACE, " MFid: 0x%x\n", status.MFid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved3));
|
|
DebugPrint((MAXTRACE, " CVid: 0x%x\n", status.CVid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved4));
|
|
DebugPrint((MAXTRACE, " SVid: 0x%x\n", status.SVid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved5));
|
|
DebugPrint((MAXTRACE, " MVid: 0x%x\n", status.MVid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved6));
|
|
DebugPrint((MAXTRACE, "\n"));
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpFidVidControl(
|
|
IN ULONG64 FidVidControl
|
|
)
|
|
{
|
|
FID_VID_CONTROL control;
|
|
|
|
control.AsQWord = FidVidControl;
|
|
|
|
DebugPrint((MAXTRACE, " Fid: 0x%x\n", control.Fid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", control.Reserved1));
|
|
DebugPrint((MAXTRACE, " Vid: 0x%x\n", control.Vid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", control.Reserved2));
|
|
DebugPrint((MAXTRACE, " FidControl: 0x%x\n", control.FidControl));
|
|
DebugPrint((MAXTRACE, " VidControl: 0x%x\n", control.VidControl));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", control.Reserved3));
|
|
DebugPrint((MAXTRACE, " FidChngRatio: 0x%x\n", control.FidChngRatio));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", control.Reserved4));
|
|
DebugPrint((MAXTRACE, " SGTC: 0x%x\n", control.SGTC));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", control.Reserved5));
|
|
DebugPrint((MAXTRACE, "\n"));
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpPssStatus(
|
|
IN ULONG PssStatus
|
|
)
|
|
{
|
|
PSS_STATUS status;
|
|
|
|
status.AsDWord = PssStatus;
|
|
|
|
DebugPrint((MAXTRACE, " Fid: 0x%x\n", status.Fid));
|
|
DebugPrint((MAXTRACE, " Vid: 0x%x\n", status.Vid));
|
|
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", status.Reserved));
|
|
DebugPrint((MAXTRACE, "\n"));
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpPssControl(
|
|
IN ULONG PssControl
)
{
PSS_CONTROL control;
control.AsDWord = PssControl;
DebugPrint((MAXTRACE, " Fid: 0x%x\n", control.Fid));
DebugPrint((MAXTRACE, " Vid: 0x%x\n", control.Vid));
DebugPrint((MAXTRACE, " SGTC: 0x%x\n", control.SGTC));
DebugPrint((MAXTRACE, " Reserved: 0x%x\n", control.Reserved));
DebugPrint((MAXTRACE, "\n"));
}
#endif
|