/*++

Copyright (c) 1998  Microsoft Corporation

Module Name:

    thermal

Abstract:

    WinDbg Extension Api

Author:

Environment:

    User Mode.

Revision History:

--*/

#include "precomp.h"
#pragma hdrstop

#define TZ_LOOP             0x00000001
#define TZ_DUMP_INFO        0x00000002
#define TZ_NO_HEADER        0x80000000

PCHAR    DumpPowerStateMappings[10] = {
    "x", "0", "1", "2", "3", "4", "5", "?", "?", "?"
};

PCHAR    DumpPowerActionMappings[] = {
    "     None",
    " Reserved",
    "    Sleep",
    "Hibernate",
    " Shutdown",
    "    Reset",
    "      Off"
};

PCHAR   DumpDynamicThrottleMapping[] = {
    "    None",
    "Constant",
    " Degrade",
    "Adaptive",
    " Maximum"
};

PCHAR
DumpTimeInStandardForm(
    IN  ULONG64   CurrentTime
    )
/*++

Routine Description:

    Print the Kernel's view of time into something that a user can
    understand

Arguments:

    CurrentTime - Kernel's Idea of time

Return Value:

    None

--*/
{
    static  CHAR    TimeBuffer[256];
    ULONG           TimeIncrement;
    TIME_FIELDS     Times;
    LARGE_INTEGER   RunTime;

    TimeIncrement = GetNtDebuggerDataValue( KeTimeIncrement );
    RunTime.QuadPart = UInt32x32To64(CurrentTime, TimeIncrement);
    RtlTimeToElapsedTimeFields( &RunTime, &Times);
    if (Times.Hour) {
        sprintf(TimeBuffer,"%3ld:%02ld:%02ld.%03lds",
                Times.Hour,
                Times.Minute,
                Times.Second,
                Times.Milliseconds);
    } else if (Times.Minute) {
        sprintf(TimeBuffer,"%02ld:%02ld.%03lds",
                Times.Minute,
                Times.Second,
                Times.Milliseconds);
    } else {
        sprintf(TimeBuffer,"%02ld.%03lds",
                Times.Second,
                Times.Milliseconds);
    }
    return TimeBuffer;
}

PCHAR
DumpMicroSecondsInStandardForm(
    IN  ULONG64 CurrentTime
    )
{
    static CHAR     PerfBuffer[256];
    ULONG64         FreqAddr;
    LARGE_INTEGER   Freq;
    ULONG           Result;
    ULONG64         MicroSeconds;
    ULONG64         MilliSeconds;
    ULONG64         Seconds;
    ULONG64         Minutes;
    ULONG64         Hours;
    ULONG64         Days;

    MicroSeconds = CurrentTime;
    MilliSeconds = MicroSeconds / 1000;
    MicroSeconds = MicroSeconds % 1000;

    Seconds      = MilliSeconds / 1000;
    MilliSeconds = MilliSeconds % 1000;

    Minutes = Seconds / 60;
    Seconds = Seconds % 60;

    Hours   = Minutes / 60;
    Minutes = Minutes % 60;

    Days  = Hours / 24;
    Hours = Hours % 24;

#if 0
    sprintf(PerfBuffer,"%02ld:%02ld:%02ld.%03ld.%03lds",
            (ULONG)Hours,
            (ULONG)Minutes,
            (ULONG)Seconds,
            (ULONG)MilliSeconds,
            (ULONG)MicroSeconds
            );
    return PerfBuffer;
#endif

    if (Hours) {
        sprintf(PerfBuffer,"%02ld:%02ld:%02ld.%03ld.%03lds",
                (ULONG)Hours,
                (ULONG)Minutes,
                (ULONG)Seconds,
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    } else if (Minutes) {
        sprintf(PerfBuffer,"%02ld:%02ld.%03ld.%03lds",
                (ULONG)Minutes,
                (ULONG)Seconds,
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    } else if (Seconds) {
        sprintf(PerfBuffer,"%02ld.%03ld.%03lds",
                (ULONG)Seconds,
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    } else {
        sprintf(PerfBuffer,".%03ld.%03lds",
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    }
    return PerfBuffer;
}


PCHAR
DumpPerformanceCounterInStandardForm(
    IN  ULONG64 CurrentTime
    )
/*++

Routine Description:

    Print a performance counter's view of time into something that a
    user can understand

--*/
{
    static CHAR     PerfBuffer[256];
    ULONG64         FreqAddr;
    LARGE_INTEGER   Freq;
    ULONG           Result;
    ULONG64         MicroSeconds;
    ULONG64         MilliSeconds;
    ULONG64         Seconds;
    ULONG64         Minutes;
    ULONG64         Hours;
    ULONG64         Days;

    FreqAddr = GetExpression( "nt!KdPerformanceCounterRate" );
    if (!FreqAddr || !ReadMemory( FreqAddr, &Freq, sizeof(Freq), &Result) ) {
        sprintf(PerfBuffer,"<unknown rate>");
        return PerfBuffer;
    }


    MicroSeconds = (CurrentTime * 1000000L) / Freq.LowPart;
    MilliSeconds = MicroSeconds / 1000;
    MicroSeconds = MicroSeconds % 1000;

    Seconds      = MilliSeconds / 1000;
    MilliSeconds = MilliSeconds % 1000;

    Minutes = Seconds / 60;
    Seconds = Seconds % 60;

    Hours   = Minutes / 60;
    Minutes = Minutes % 60;

    Days  = Hours / 24;
    Hours = Hours % 24;

#if 0
    sprintf(PerfBuffer,"%02ld:%02ld:%02ld.%03ld.%03lds",
            (ULONG)Hours,
            (ULONG)Minutes,
            (ULONG)Seconds,
            (ULONG)MilliSeconds,
            (ULONG)MicroSeconds
            );
    return PerfBuffer;
#endif

    if (Hours) {
        sprintf(PerfBuffer,"%02ld:%02ld:%02ld.%03ld.%03lds",
                (ULONG)Hours,
                (ULONG)Minutes,
                (ULONG)Seconds,
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    } else if (Minutes) {
        sprintf(PerfBuffer,"%02ld:%02ld.%03ld.%03lds",
                (ULONG)Minutes,
                (ULONG)Seconds,
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    } else if (Seconds) {
        sprintf(PerfBuffer,"%02ld.%03ld.%03lds",
                (ULONG)Seconds,
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    } else {
        sprintf(PerfBuffer,".%03ld.%03lds",
                (ULONG)MilliSeconds,
                (ULONG)MicroSeconds
                );
    }
    return PerfBuffer;
}

VOID
DumpTemperatureInKelvins(
    IN  ULONG                   Temperature
    )
/*++

Routine Description:

    Dumps the temperatures in Kelvins

Arguments:

    Temperature - What to dump in Kelvins

Return Value:

    None

--*/
{
    dprintf(" (%d.%dK)", (Temperature / 10), (Temperature % 10) );
}

VOID
DumpPowerActionPolicyBrief(
    IN  ULONG    Action,
    IN  ULONG    Flags,
    IN  ULONG    EventCode
    )
{
    dprintf("%s  Flags: %08lx   Event: %08lx  ",
            DumpPowerActionMappings[Action],
            Flags,
            EventCode
            );
    if (Flags & POWER_ACTION_QUERY_ALLOWED) {

        dprintf(" Query");

    }
    if (Flags & POWER_ACTION_UI_ALLOWED) {

        dprintf(" UI");

    }
    if (Flags & POWER_ACTION_OVERRIDE_APPS) {

        dprintf(" Override");

    }
    if (Flags & POWER_ACTION_LOCK_CONSOLE) {

        dprintf(" Lock");

    }
    if (Flags & POWER_ACTION_DISABLE_WAKES) {

        dprintf(" NoWakes");

    }
    if (Flags & POWER_ACTION_CRITICAL) {

        dprintf(" Critical");

    }

    if (EventCode & POWER_LEVEL_USER_NOTIFY_TEXT) {

        dprintf(" NotifyText");

    }
    if (EventCode & POWER_LEVEL_USER_NOTIFY_SOUND) {

        dprintf(" NotifySound");

    }
    if (EventCode & POWER_LEVEL_USER_NOTIFY_EXEC) {

        dprintf(" NotifyExec");

    }
    dprintf("\n");
}

VOID
DumpSystemPowerPolicy(
    IN  PCHAR                  Pad,
    IN  ULONG64                Address,
    IN  ULONG                  Flags
    )
/*++

Routine Description:

    System Power Policy change

Arguments:

Return Value:

--*/
{
    UCHAR   temp;

    InitTypeRead(Address, nt!_SYSTEM_POWER_POLICY);
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%sSYSTEM_POWER_POLICY (R.%d) @ 0x%08p\n",
                Pad, (ULONG) ReadField(Revision), Address);

    }

    temp = (UCHAR) ReadField(DynamicThrottle);
    if (temp > PO_THROTTLE_MAXIMUM) {
        temp = PO_THROTTLE_MAXIMUM;
    }

    dprintf("%s  PowerButton:     ", Pad);
    DumpPowerActionPolicyBrief( (ULONG) ReadField(PowerButton.Action),
                                (ULONG) ReadField(PowerButton.Flags),
                                (ULONG) ReadField(PowerButton.EventCode));
    dprintf("%s  SleepButton:     ", Pad);
    DumpPowerActionPolicyBrief( (ULONG) ReadField(SleepButton.Action),
                                (ULONG) ReadField(SleepButton.Flags),
                                (ULONG) ReadField(SleepButton.EventCode));
    dprintf("%s  LidClose:        ", Pad);
    DumpPowerActionPolicyBrief( (ULONG) ReadField(LidClose.Action),
                                (ULONG) ReadField(LidClose.Flags),
                                (ULONG) ReadField(LidClose.EventCode));
    dprintf("%s  Idle:            ", Pad);
    DumpPowerActionPolicyBrief( (ULONG) ReadField(Idle.Action),
                                (ULONG) ReadField(Idle.Flags),
                                (ULONG) ReadField(Idle.EventCode));
    dprintf("%s  OverThrottled:   ", Pad);
    DumpPowerActionPolicyBrief( (ULONG) ReadField(OverThrottled.Action),
                                (ULONG) ReadField(OverThrottled.Flags),
                                (ULONG) ReadField(OverThrottled.EventCode));
    dprintf("%s  IdleTimeout:      %8lx  IdleSensitivity:        %d%%\n",
            Pad,
            (ULONG) ReadField(IdleTimeout),
            (ULONG) ReadField(IdleSensitivity));
    dprintf("%s  MinSleep:               S%s  MaxSleep:               S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(MinSleep)],
            DumpPowerStateMappings[(ULONG) ReadField(MaxSleep)]);
    dprintf("%s  LidOpenWake:            S%s  FastSleep:              S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(LidOpenWake)],
            DumpPowerStateMappings[(ULONG) ReadField(ReducedLatencySleep)]);
    dprintf("%s  WinLogonFlags:    %8lx  S4Timeout:        %8lx\n",
            Pad,
            (ULONG) ReadField(WinLogonFlags),
            (ULONG) ReadField(DozeS4Timeout));
    dprintf("%s  VideoTimeout:     %8d  VideoDim:               %2d\n",
            Pad,
            (ULONG) ReadField(VideoTimeout),
            (ULONG) ReadField(VideoDimDisplay));
    dprintf("%s  SpinTimeout:      %8lx  OptForPower:            %2d\n",
            Pad,
            (ULONG) ReadField(SpindownTimeout),
            (ULONG) ReadField(OptimizeForPower)
            );
    dprintf("%s  FanTolerance:         %4d%% ForcedThrottle:       %4d%%\n",
            Pad,
            (ULONG) ReadField(FanThrottleTolerance),
            (ULONG) ReadField(ForcedThrottle));
    dprintf("%s  MinThrottle:          %4d%% DyanmicThrottle:  %8s (%d)\n",
            Pad, (ULONG) ReadField(MinThrottle),
            DumpDynamicThrottleMapping[temp],
            temp
            );
}

DECLARE_API( popolicy )
/*++

Routine Description:

    Dumps the power policy

Arguments:

Return Value:

--*/
{
    ULONG64                     Address = 0;
    ULONG64                     PolicyAddress;
    ULONG                       Flags = 0;
    ULONG                       Result;

    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (!Address) {

        Address = GetExpression("nt!PopPolicy");
        if (!Address) {

            dprintf("Could not read PopPolicy\n");
            return E_INVALIDARG;

        }
        if (!ReadPointer(Address,
                    &PolicyAddress) ) {

            dprintf("Could not read PopPolicy at %p\n", Address );
            return E_INVALIDARG;

        }
        Address = PolicyAddress;

    }
    if (!Address) {

        dprintf("!popolicy [addr [flags]]\n");
        return E_INVALIDARG;

    }

    if (GetFieldValue( Address,
                       "nt!_SYSTEM_POWER_POLICY",
                       "Revision",
                       Result) ) {

        dprintf("Could not read PopPolicy at %p\n", Address );
        return E_INVALIDARG;

    }

    DumpSystemPowerPolicy( "", Address, Flags );
    return S_OK;
}

VOID
DumpProcessorPowerPolicy(
    IN  PCHAR                  Pad,
    IN  ULONG64                Address,
    IN  ULONG                  Flags
    )
/*++

Routine Description:

    Processor Power Policy change

Arguments:

Return Value:

--*/
{
    ULONG   i;
    ULONG   count;
    ULONG   offset;
    ULONG64 size;

    InitTypeRead(Address, nt!_PROCESSOR_POWER_POLICY);
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%sPROCESSOR_POWER_POLICY %p (Rev .%d)\n",
                Pad,
                Address,
                (ULONG) ReadField(Revision)
                );

    }

    dprintf(
        "%s  DynamicThrottle:                %4d   PolicyCount:                 %8d\n",
        Pad,
        (ULONG) ReadField(DynamicThrottle),
        (ULONG) ReadField(PolicyCount)
        );

    GetFieldOffset("nt!_PROCESSOR_POWER_POLICY", "Policy", &offset);
    Address += offset;
    size = GetTypeSize("nt!_PROCESSOR_POWER_POLICY_INFO");
    count = (ULONG) ReadField(PolicyCount);
    if (count > 3) {

        count = 3;

    }

    //
    // Walk the PROCESSOR_POWER_POLICY_INFO structures
    //
    for (i = 0; i < count; i++) {

        InitTypeRead(Address, nt!_PROCESSOR_POWER_POLICY_INFO);
        dprintf(
            "\n%s  PROCESSOR_POWER_POLICY_INFO %p\n",
            Pad,
            Address
            );
        dprintf(
            "%s  PromotePercent:                 %4d%%  DemotePercent:             %4d%%\n",
            Pad,
            (ULONG) ReadField( PromotePercent ),
            (ULONG) ReadField( DemotePercent )
            );
        dprintf(
            "%s  AllowPromotion:                %5s   AllowDemotion:            %5s\n",
            Pad,
            ( (ULONG) ReadField( AllowPromotion ) ? " TRUE" : "FALSE"),
            ( (ULONG) ReadField( AllowDemotion) ? " TRUE" : "FALSE")
            );
        dprintf(
            "%s  TimeCheck:                %21s (%8p)\n",
            Pad,
            DumpMicroSecondsInStandardForm( ReadField( TimeCheck ) ),
            (ULONG) ReadField( TimeCheck )
            );
        dprintf(
            "%s  PromoteLimit:             %21s (%8p)\n",
            Pad,
            DumpMicroSecondsInStandardForm( ReadField( PromoteLimit ) ),
            (ULONG) ReadField( PromoteLimit )
            );
        dprintf(
            "%s  DemoteLimit:              %21s (%8p)\n",
            Pad,
            DumpMicroSecondsInStandardForm( ReadField( DemoteLimit ) ),
            (ULONG) ReadField( DemoteLimit )
            );
        Address += size;

    }

}

DECLARE_API( poprocpolicy )
/*++

Routine Description:

    Dumps the power policy

Arguments:

Return Value:

--*/
{
    ULONG64                     Address = 0;
    ULONG64                     PolicyAddress;
    ULONG                       Flags = 0;
    ULONG                       Result;

    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (!Address) {

        Address = GetExpression("nt!PopProcessorPolicy");
        if (!Address) {

            dprintf("Could not read PopProcessorPolicy\n");
            return E_INVALIDARG;

        }
        if (!ReadPointer(Address,&PolicyAddress) ) {

            dprintf("Could not read PopProcessorPolicy at %p\n", Address );
            return E_INVALIDARG;

        }
        Address = PolicyAddress;

    }
    if (!Address) {

        dprintf("!poprocpolicy [addr [flags]]\n");
        return E_INVALIDARG;

    }

    if (GetFieldValue( Address,"PROCESSOR_POWER_POLICY", "Revision", Result) ) {

        dprintf("Could not read PopProcessorPolicy at %p\n", Address );
        return E_INVALIDARG;

    }

    DumpProcessorPowerPolicy( "", Address, Flags );
    return S_OK;
}

VOID
DumpProcessorPowerState(
    IN  PCHAR                 Pad,
    IN  ULONG64               Address,
    IN  ULONG                 Flags
    )
/*++

Routine Description:

    Processor Power State dump

Arguments:

Return Value:

--*/
{
    ULONG   time;
    ULONG   temp;
    CHAR    FunctionName[256];
    ULONG64 Offset;

    InitTypeRead(Address, nt!_PROCESSOR_POWER_STATE);
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%sPROCESSOR_POWER_STATE %p\n", Pad, Address );

    }

    dprintf(
        "%s  IdleState:          %16p   IdleHandlers:       %16p\n",
        Pad,
        ReadField(IdleState),
        ReadField(IdleHandlers)
        );
    dprintf(
        "%s  C1 Idle Transitions:        %8lx   C1 Idle Time:       %17s\n",
        Pad,
        (ULONG) ReadField( TotalIdleTransitions[0] ),
        DumpPerformanceCounterInStandardForm( ReadField( TotalIdleStateTime[0] ) )
        );
    dprintf(
        "%s  C2 Idle Transitions:        %8lx   C2 Idle Time:       %17s\n",
        Pad,
        (ULONG) ReadField( TotalIdleTransitions[1] ),
        DumpPerformanceCounterInStandardForm( ReadField( TotalIdleStateTime[1] ) )
        );
    dprintf(
        "%s  C3 Idle Transitions:        %8lx   C3 Idle Time:       %17s\n\n",
        Pad,
        (ULONG) ReadField( TotalIdleTransitions[2] ),
        DumpPerformanceCounterInStandardForm( ReadField( TotalIdleStateTime[2] ) )
        );
    dprintf(
        "%s  DebugDelta:         %16I64x   LastCheck:          %17s\n",
        Pad,
        ReadField(DebugDelta),
        DumpPerformanceCounterInStandardForm( ReadField( LastCheck ) )
        );
    dprintf(
        "%s  DebugCount:                 %8lx   IdleTime.Start:     %17s\n",
        Pad,
        (ULONG) ReadField(DebugCount),
        DumpPerformanceCounterInStandardForm( ReadField( IdleTimes.StartTime ) )
        );
    dprintf(
        "%s  PromotionCheck:             %8lx   IdleTime.End:       %17s\n",
        Pad,
        (ULONG) ReadField(PromotionCheck ),
        DumpPerformanceCounterInStandardForm( ReadField( IdleTimes.EndTime ) )
        );
    dprintf(
        "%s  IdleTime1:                  %8lx   Idle0LastTime:      %17s\n",
        Pad,
        (ULONG) ReadField(IdleTime1),
        DumpTimeInStandardForm( ReadField( Idle0LastTime ) )
        );
    dprintf(
        "%s  IdleTime2:                  %8lx   LastSystTime:       %17s\n",
        Pad,
        (ULONG) ReadField(IdleTime2),
        DumpTimeInStandardForm( ReadField( LastSysTime ) )
        );
    dprintf(
        "%s  CurrentThrottle:                %4d%%  Idle0KernelTimeLimit: %15s\n",
        Pad,
        (ULONG) ReadField(CurrentThrottle),
        DumpTimeInStandardForm( ReadField( Idle0KernelTimeLimit ) )
        );
    dprintf(
        "%s  CurrentThrottleIndex:           %4d   ThermalThrottleLimit:           %4d%%\n",
        Pad,
        (ULONG) ReadField(CurrentThrottleIndex),
        (ULONG) ReadField(ThermalThrottleLimit)
        );
    dprintf(
        "%s  KneeThrottleIndex:              %4d   ThermalThrottleIndex:           %4d\n",
        Pad,
        (ULONG) ReadField(KneeThrottleIndex),
        (ULONG) ReadField(ThermalThrottleIndex)
        );
    dprintf(
        "%s  ThrottleLimitIndex:             %4d   Flags:                      %8x\n",
        Pad,
        (ULONG) ReadField(ThrottleLimitIndex),
        (ULONG) ReadField(Flags)
        );
    dprintf(
        "%s  PerfStates:                 %8p   PerfStatesCount:                %4d\n",
        Pad,
        ReadField(PerfStates),
        (ULONG) ReadField(PerfStatesCount)
        );
    dprintf(
        "%s  ProcessorMinThrottle:           %4d%%  ProcessorMaxThrottle:           %4d%%\n",
        Pad,
        (ULONG) ReadField(ProcessorMinThrottle),
        (ULONG) ReadField(ProcessorMaxThrottle)
        );
    dprintf(
        "%s  PromotionCount:             %8d   DemotionCount:              %8d\n",
        Pad,
        (ULONG) ReadField( PromotionCount ),
        (ULONG) ReadField( DemotionCount )
        );
    dprintf(
        "%s  ErrorCount:                 %8d   RetryCount:                 %8d\n",
        Pad,
        (ULONG) ReadField(ErrorCount),
        (ULONG) ReadField(RetryCount)
        );
    dprintf(
        "%s  LastBusyPercentage:             %4d%%  LastC3Percentage:               %4d%%\n",
        Pad,
        (ULONG) ReadField( LastBusyPercentage ),
        (ULONG) ReadField( LastC3Percentage )
        );
    dprintf(
        "%s  LastAdjustedBusyPercent:        %4d%%\n",
        Pad,
        (ULONG) ReadField(LastAdjustedBusyPercentage)
        );
    dprintf("\n");
    GetSymbol(ReadField(IdleFunction), FunctionName, &Offset);
    dprintf(
        "%s  IdleFunction:            %50s\n",
        Pad,
        FunctionName
        );
    GetSymbol(ReadField(PerfSetThrottle), FunctionName, &Offset);
    dprintf(
        "%s  PerfSetThrottle:         %50s\n",
        Pad,
        FunctionName
        );
    dprintf(
        "%s  PreviousC3StateTime:      %21s (%16p)\n",
        Pad,
        DumpPerformanceCounterInStandardForm( ReadField( PreviousC3StateTime ) ),
        ReadField( PreviousC3StateTime )
        );
    dprintf(
        "%s  PerfSystemTime:           %21s (%8x)\n",
        Pad,
        DumpTimeInStandardForm( ReadField(PerfSystemTime) ),
        ReadField( PerfSystemTime )
        );
    dprintf(
        "%s  PerfIdleTime:             %21s (%8x)\n",
        Pad,
        DumpTimeInStandardForm( ReadField(PerfIdleTime) ),
        ReadField( PerfIdleTime )
        );
    dprintf(
        "%s  PerfTickCount:            %21s (%8x)\n",
        Pad,
        DumpTimeInStandardForm( ReadField(PerfTickCount) ),
        ReadField( PerfTickCount )
        );

    //
    // At this point, go look at the corresponding PRCB to see what the
    // kernel and user times are
    //
    GetFieldOffset("nt!_KPRCB", "PowerState", &temp);
    Address -= temp;
    InitTypeRead( Address, _KPRCB );
    time = (ULONG) ReadField(UserTime) + (ULONG) ReadField(KernelTime);
    dprintf(
        "%s  CurrentSystemTime:        %21s (%8x)\n",
        Pad,
        DumpTimeInStandardForm( time ),
        time
        );

    //
    // Read the Idle Thread to see what the current idle thread time is
    //
    Address = ReadField( IdleThread );
    InitTypeRead( Address, _KTHREAD );
    time = (ULONG) ReadField(KernelTime);
    dprintf(
        "%s  CurrentIdleTime:          %21s (%8x)\n",
        Pad,
        DumpTimeInStandardForm( time ),
        time
        );

}

DECLARE_API( poproc )
/*++

Routine Description:

    Dumps the Processor Power State

Arguments:

Return Value:

--*/
{
    ULONG64  Address = 0;
    ULONG64  Pkprcb;
    ULONG    Flags = 0;
    ULONG    processor;
    ULONG64  Result;

    //
    // Get address and flags
    //
    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }

    if (Address == 0) {

        HRESULT Hr;

        INIT_API();

        GetCurrentProcessor(Client, &processor, NULL);

        Hr = g_ExtData->ReadProcessorSystemData(processor,
                                                DEBUG_DATA_KPRCB_OFFSET,
                                                &Pkprcb,
                                                sizeof(Pkprcb),
                                                NULL);


        if (Hr != S_OK)
        {
            dprintf("Cannot get PRCB address\n");
        }
        else
        {
            InitTypeRead(Pkprcb,nt!_KPRCB);
            Address = ReadField(PowerState);
            if (!Address)
            {
                dprintf("Unable to get PowerState from the PRCB at %p",Pkprcb);
                dprintf("poproc <address>\n");
                Hr = E_INVALIDARG;

            }
        }

        if (Hr != S_OK)
        {
            return Hr;
        }
    }

    if (GetFieldValue( Address,
                       "PROCESSOR_POWER_STATE",
                       "IdleTime1",
                       Result) ) {

        dprintf("Could not read PROCESSOR_POWER_STATE at %08p\n", Address );
        return E_INVALIDARG;

    }

    //
    // Dump the Trigger Information
    //
    DumpProcessorPowerState("", Address, Flags );

    return S_OK;
}

VOID
DumpPowerCapabilities(
    IN  PCHAR                      Pad,
    IN  ULONG64                    Address,
    IN  ULONG                      Flags
    )
/*++

Routine Description:

    Dumps the power capabilities

Arguments:

Return Value:

--*/
{
    InitTypeRead(Address, nt!SYSTEM_POWER_CAPABILITIES);
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%sPopCapabilities @ 0x%08p\n", Pad, Address );

    }

    dprintf("%s  Misc Supported Features: ", Pad);
    if ((ULONG) ReadField(PowerButtonPresent)) {

        dprintf(" PwrButton");
    }
    if ((ULONG) ReadField(SleepButtonPresent)) {

        dprintf(" SlpButton");
    }
    if ((ULONG) ReadField(LidPresent)) {

        dprintf(" Lid");
    }
    if ((ULONG) ReadField(SystemS1)) {

        dprintf(" S1");
    }
    if ((ULONG) ReadField(SystemS2)) {

        dprintf(" S2");
    }
    if ((ULONG) ReadField(SystemS3)) {

        dprintf(" S3");
    }
    if ((ULONG) ReadField(SystemS4)) {

        dprintf(" S4");
    }
    if ((ULONG) ReadField(SystemS5)) {

        dprintf(" S5");
    }
    if ((ULONG) ReadField(HiberFilePresent)) {

        dprintf(" HiberFile");
    }
    if ((ULONG) ReadField(FullWake)) {

        dprintf(" FullWake");
    }
    if ((ULONG) ReadField(VideoDimPresent)) {

        dprintf(" VideoDim");
    }
    dprintf("\n");

    dprintf("%s  Processor Features:      ", Pad);
    if ((ULONG) ReadField(ThermalControl)) {

        dprintf(" Thermal");
    }
    if ((ULONG) ReadField(ProcessorThrottle)) {

        dprintf(" Throttle (MinThrottle = %d%%, Scale = %d%%)",
                (ULONG) ReadField(ProcessorMinThrottle),
                (ULONG) ReadField(ProcessorThrottleScale));

    }
    dprintf("\n");

    dprintf("%s  Disk Features:           ", Pad );
    if ((ULONG) ReadField(DiskSpinDown)) {

        dprintf(" SpinDown");
    }
    dprintf("\n");

    dprintf("%s  Battery Features:        ", Pad);
    if ((ULONG) ReadField(SystemBatteriesPresent)) {

        dprintf(" BatteriesPresent");

    }
    if ((ULONG) ReadField(BatteriesAreShortTerm)) {

        dprintf(" ShortTerm");
    }
    dprintf("\n");
    if ((ULONG) ReadField(SystemBatteriesPresent)) {

        dprintf("%s    Battery 0 - Capacity: %8lx  Granularity: %8lx\n",
                Pad,
                (ULONG) ReadField(BatteryScale[0].Capacity),
                (ULONG) ReadField(BatteryScale[0].Granularity)
                );
        dprintf("%s    Battery 1 - Capacity: %8lx  Granularity: %8lx\n",
                Pad,
                (ULONG) ReadField(BatteryScale[1].Capacity),
                (ULONG) ReadField(BatteryScale[1].Granularity)
                );
        dprintf("%s    Battery 2 - Capacity: %8lx  Granularity: %8lx\n",
                Pad,
                (ULONG) ReadField(BatteryScale[2].Capacity),
                (ULONG) ReadField(BatteryScale[2].Granularity)
                );

    }
    dprintf("%s  Wake Caps\n", Pad);
    dprintf("%s    Ac OnLine Wake:         S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(AcOnLineWake)]);
    dprintf("%s    Soft Lid Wake:          S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(SoftLidWake)]);
    dprintf("%s    RTC Wake:               S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(RtcWake)]);
    dprintf("%s    Min Device Wake:        S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(MinDeviceWakeState)]);
    dprintf("%s    Default Wake:           S%s\n",
            Pad,
            DumpPowerStateMappings[(ULONG) ReadField(DefaultLowLatencyWake)]);

}

DECLARE_API( pocaps )
/*++

Routine Description:

    Dumps the power capabilities

Arguments:

Return Value:

--*/
{
    ULONG64                     Address = 0;
    ULONG                       Flags = 0;
    ULONG                       Result;

    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (!Address) {

        Address = GetExpression("nt!PopCapabilities");
        if (!Address) {

            dprintf("Could not read PopCapabilities\n");
            return E_INVALIDARG;

        }

    }
    if (!Address) {

        dprintf("!pocaps [addr [flags]]\n");
        return E_INVALIDARG;

    }
    if (GetFieldValue(Address,
                      "nt!SYSTEM_POWER_CAPABILITIES",
                      "PowerButtonPresent",
                      Result) ) {

        dprintf("Could not read PopCapabilities at %08p\n", Address );
        return E_INVALIDARG;

    }
    DumpPowerCapabilities( "", Address, Flags );
    return S_OK;
}

VOID
DumpPopActionTrigger(
    IN  PCHAR              Pad,
    IN  ULONG64            Address,
    IN  ULONG              Flags
    )
/*++

--*/
{
    ULONG Type, PopFlags;

    InitTypeRead(Address, nt!_POP_ACTION_TRIGGER);

    //
    // Header line
    //
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%sPOP_ACTION_TRIGGER @ 0x%08p\n", Pad, Address );

    }

    dprintf("%s  Type:  ", Pad);
    switch(Type = (ULONG) ReadField(Type)) {
    case PolicyDeviceSystemButton:
        dprintf("    SystemButton"); break;
    case PolicyDeviceThermalZone:
        dprintf("     ThermalZone"); break;
    case PolicyDeviceBattery:
        dprintf("         Battery"); break;
    case PolicyInitiatePowerActionAPI:
        dprintf("   InitActionAPI"); break;
    case PolicySetPowerStateAPI:
        dprintf("     SetStateAPI"); break;
    case PolicyImmediateDozeS4:
        dprintf("          DozeS4"); break;
    case PolicySystemIdle:
        dprintf("      SystemIdle"); break;
    default:
        dprintf("         Unknown"); break;
    }

    dprintf("  Flags:   %02x%02x%02x%02x",
            (ULONG) ReadField(Spare[2]),
            (ULONG) ReadField(Spare[1]),
            (ULONG) ReadField(Spare[0]),
            (PopFlags = (ULONG) ReadField(Flags)));
    if (PopFlags & PO_TRG_USER) {

        dprintf(" UserAction");

    }
    if (PopFlags & PO_TRG_SYSTEM) {

        dprintf(" SystemAction");

    }
    if (PopFlags & PO_TRG_SYNC) {

        dprintf(" Sync");

    }
    if (PopFlags & PO_TRG_SET) {

        dprintf(" Set");

    }
    dprintf("\n");

    if (Type != PolicyDeviceBattery) {

        dprintf("%s  Wait Trigger:  %08p\n", Pad, ReadField(Wait ));

    } else {

        dprintf("%s  BatteryLevel:  %08lx\n", Pad, (ULONG) ReadField(Battery.Level ));

    }

}

DECLARE_API( potrigger )
/*++

Routine Description:

    Dumps a Pop Action Trigger

Arguments:

Return Value:

--*/
{
    ULONG64             Address = 0;
    ULONG               Flags = 0;
    ULONG               Result;

    //
    // Get address and flags
    //
    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (Address == 0) {

        dprintf("potrigger <address>\n");
        return E_INVALIDARG;

    }
    if (GetFieldValue(Address,
                      "nt!_POP_ACTION_TRIGGER",
                      "Type",
                      Result) ) {

        dprintf("Could not read POP_ACTION_TRIGGER at %08p\n", Address );
        return E_INVALIDARG;

    }

    //
    // Dump the Trigger Information
    //
    DumpPopActionTrigger("", Address, Flags );

    return S_OK;
}

VOID
DumpThermalZoneInformation(
    IN  PCHAR                  Pad,
    IN  ULONG64                Address,
    IN  ULONG                  Flags
    )
/*++

Routine Description:

    Displays the thermal zone information structure

Arguments:

Return Value:

--*/
{
    ULONG   i, Count;

    InitTypeRead(Address, nt!_THERMAL_INFORMATION);
    //
    // Header line
    //
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%sThermalInfo @ 0x%08p\n", Pad, Address );

    }

    //
    // First line
    //
    dprintf("%s  Stamp:         %08lx  Constant1:  %08lx  Constant2:  %08lx\n",
            Pad,
            (ULONG) ReadField(ThermalStamp),
            (ULONG) ReadField(ThermalConstant1),
            (ULONG) ReadField(ThermalConstant2));

    //
    // Second Line
    //
    dprintf("%s  Affinity:      %08lx  Period:     %08lx  ActiveCnt:  %08lx\n",
            Pad,
            (ULONG) ReadField(Processors),
            (ULONG) ReadField(SamplingPeriod),
            (ULONG) ReadField(ActiveTripPointCount ));

    //
    // Temperatures
    //
    dprintf("%s  Current Temperature:                 %08lx",
            Pad,
            (ULONG) ReadField(CurrentTemperature ));
    DumpTemperatureInKelvins((ULONG) ReadField(CurrentTemperature));
    dprintf("\n");
    dprintf("%s  Passive TripPoint Temperature:       %08lx",
            Pad,
            (ULONG) ReadField(PassiveTripPoint ));
    DumpTemperatureInKelvins((ULONG) ReadField(PassiveTripPoint));
    dprintf("\n");

    //
    // Active trip points
    //
    Count = (ULONG) ReadField(ActiveTripPointCount);
    for (i = 0; i < Count; i++) {
        CHAR Buff[40];
        ULONG Act;

        sprintf(Buff, "ActiveTripPoint[%d]", i);
        dprintf("%s  Active TripPoint Temperature %d:      %08lx",
                Pad,
                i,
                (Act = (ULONG) GetShortField(0, Buff, 0)));
        DumpTemperatureInKelvins(Act);
        dprintf("\n");

    }

    //
    // Dump critical temperatures
    //
    dprintf("%s  Critical TripPoint Temperature:      %08lx",
            Pad,
            (ULONG) ReadField(CriticalTripPoint ));
    DumpTemperatureInKelvins((ULONG) ReadField(CriticalTripPoint));
    dprintf("\n");

}

DECLARE_API( tzinfo )
/*++

Routine Description:

    Dumps the thermal zone information structure

Arguments:

Return Value:

--*/
{
//    THERMAL_INFORMATION ThermalInfo;
    ULONG64             Address = 0;
    ULONG               Flags = 0;
    ULONG               Result;

    //
    // Get address and flags
    //
    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (Address == 0) {

        dprintf("tzinfo <address>\n");
        return E_INVALIDARG;

    }
    if (GetFieldValue(Address,
                      "nt!_THERMAL_INFORMATION",
                      "ThermalStamp",
                      Result) ) {

        dprintf("Could not read THERMAL_INFO at %08p\n", Address );
        return E_INVALIDARG;

    }

    //
    // Dump the thermal zone information
    //
    DumpThermalZoneInformation("", Address, Flags );

    return S_OK;
}

VOID
DumpThermalZone(
    IN  ULONG              Count,
    IN  PCHAR              Pad,
    IN  ULONG64            Address,
    IN  ULONG              Flags
    )
/*++

Routine Description:

    Dumps a thermal zone

--*/
{
    ULONG ThFlags, Off1, Off2, LastTemp;

    InitTypeRead(Address, NT!_POP_THERMAL_ZONE);
    //
    // Header line
    //
    if (!(Flags & TZ_NO_HEADER)) {

        dprintf("%s%d - ThermalZone @ 0x%08p\n", Pad, Count, Address );

    }

    //
    // First line
    //
    dprintf("%s  State:         ",Pad);
    switch ((ULONG) ReadField(State)) {
    case 1: dprintf("    Read"); break;
    case 2: dprintf("Set Mode"); break;
    case 3: dprintf("  Active"); break;
    default:dprintf("No State"); break;
    }
    dprintf("  Flags:               %08lx", (ThFlags = (ULONG) ReadField(Flags)));
    if (ThFlags & PO_TZ_THROTTLING) {
        dprintf(" Throttling");
    }
    if (ThFlags & PO_TZ_CLEANUP) {
        dprintf(" CleanUp");
    }
    dprintf("\n");

    //
    // Second Line
    //
    dprintf("%s  Mode:          ", Pad );
    switch((ULONG) ReadField(Mode)) {
    case 0: dprintf("  Active"); break;
    case 1: dprintf(" Passive"); break;
    default: dprintf(" Invalid"); break;
    }
    dprintf("  PendingMode:         ");
    switch((ULONG) ReadField(PendingMode)) {
    case 0: dprintf("  Active"); break;
    case 1: dprintf(" Passive"); break;
    default: dprintf(" Invalid"); break;
    }
    dprintf("\n");


    dprintf("%s  ActivePoint:   %08lx  PendingTrp:          %08lx\n",
            Pad, (ULONG) ReadField(ActivePoint), (ULONG) ReadField(PendingActivePoint ));
    dprintf("%s  SampleRate:    %08lx  LastTime:    %016I64x\n",
            Pad, (ULONG) ReadField(SampleRate), ReadField(LastTime ));
    GetFieldOffset("NT!_POP_THERMAL_ZONE", "PassiveTimer", &Off1);
    GetFieldOffset("NT!_POP_THERMAL_ZONE", "PassiveDpc", &Off2);
    dprintf("%s  Timer:         %08lx  Dpc:                 %08lx\n",
            Pad,
            Address + Off1,
            Address + Off2);
    GetFieldOffset("NT!_POP_THERMAL_ZONE", "OverThrottled", &Off1);
    dprintf("%s  OverThrottled: %08lx  Irp:                 %08p\n",
            Pad,
            Address + Off1,
            ReadField(Irp ));
    dprintf("%s  Throttle:      %08lx  LastTemp:            %08lx",
            Pad,
            (ULONG) ReadField(Throttle),
            (LastTemp = (ULONG) ReadField(LastTemp )));
    DumpTemperatureInKelvins( LastTemp );
    dprintf("\n");
    GetFieldOffset("NT!_POP_THERMAL_ZONE", "Info", &Off1);
    dprintf("%s  Thermal Info:  %08lx\n",
            Pad,
            Address + Off1);
    if (Flags & TZ_DUMP_INFO) {

        CHAR   buffer[80];

        //
        // Increase the buffer
        //
        sprintf(buffer,"  %s", Pad );

        //
        // Dump the thermal zone
        //
        DumpThermalZoneInformation(
            buffer,
            (Address + Off1),
            (Flags | TZ_NO_HEADER)
            );

    }
}


DECLARE_API( tz )
/*++

Routine Description:


Arguments:

    args -

Return Value:

    None

--*/

{
    ULONG64             Address = 0;
    ULONG               Count = 0;
    ULONG64             EndAddress = 0, Flink;
    ULONG               Flags = 0;
    ULONG               Result;

    //
    // Get address and flags
    //
    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (Address == 0) {

        Address = GetExpression("nt!PopThermal");
        if (!Address) {

            dprintf("Could not read PopThermal\n");
            return E_INVALIDARG;

        }
        if (GetFieldValue(Address,
                          "nt!_LIST_ENTRY",
                          "Flink",
                          Flink) ) {

            dprintf("Could not read PopThermal at %08p\n", Address );
            return E_INVALIDARG;

        }
        if (Flink == Address) {

            dprintf("No Thermal Zones\n");
            return E_INVALIDARG;

        }

        Flags |= TZ_LOOP;
        EndAddress = Address;
        Address = Flink;

    } else {

        EndAddress = Address;

    }

    //
    // Now read the proper thermal zone
    //
    if (GetFieldValue(Address,
                      "nt!_LIST_ENTRY",
                      "Flink",
                      Flink) ) {

        dprintf("Could not read LIST_ENTRY at %08p\n", Address );
        return E_INVALIDARG;

    }

    //
    // Do we stop looping?
    //
    if (!(Flags & TZ_LOOP)) {

        EndAddress = Flink;

    }

    do {

        //
        // Read the thermal zone
        // Try both names for backward compatibility
        //
        if (GetFieldValue(Address, "NT!_POP_THERMAL_ZONE", "Link.Flink", Flink) &&
            GetFieldValue(Address, "NT!POP_THERMAL_ZONE", "Link.Flink", Flink)) {
            dprintf("Could not read THERMAL_ZONE at %08p\n", Address );
            return E_INVALIDARG;
        }

        //
        // Dump the zone
        //
        DumpThermalZone( Count, "", Address, Flags );

        //
        // Check for Control C
        //
        if (CheckControlC()) {
            return E_INVALIDARG;
        }

        //
        // Next
        //
        Address = Flink;
        Count++;

    } while (Address != EndAddress  );
    return S_OK;
}

VOID
DumpPopIdleHandler(
    IN  ULONG64                     Address,
    IN  ULONG                       Flags
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    CHAR    FunctionName[256];
    ULONG64 Offset;

    if (InitTypeRead(Address,nt!_POP_IDLE_HANDLER)) {
        // If the new type name fails, use the old one
        InitTypeRead(Address,nt!POP_IDLE_HANDLER);
    }

    dprintf("PopIdleHandle[%d] - POP_IDLE_HANDLER %p\n",(ULONG)ReadField(State),Address);
    dprintf("  State:                      %8d   PromoteCount:               %8d\n",
            (ULONG)ReadField(State),
            (ULONG)ReadField(PromoteCount)
            );
    dprintf("  DemotePercent:              %8d%%  PromotePercent:            %8d%%\n",
            (ULONG)ReadField(DemotePercent),
            (ULONG)ReadField(PromotePercent)
            );
    dprintf("  Demote:                     %8d   Promote:                    %8d\n",
            (ULONG)ReadField(Demote),
            (ULONG)ReadField(Promote)
            );
    dprintf("\n");
    GetSymbol(ReadField(IdleFunction), FunctionName, &Offset);
    dprintf("  Function:           %27s  (%p)\n",
            FunctionName,
            ReadField(IdleFunction)
            );
    dprintf("  Latency:            %27s  (%8x)\n",
            DumpPerformanceCounterInStandardForm( (ULONG)ReadField(Latency) ),
            (ULONG)ReadField(Latency)
            );
    dprintf("  TimeCheck:          %27s  (%8x)\n",
            DumpPerformanceCounterInStandardForm( (ULONG)ReadField(TimeCheck) ),
            (ULONG)ReadField(TimeCheck)
            );
    dprintf("  PromoteLimit:       %27s  (%8x)\n",
            DumpPerformanceCounterInStandardForm( (ULONG)ReadField(PromoteLimit) ),
            (ULONG)ReadField(PromoteLimit)
            );
    dprintf("  DemoteLimit:        %27s  (%8x)\n",
            DumpPerformanceCounterInStandardForm( (ULONG)ReadField(DemoteLimit) ),
            (ULONG) ReadField(DemoteLimit)
            );
    dprintf("\n");

}

DECLARE_API( poidle )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    ULONG64             Address = 0;
    ULONG64             Pkprcb;
    ULONG64             PowerState;
    ULONG64             Size;
    ULONG               Loop = 3;
    ULONG               Flags = 0;
    ULONG               processor = 0;

    //
    // Get address and flags
    //
    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }

    if (Address == 0) {

        HRESULT Hr;

        INIT_API();

        GetCurrentProcessor(Client, &processor, NULL);

        Hr = g_ExtData->ReadProcessorSystemData(processor,
                                                DEBUG_DATA_KPRCB_OFFSET,
                                                &Pkprcb,
                                                sizeof(Pkprcb),
                                                NULL);


        if (Hr != S_OK) {

            dprintf("Cannot get PRCB address\n");

        } else {

            InitTypeRead(Pkprcb,nt!_KPRCB);
            PowerState = ReadField(PowerState);
            if (!PowerState) {

                dprintf("Unable to get PowerState from the PRCB at %p",Pkprcb);
                dprintf("poproc <address>\n");
                Hr = E_INVALIDARG;

            }

        }
        if (Hr != S_OK){

            return Hr;

        }

        if (GetFieldValue( PowerState,
                           "PROCESSOR_POWER_STATE",
                           "IdleHandlers",
                           Address) ) {

            dprintf("Could not read PROCESSOR_POWER_STATE at %p\n", PowerState );
            return E_INVALIDARG;

        }

        Loop = 3;

    }

    //
    // We will need to know how large the structure is..
    //
    Size = GetTypeSize("nt!_POP_IDLE_HANDLER");
    if (!Size) {
        Size = GetTypeSize("nt!POP_IDLE_HANDLER");
    }

    do {

        DumpPopIdleHandler( Address, Flags );
        Address += Size;
        if (CheckControlC() || !Loop) {
            break;
        }
        Loop--;

    } while ( Loop );

    return S_OK;
}

VOID
DumpProcessorPerfState(
    IN  ULONG64                     Address,
    IN  ULONG                       Flags
    )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    ULONG64 Value = 0;

    InitTypeRead(Address,nt!PROCESSOR_PERF_STATE);
    dprintf(
        "  Power:  %4dmW",
        (ULONG)ReadField(Power)
        );
    Value = ReadField(Flags);
    if (Value) {
        dprintf("  NonLinear\n");
    } else {
        dprintf("  Linear\n");
    }
    dprintf(
        "    Frequency:     %8d%% MinCapacity:   %8d%%\n",
        (ULONG)ReadField(PercentFrequency),
        (ULONG)ReadField(MinCapacity)
        );
    dprintf(
        "    IncreaseLevel: %8d%% DecreaseLevel: %8d%%\n",
        (ULONG)ReadField(IncreaseLevel),
        (ULONG)ReadField(DecreaseLevel)
        );
    dprintf(
        "    IncreaseCount: %8x  DecreaseCount: %8x\n",
        (ULONG)ReadField(IncreaseCount),
        (ULONG)ReadField(DecreaseCount)
        );
    dprintf(
        "    PerformanceTime: %21s (%8x)\n",
        DumpPerformanceCounterInStandardForm( ReadField(PerformanceTime) ),
        ReadField(PerformanceTime)
        );
    dprintf(
        "    IncreaseTime:    %21s (%8x)\n",
        DumpTimeInStandardForm( (ULONG) ReadField(IncreaseTime) ),
        ReadField(IncreaseTime)
        );
    dprintf(
        "    DecreaseTime:    %21s (%8x)\n",
        DumpTimeInStandardForm( (ULONG) ReadField(DecreaseTime) ),
        ReadField(DecreaseTime)
        );

}

DECLARE_API( poperf )
/*++

Routine Description:

Arguments:

Return Value:

--*/
{
    ULONG64             Address = 0;
    ULONG64             Count = 1;
    ULONG64             Index;
    ULONG64             PolicyAddress;
    ULONG64             Size = 0;
    ULONG               Flags = 0;
    ULONG               Processor;
    ULONG               Prcb;

    //
    // Get address and flags
    //
    if (GetExpressionEx(args, &Address, &args)) {
        Flags = (ULONG) GetExpression(args);
    }
    if (Address == 0) {

        HRESULT Hr;

        INIT_API();

        //
        // Fetch them from the current processor's prcb
        //
        GetCurrentProcessor(Client, &Processor, NULL);

        Hr = g_ExtData->ReadProcessorSystemData(
            Processor,
            DEBUG_DATA_KPRCB_OFFSET,
            &Address,
            sizeof(Address),
            NULL
            );
        if (Hr != S_OK) {

            dprintf("Unable to get PRCB address\n");
            return Hr;

        }

        InitTypeRead(Address,nt!_KPRCB);
        PolicyAddress = ReadField(PowerState.PerfStates);
        Count         = ReadField(PowerState.PerfStatesCount);

        //
        // Remember what's the address we will use
        //
        Address = PolicyAddress;
        dprintf("Prcb.PowerState.PerfStates - %p (%d Levels)\n", Address, (ULONG) Count );

    } else {

        dprintf("PROCESSOR_PERF_STATE - %p\n",Address);

    }

    //
    // We will need to know how large the structure is..
    //
    Size = GetTypeSize("nt!PROCESSOR_PERF_STATE");

    //
    // Dump all the states
    //
    for (Index = 0; Index < Count; Index++, Address += Size) {

        DumpProcessorPerfState( Address, Flags );
        if (CheckControlC()) {
            break;
        }

    }

    //
    // Done
    //
    return S_OK;
}

DECLARE_API( whattime )
{
    ULONG64 Address = 0;

    //
    // Get address and flags
    //
    GetExpressionEx(args, &Address, &args);

    dprintf(
        "%d Ticks in Standard Time: %s\n",
        (ULONG) Address,
        DumpTimeInStandardForm( (ULONG) Address )
        );
    return S_OK;
}

DECLARE_API( whatperftime )
{
    ULONG64 Address = 0;

    //
    // Get address and flags
    //
    GetExpressionEx(args, &Address, &args);

    dprintf(
        "%ld Performance Counter in Standard Time: %s\n",
        (ULONG) Address,
        DumpPerformanceCounterInStandardForm( Address )
        );
    return S_OK;
}