/*++

Copyright (c) 1999  Microsoft Corporation

Module Name:

    ext.c

Abstract:

    WinDbg Extension Api
    implements !_ext
               !_help
               !_pow

Author:

    jdunn

Environment:

    User Mode.

Revision History:

--*/

#include "precomp.h"
#include "usbhcdkd.h"


PUCHAR
S_State(
    SYSTEM_POWER_STATE S
    )
{
    switch (S) {
    case PowerSystemUnspecified:
        return "SystemUnspecified(S?)";
    case PowerSystemWorking:
        return "SystemWorking    (S0)";
    case PowerSystemSleeping1:
        return "SystemSleeping1  (S1)";
    case PowerSystemSleeping2:
        return "SystemSleeping2  (S2)";
    case PowerSystemSleeping3:
        return "SystemSleeping3  (S3)";
    case PowerSystemHibernate:
        return "SystemHibernate      ";
    case PowerSystemShutdown:
        return "SystemShutdown       ";
    case PowerSystemMaximum:
        return "SystemMaximum        ";
    }

    return "???";
}


PUCHAR
PwrAttributes(
    HC_POWER_ATTRIBUTES A
    )
{
    switch (A) {
    case HcPower_N_Wakeup_N:
        return "HcPower_N_Wakeup_N";
    case HcPower_Y_Wakeup_Y:
        return "HcPower_Y_Wakeup_Y";
    case HcPower_Y_Wakeup_N:
        return "HcPower_Y_Wakeup_N";
    case HcPower_N_Wakeup_Y:
        return "HcPower_N_Wakeup_Y";
    }
    return "???";
}


PUCHAR
D_State(
    DEVICE_POWER_STATE D
    )
{
    switch (D) {
    case PowerDeviceUnspecified:
        return "D?";
    case PowerDeviceD0:
        return "D0";
    case PowerDeviceD1:
        return "D1";
    case PowerDeviceD2:
        return "D2";
    case PowerDeviceD3:
        return "D3";
    case PowerDeviceMaximum:
        return "DX";
    }

    return "??";
}


VOID
DumpPortFdoDevExt(
    MEMLOC ExtMemLoc
    )
{
    ULONG i, f;
    UCHAR cs[] = "usbport!_FDO_EXTENSION";
    ULONG bandwidthTable[USBPORT_MAX_INTEP_POLLING_INTERVAL];
    MEMLOC l;

    FLAG_TABLE fdoFlags[] = {
    "USBPORT_FDOFLAG_IRQ_CONNECTED", USBPORT_FDOFLAG_IRQ_CONNECTED,
    "USBPORT_FDOFLAG_ENABLE_SYSTEM_WAKE", USBPORT_FDOFLAG_ENABLE_SYSTEM_WAKE,
    "USBPORT_FDOFLAG_POLL_CONTROLLER", USBPORT_FDOFLAG_POLL_CONTROLLER,
    "USBPORT_FDOFLAG_KILL_THREAD", USBPORT_FDOFLAG_KILL_THREAD,

    "USBPORT_FDOFLAG_NEED_SET_POWER_D0", USBPORT_FDOFLAG_NEED_SET_POWER_D0,
    "USBPORT_FDOFLAG_DM_TIMER_ENABLED", USBPORT_FDOFLAG_DM_TIMER_ENABLED,
    "USBPORT_FDOFLAG_SKIP_TIMER_WORK", USBPORT_FDOFLAG_SKIP_TIMER_WORK,
    "USBPORT_FDOFLAG_OFF", USBPORT_FDOFLAG_OFF,

    "USBPORT_FDOFLAG_SUSPENDED", USBPORT_FDOFLAG_SUSPENDED,
    "USBPORT_FDOFLAG_IRQ_EN", USBPORT_FDOFLAG_IRQ_EN,
    "USBPORT_FDOFLAG_RH_CAN_SUSPEND", USBPORT_FDOFLAG_RH_CAN_SUSPEND,
    "USBPORT_FDOFLAG_RESUME_SIGNALLING", USBPORT_FDOFLAG_RESUME_SIGNALLING,

    "USBPORT_FDOFLAG_HCPENDING_WAKE_IRP", USBPORT_FDOFLAG_HCPENDING_WAKE_IRP,
    "USBPORT_FDOFLAG_DM_TIMER_INIT",  USBPORT_FDOFLAG_DM_TIMER_INIT,
    "USBPORT_FDOFLAG_THREAD_INIT", USBPORT_FDOFLAG_THREAD_INIT

    };

    FLAG_TABLE mpStateFlags[] = {
        "MP_STATE_STARTED", MP_STATE_STARTED,
        "MP_STATE_SUSPENDED", MP_STATE_SUSPENDED
         };


    dprintf ("\n");
    PrintfMemLoc("**USBPORT FDO_EXTENSION ", ExtMemLoc, "\n");

    PrintfMemLoc("WorkerThreadHandle: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "WorkerThreadHandle"),
            "\n");

    PrintfMemLoc("WorkerPkThread: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "WorkerPkThread"),
            "\n");

    PrintfMemLoc("HcPendingWakeIrp: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "HcPendingWakeIrp"),
            "\n");

    PrintfMemLoc("PhysicalDeviceObject: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "PhysicalDeviceObject"),
            "\n");

    PrintfMemLoc("TopOfStackDeviceObject: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "TopOfStackDeviceObject"),
            "\n");

    PrintfMemLoc("RootHubPdo: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "RootHubPdo"),
            "\n");

    dprintf ("DM_TimerInterval: %d\n",
                UsbReadFieldUlong(ExtMemLoc, cs, "DM_TimerInterval")
            );
    dprintf ("DeviceNameIdx: %d\n",
                UsbReadFieldUlong(ExtMemLoc, cs, "DeviceNameIdx")
            );
    dprintf ("TotalBusBandwidth: %d\n",
                UsbReadFieldUlong(ExtMemLoc, cs, "TotalBusBandwidth")
            );

    dprintf ("Bandwidth Table[]\n");


    {
    ULONG64 addr;
    ULONG cb;

    addr = ExtMemLoc + UsbFieldOffset(cs,
            "BandwidthTable[0]");

    ReadMemory(addr,
               &bandwidthTable,
               (ULONG)sizeof(bandwidthTable),
               &cb);
    }

    for (i=0; i< USBPORT_MAX_INTEP_POLLING_INTERVAL/4; i++) {
        dprintf ("[%02.2d] - %8d [%02.2d] - %8d [%02.2d] - %8d [%02.2d] - %8d\n",
            i*4, bandwidthTable[i*4],
            i*4+1, bandwidthTable[i*4+1],
            i*4+2, bandwidthTable[i*4+2],
            i*4+3, bandwidthTable[i*4+3]);
    }

    dprintf ("AllocedInterruptBW 1,2,4,8,16,32 ms\n");
    for (i=0; i<6; i++) {
        UCHAR s[80];
        sprintf(s, "AllocedInterruptBW[%d]", i);
        dprintf ("bits/sec %d \n",
            UsbReadFieldUlong(ExtMemLoc, cs, s)
            );
    }

    dprintf ("AllocedIsoBW %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "AllocedIsoBW")
        );

    // pm stats
    //dprintf ("D0ResumeTimeStart %d \n",
    //    UsbReadFieldUlong(ExtMemLoc, cs, "D0ResumeTimeStart")
    //    );
    //dprintf ("S0ResumeTimeStart %d \n",
    //    UsbReadFieldUlong(ExtMemLoc, cs, "S0ResumeTimeStart")
    //    );
    //dprintf ("ThreadResumeTimeStart %d \n",
    //    UsbReadFieldUlong(ExtMemLoc, cs, "ThreadResumeTimeStart")
    //    );
    dprintf ("HC FDO Time -------------\n");
    dprintf ("ThreadResumeTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "ThreadResumeTime")
        );
    dprintf ("ControllerResumeTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "ControllerResumeTime")
        );
    dprintf ("D0ResumeTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "D0ResumeTime")
        );
    dprintf ("S0ResumeTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "S0ResumeTime")
        );
    dprintf ("CancelHcWakeIrp %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "CancelHcWakeIrp")
        );
    dprintf ("CcLockTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "CcLockTime")
        );

    //dprintf ("RootHubS0ResumeTime %d \n",
    //    UsbReadFieldUlong(ExtMemLoc, cs, "RootHubS0ResumeTime")
    //    );

    dprintf ("HUB PDO Time -------------\n");
    dprintf ("RootHubD0Time %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "RootHubD0Time")
        );
    dprintf ("MpResumeTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "MpResumeTime")
        );
    dprintf ("MpStartTime %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "MpStartTime")
        );
    dprintf ("CompletePdoWaitWake %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "CompletePdoWaitWake")
        );
    dprintf ("CompletePendingIdleIrp %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "CompletePendingIdleIrp")
        );
    dprintf ("ResumeController %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "ResumeController")
        );
    dprintf ("ControllerWait %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "ControllerWait")
        );
    dprintf ("-------------------------\n");
    // stats

    dprintf ("StatBulkBytes %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "StatBulkBytes")
        );

    dprintf ("StatIsoBytes %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "StatIsoBytes")
        );

    dprintf ("StatInterruptBytes %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "StatInterruptBytes")
        );

    dprintf ("StatControlDataBytes %d \n",
        UsbReadFieldUlong(ExtMemLoc, cs, "StatControlDataBytes")
        );

    PrintfMemLoc("***Miniport Extension: ",
            ExtMemLoc + UsbFieldOffset(cs, "MiniportExtension"),
            "\n");

    f = UsbReadFieldUlong(ExtMemLoc, cs, "FdoFlags"),
    dprintf ("FdoFlags %08.8x\n", f);
    UsbDumpFlags(f, fdoFlags,
        sizeof(fdoFlags)/sizeof(FLAG_TABLE));

    f = UsbReadFieldUlong(ExtMemLoc, cs, "MpStateFlags"),
    dprintf ("MpStateFlags %08.8x\n", f);
    UsbDumpFlags(f, mpStateFlags,
        sizeof(mpStateFlags)/sizeof(FLAG_TABLE));

    dprintf ("DmaBusy %d\n",
        UsbReadFieldUlong(ExtMemLoc, cs, "DmaBusy")
        );
    dprintf ("WorkerDpc %d\n",
        UsbReadFieldUlong(ExtMemLoc, cs, "WorkerDpc")
        );

    dprintf ("PciVendorId: %04.4x PciDeviceId: %04.4x Rev %02.2x\n",
        UsbReadFieldUshort(ExtMemLoc, cs, "PciVendorId"),
        UsbReadFieldUshort(ExtMemLoc, cs, "PciDeviceId"),
        UsbReadFieldUshort(ExtMemLoc, cs, "PciRevisionId")
        );

    f = UsbReadFieldUlong(ExtMemLoc, cs, "HcFlavor"),
    dprintf ("ControllerFlavor: %d ", f);

    switch(f) {
    case USB_HcGeneric:
        dprintf ("USB_HcGeneric\n");
        break;
    case OHCI_Generic:
        dprintf ("OHCI_Generic\n");
        break;
    case OHCI_Hydra:
        dprintf ("OHCI_Hydra\n");
        break;
    case OHCI_NEC:
        dprintf ("OHCI_NEC\n");
        break;
    case UHCI_Generic:
        dprintf ("UHCI_Generic\n");
        break;
    case UHCI_Piix4:
        dprintf ("UHCI_Piix4\n");
        break;
    case EHCI_Generic:
        dprintf ("EHCI_Generic\n");
        break;
//    case EHCI_960MUlator:
//        dprintf ("EHCI_960MUlator\n");
//        break;
    default:
        dprintf ("???\n");
    }

    dprintf ("-Driver Lists-\n");
    //GETMEMLOC(x, MemLoc, DEVICE_EXTENSION, Fdo.DeviceHandleList);

    l = ExtMemLoc + UsbFieldOffset(cs, "DeviceHandleList");
    PrintfMemLoc("(DH) DeviceHandleList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "MapTransferList");
    PrintfMemLoc("(MT) MapTransferList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "DoneTransferList");
    PrintfMemLoc("(DT) DoneTransferList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "EpStateChangeList");
    PrintfMemLoc("(SC) EpStateChangeList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "GlobalEndpointList");
    PrintfMemLoc("(GL) GlobalEndpointList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "AttendEndpointList");
    PrintfMemLoc("(AT) AttendEndpointList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "EpClosedList");
    PrintfMemLoc("(XL) EpClosedList: ",
            l,
            ListEmpty(l));

    l = ExtMemLoc + UsbFieldOffset(cs, "BadRequestList");
    PrintfMemLoc("(BA) BadRequestList: ",
            l,
            ListEmpty(l));
}


VOID
DumpPortPdoDevExt(
    MEMLOC ExtMemLoc
    )
{
    UCHAR cs[] = "usbport!_PDO_EXTENSION";

    dprintf ("\n");
    PrintfMemLoc("**USBPORT PDO_EXTENSION ", ExtMemLoc, "\n");


    PrintfMemLoc("RootHubInterruptEndpoint: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "RootHubInterruptEndpoint"),
            "\n");

    dprintf ("ConfigurationValue: %d\n",
                UsbReadFieldUchar(ExtMemLoc, cs, "Flags"));

    PrintfMemLoc("DeviceDescriptor: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "DeviceDescriptor"),
            "\n");

    PrintfMemLoc("ConfigurationDescriptor: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "ConfigurationDescriptor"),
            "\n");

    PrintfMemLoc("HubDescriptor: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "HubDescriptor"),
            "\n");

    PrintfMemLoc("PendingWaitWakeIrp: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "PendingWaitWakeIrp"),
            "\n");

    PrintfMemLoc("PendingIdleNotificationIrp: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "PendingIdleNotificationIrp"),
            "\n");

    PrintfMemLoc("Descriptors: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "Descriptors"),
            "\n");

}


VOID
DumpPowerCaps(
    MEMLOC MemLoc
    )
{
    SYSTEM_POWER_STATE s;
    DEVICE_CAPABILITIES devCaps;
    ULONG cb;

    PrintfMemLoc(">Power Capabilities @ ",
                  MemLoc,
                 "\n");

    ReadMemory(MemLoc,
               &devCaps,
               sizeof(devCaps),
               &cb);


    dprintf ("\tSystemWake = %s\n",
        S_State(devCaps.SystemWake));

    dprintf ("\tDeviceWake = %s\n",
        D_State(devCaps.DeviceWake));

    dprintf ("\t<System Power State Map>\n");
    for (s=PowerSystemUnspecified; s< PowerSystemMaximum; s++) {
        dprintf ("\t%s =  %s\n",
            S_State(s), D_State(devCaps.DeviceState[s]));
    }
}


VOID
DumpFdoPower(
    MEMLOC MemLoc
    )
{
    MEMLOC ExtMemLoc;
    UCHAR cs[] = "usbport!_DEVICE_EXTENSION";
    ULONG pa, st, d, i;
    UCHAR s[64];
    UCHAR csFdo[] = "usbport!_FDO_EXTENSION";

    PrintfMemLoc("*POWER SUMMARY fdo (ext) ",
                  MemLoc,
                 "\n");

    // dump the hc power caps
    dprintf ("HC Power Capabilities\n");
    DumpPowerCaps(MemLoc + UsbFieldOffset(cs, "DeviceCapabilities"));

    ExtMemLoc = MemLoc + UsbFieldOffset(cs, "Fdo");
    // dump power attributes
    dprintf ("HC Power Attributes\n");
    for (i=0; i< USBPORT_MAPPED_SLEEP_STATES; i++) {

        sprintf(s, "HcPowerStateTbl.PowerState[0].SystemState", i);
        st = UsbReadFieldUlong(ExtMemLoc, csFdo, s);
        sprintf(s, "HcPowerStateTbl.PowerState[0].DeviceState", i);
        d = UsbReadFieldUlong(ExtMemLoc, csFdo, s);
        sprintf(s, "HcPowerStateTbl.PowerState[0].Attributes", i);
        pa = UsbReadFieldUlong(ExtMemLoc, csFdo, s);

        dprintf("[%d] %s - %s  %s\n",
            i,
            S_State(st),
            D_State(d),
            PwrAttributes(pa));
        ExtMemLoc+=sizeof(HC_POWER_STATE);
    }


}


VOID
DumpFdoSpin(
    MEMLOC MemLoc
    )
{
    MEMLOC ExtMemLoc;
    UCHAR cs[] = "usbport!_DEVICE_EXTENSION";
    ULONG pa, st, d, i;
    UCHAR s[64];
    UCHAR csFdo[] = "usbport!_FDO_EXTENSION";

    PrintfMemLoc("*SPINLOCK SUMMARY fdo ",
                  MemLoc,
                 "\n");

    ExtMemLoc = MemLoc + UsbFieldOffset(cs, "Fdo");

    PrintfMemLoc("CoreFunctionSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "CoreFunctionSpin"),
                 "\n");
    PrintfMemLoc("MapTransferSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "MapTransferSpin"),
                 "\n");
    PrintfMemLoc("DoneTransferSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "DoneTransferSpin"),
                 "\n");
    PrintfMemLoc("EndpointListSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "EndpointListSpin"),
                 "\n");
    PrintfMemLoc("EpStateChangeListSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "EpStateChangeListSpin"),
                 "\n");
    PrintfMemLoc("DevHandleListSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "DevHandleListSpin"),
                 "\n");
    PrintfMemLoc("EpClosedListSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "EpClosedListSpin"),
                 "\n");
    PrintfMemLoc("PendingTransferIrpSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "PendingTransferIrpSpin"),
                 "\n");
    PrintfMemLoc("ActiveTransferIrpSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "ActiveTransferIrpSpin"),
                 "\n");
    PrintfMemLoc("WorkerThreadSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "WorkerThreadSpin"),
                 "\n");
    PrintfMemLoc("DM_TimerSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "DM_TimerSpin"),
                 "\n");
    PrintfMemLoc("WakeIrpSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "WakeIrpSpin"),
                 "\n");
    PrintfMemLoc("HcPendingWakeIrpSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "HcPendingWakeIrpSpin"),
                 "\n");
    PrintfMemLoc("IdleIrpSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "IdleIrpSpin"),
                 "\n");
    PrintfMemLoc("IsrDpcSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "IsrDpcSpin"),
                 "\n");
    PrintfMemLoc("StatCounterSpin - ",
                  ExtMemLoc + UsbFieldOffset(csFdo, "StatCounterSpin"),
                 "\n");
}


VOID
DumpBandwidth(
    MEMLOC MemLoc
    )
{
    MEMLOC ExtMemLoc;
    UCHAR cs[] = "usbport!_DEVICE_EXTENSION";
    ULONG pa, st, d, i;
    UCHAR s[64];
    UCHAR csFdo[] = "usbport!_FDO_EXTENSION";
    ULONG bandwidthTable[USBPORT_MAX_INTEP_POLLING_INTERVAL];

    PrintfMemLoc("*BANDWIDTH SUMMARY fdo_ext ",
                  MemLoc,
                 "\n");

    ExtMemLoc = MemLoc + UsbFieldOffset(cs, "Fdo");

    dprintf ("TotalBusBandwidth (bits/sec): %d\n",
                UsbReadFieldUlong(ExtMemLoc, csFdo, "TotalBusBandwidth")
            );


    // dump the 32 node bandwidth table

    {
    ULONG64 addr;
    ULONG cb;

    addr = ExtMemLoc + UsbFieldOffset(csFdo,
            "BandwidthTable[0]");

    ReadMemory(addr,
               &bandwidthTable,
               (ULONG)sizeof(bandwidthTable),
               &cb);
    }

    for (i=0; i< USBPORT_MAX_INTEP_POLLING_INTERVAL/4; i++) {
        dprintf ("[%02.2d] - %8d [%02.2d] - %8d [%02.2d] - %8d [%02.2d] - %8d\n",
            i*4, bandwidthTable[i*4],
            i*4+1, bandwidthTable[i*4+1],
            i*4+2, bandwidthTable[i*4+2],
            i*4+3, bandwidthTable[i*4+3]);
    }

    dprintf ("AllocedInterruptBW, period 1,2,4,8,16,32 ms\n");
    for (i=0; i<6; i++) {
        UCHAR s[80];
        sprintf(s, "AllocedInterruptBW[%d]", i);
        dprintf ("bits/sec %d \n",
            UsbReadFieldUlong(ExtMemLoc, csFdo, s)
            );
    }

    dprintf ("AllocedIsoBW %d \n",
        UsbReadFieldUlong(ExtMemLoc, csFdo, "AllocedIsoBW")
        );

    {
    ULONG m, t;
    t =  UsbReadFieldUlong(ExtMemLoc, csFdo, "TotalBusBandwidth");
    m =  UsbReadFieldUlong(ExtMemLoc, csFdo, "MaxAllocedBw");
    dprintf ("MaxAllocedBw %d %% (%d)\n", m, (m*100/t));
    m =  UsbReadFieldUlong(ExtMemLoc, csFdo, "MinAllocedBw");
    dprintf ("MinAllocedBw %d %% (%d)\n", m, (m*100/t));
    }

}


#if 0
VOID
DumpCaps(
    PDEVICE_CAPABILITIES DevCaps
    )
{
    dprintf ("USBPORT PDO Extension\n");

    dprintf("DeviceCapabilities: \n");
    dprintf(">Size %d Version %d\n", devCaps.Size, devCaps.Version);
    dprintf(">Address %08.8x UINumber %08.8x\n", devCaps.Address, devCaps.UINumber);

    dprintf(">DeviceD1: ");
    if (devCaps.DeviceD1) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">DeviceD2: ");
    if (devCaps.DeviceD2) {
    dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">LockSupported: ");
    if (devCaps.LockSupported) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">EjectSupported: ");
    if (devCaps.EjectSupported) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">Removable: ");
    if (devCaps.Removable) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">DockDevice: ");
    if (devCaps.DockDevice) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">UniqueID: ");
    if (devCaps.UniqueID) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">SilentInstall: ");
    if (devCaps.SilentInstall) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">RawDeviceOK: ");
    if (devCaps.RawDeviceOK) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">SurpriseRemovalOK: ");
    if (devCaps.SurpriseRemovalOK) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">WakeFromD0: ");
    if (devCaps.WakeFromD0) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">WakeFromD1: ");
    if (devCaps.WakeFromD1) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">WakeFromD2: ");
    if (devCaps.WakeFromD2) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">WakeFromD3: ");
    if (devCaps.WakeFromD3) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">HardwareDisabled: ");
    if (devCaps.HardwareDisabled) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">NonDynamic: ");
    if (devCaps.NonDynamic) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }
    dprintf(">WarmEjectSupported: ");
    if (devCaps.WarmEjectSupported) {
        dprintf(" yes\n");
    } else {
        dprintf(" no\n");
    }

    //BUGBUG
    //DEVICE_POWER_STATE DeviceState[PowerSystemMaximum];
    //SYSTEM_POWER_STATE SystemWake;
    //DEVICE_POWER_STATE DeviceWake;
    dprintf(">D1Latency: %d\n", devCaps.D1Latency);
    dprintf(">D2Latency: %d\n", devCaps.D2Latency);
    dprintf(">D3Latency: %d\n", devCaps.D3Latency);
}
#endif


VOID
DumpPortDevExt(
    MEMLOC ExtMemLoc
    )
{
    UCHAR cs[] = "usbport!_DEVICE_EXTENSION";
    ULONG sig, f;
    DEVICE_POWER_STATE dps;

    FLAG_TABLE flags[] = {
        "USBPORT_FLAG_SYM_LINK", USBPORT_FLAG_SYM_LINK
        };
    FLAG_TABLE pnpFlags[] = {
        "USBPORT_PNP_STOPPED", USBPORT_PNP_STOPPED,
        "USBPORT_PNP_STARTED", USBPORT_PNP_STARTED,
        "USBPORT_PNP_REMOVED", USBPORT_PNP_REMOVED,
        "USBPORT_PNP_START_FAILED", USBPORT_PNP_START_FAILED
        };

    PrintfMemLoc("*USBPORT DEVICE_EXTENSION ", ExtMemLoc, "\n");

    PrintfMemLoc("DummyUsbdExtension: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "DummyUsbdExtension"),
            "\n");

    sig = UsbReadFieldUlong(ExtMemLoc, cs, "Sig");

    if (sig != USBPORT_DEVICE_EXT_SIG &&
        sig != ROOTHUB_DEVICE_EXT_SIG) {
        dprintf("Not a USBPORT Extension\n");
        return;
    }

    Sig(sig, "");

    PrintfMemLoc("HcFdoDeviceObject: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "HcFdoDeviceObject"),
            "\n");

    PrintfMemLoc("LogPtr: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "Log.LogPtr"),
            "");
    PrintfMemLoc("LogStart: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "Log.LogStart"),
            "");
    PrintfMemLoc("LogEnd: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "Log.LogEnd"),
            "\n");

    PrintfMemLoc("EnumLog.LogPtr: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "EnumLog.LogPtr"),
            "");
    PrintfMemLoc("EnumLog.LogStart: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "EnumLog.LogStart"),
            "");
    PrintfMemLoc("EnumLog.LogEnd: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "EnumLog.LogEnd"),
            "\n");

    PrintfMemLoc("PendingRequestCount: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "PendingRequestCount"),
            "\n");

    PrintfMemLoc("TrackIrpList.Flink: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "TrackIrpList.Flink"),
            "\n");
    PrintfMemLoc("TrackIrpList.Blink: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "TrackIrpList.Blink"),
            "\n");

    PrintfMemLoc("PendingTransferIrpTable: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "PendingTransferIrpTable"),
            "\n");
    PrintfMemLoc("ActiveTransferIrpTable: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "ActiveTransferIrpTable"),
            "\n");

    f = UsbReadFieldUlong(ExtMemLoc, cs, "Flags");
    dprintf("Flags: %08.8x\n", f);
    UsbDumpFlags(f, flags,
        sizeof(flags)/sizeof(FLAG_TABLE));

    f = UsbReadFieldUlong(ExtMemLoc, cs, "PnpStateFlags");
    dprintf("PnpStateFlags: %08.8x\n", f);
    UsbDumpFlags(f, pnpFlags,
        sizeof(pnpFlags)/sizeof(FLAG_TABLE));

    dprintf("----------------\n");
    PrintfMemLoc("SystemPowerIrp: ",
            UsbReadFieldPtr(ExtMemLoc, cs, "SystemPowerIrp"),
            "\n");
    dprintf("CurrentDevicePowerState: ");

    dps = (DEVICE_POWER_STATE) UsbReadFieldUlong(ExtMemLoc, cs,
                                "CurrentDevicePowerState");
    switch (dps) {
    case PowerDeviceUnspecified:
        dprintf("PowerDeviceUnspecified\n");
        break;
    case PowerDeviceD0:
        dprintf("PowerDeviceD0\n");
        break;
    case PowerDeviceD1:
        dprintf("PowerDeviceD1\n");
        break;
    case PowerDeviceD2:
        dprintf("PowerDeviceD2\n");
        break;
    case PowerDeviceD3:
        dprintf("PowerDeviceD3\n");
        break;
    default:
        dprintf("???\n");
    }

    dprintf ("Power Capabilities\n");
    DumpPowerCaps(ExtMemLoc + UsbFieldOffset(cs, "DeviceCapabilities"));

    dprintf("----------------\n");

//    dprintf("SymbolicLinkName:\n");
//    DumpUnicodeString(devExt.SymbolicLinkName);
    if (sig == USBPORT_DEVICE_EXT_SIG) {
        ExtMemLoc = ExtMemLoc + UsbFieldOffset(cs, "Fdo");
        DumpPortFdoDevExt(ExtMemLoc);
    }

    if (sig == ROOTHUB_DEVICE_EXT_SIG) {
        ExtMemLoc = ExtMemLoc + UsbFieldOffset(cs, "Pdo");
        DumpPortPdoDevExt(ExtMemLoc);
    }

}


VOID
DumpMiniportList(
    MEMLOC HeadMemLoc
    )
{
    MEMLOC flink;
    MEMLOC blink;
    MEMLOC mpMemLoc;
    ULONG i=0;
    UCHAR cs[] = "_USBPORT_MINIPORT_DRIVER";

    dprintf ("*USBPORT DRIVER LIST: ");
    PrintfMemLoc("", HeadMemLoc, "\n");

    GetFieldValue(HeadMemLoc, "_LIST_ENTRY", "Flink", flink);
    GetFieldValue(HeadMemLoc, "_LIST_ENTRY", "Blink", blink);

    PrintfMemLoc("blink: ", blink, "\n");
    PrintfMemLoc("flink: ", flink, "\n");

    while (flink != HeadMemLoc && i < 5) {
        // get the address of the USBPORT_MINIPORT_DRIVER
        // struct
        mpMemLoc = flink - UsbFieldOffset("_USBPORT_MINIPORT_DRIVER",
            "ListEntry");

        dprintf ("[%d] MiniportDriver: ", i);
        PrintfMemLoc("", mpMemLoc, "\n");
        i++;

        PrintfMemLoc("\tDriverObject: ",
            UsbReadFieldPtr(mpMemLoc, cs, "DriverObject"),
            "\n");
        PrintfMemLoc("\tMiniportUnload: ",
            UsbReadFieldPtr(mpMemLoc, cs, "MiniportUnload"),
            "\n");

        flink = UsbReadFieldPtr(mpMemLoc, cs, "ListEntry.Flink");


    }
}


VOID
DumpIrps(
    MEMLOC ExtMemLoc
    )
{
    UCHAR cs[] = "usbport!_DEVICE_EXTENSION";
    UCHAR is[] = "_USBPORT_IRP_TABLE";
    MEMLOC nxt, tbl;
    ULONG i;
    UCHAR s[64];

    PrintfMemLoc("*USBPORT DEVICE_EXTENSION ", ExtMemLoc, "\n");

    tbl = UsbReadFieldPtr(ExtMemLoc, cs, "PendingTransferIrpTable");

    PrintfMemLoc("Pending TABLE @", tbl, "\n");
    nxt = UsbReadFieldPtr(tbl, is, "NextTable"),
    PrintfMemLoc("NextTable: ", nxt, "\n");
    for (i= 0; i<IRP_TABLE_LENGTH; i++) {
        MEMLOC irp;
        sprintf(s, "Irps[%d]", i);
        irp = UsbReadFieldPtr(tbl, is, s);
        if (irp != 0) {
            PrintfMemLoc("irp: ",
                         irp,
                         "\n");
        }
    }

    tbl = UsbReadFieldPtr(ExtMemLoc, cs, "ActiveTransferIrpTable");

    PrintfMemLoc("Active TABLE @", tbl, "\n");
    nxt = UsbReadFieldPtr(tbl, is, "NextTable"),
    PrintfMemLoc("NextTable: ", nxt, "\n");
    for (i= 0; i<IRP_TABLE_LENGTH; i++) {
        MEMLOC irp;
        sprintf(s, "Irps[%d]", i);
        irp = UsbReadFieldPtr(tbl, is, s);
        if (irp != 0) {
            PrintfMemLoc("irp: ",
                         irp,
                         "\n");
        }
    }
}


DECLARE_API( _ext )

/*++

Routine Description:

   dumps the extension

Arguments:

    args - Address flags

Return Value:

    None

--*/

{
    MEMLOC addr;

    CHECKSYM();

    addr = GetExpression( args );

    DumpPortDevExt (addr);

    return S_OK;
}


DECLARE_API( _usbirps )

/*++

Routine Description:

   dumps the irps from our active and pending
   tables

Arguments:

    args - Address flags

Return Value:

    None

--*/

{
    MEMLOC addr;

    CHECKSYM();

    addr = GetExpression( args );

    DumpIrps (addr);

    return S_OK;
}


DECLARE_API( _help )

/*++

Routine Description:

   dumps the extension

Arguments:

    args - Address flags

Return Value:

    None

--*/

{

    // usbport extensions
    dprintf("usbport extensions\n");
    dprintf("!_ext [addr] - addr = DEVICE_EXTENSION fdo | pdo\n");
    dprintf("!_pow [addr] - addr = fdo DEVICE_EXTENSION\n");

    dprintf("!_list [n], [type]\n");

    dprintf("!_devh [addr]\n");
    dprintf("!_log [addr], [count] - addr = DEVICE_EXTENSION\n");
    dprintf("                        count = entries to dump \n");

    dprintf("!_urb [addr]\n");
    dprintf("!_endp [addr]\n");
    dprintf("!_cmbf [addr]\n");
    dprintf("!_tfer [addr] - dumps HCD_TRANSFER_CONTEXT for usbport\n");
    dprintf("!_iso [addr] - dumps MINIPORT_ISO_TRANSFER for usbport\n");
    dprintf("---\n");

    // usbohci miniport extensions
    dprintf("usbohci miniport extensions \n");
    dprintf("!_ohcidd [addr] - addr = DEVICE_DATA\n");
    dprintf("!_ohcitd [addr] - addr = HCD_TRANSFER_DESCRIPTOR\n");
    dprintf("!_ohcied [addr] - addr = HCD_ENDPOINT_DESCRIPTOR\n");
    dprintf("!_ohciep [addr] - addr = ENDPOINT_DATA\n");
    dprintf("!_ohcitfer [addr] - addr = TRANSFER_CONTEXT\n");
    dprintf("!_ohciregs [addr] - addr = OHCI Opertation Registers\n");
    dprintf("---\n");

    // usbehci miniport extensions
    dprintf("usbehci miniport extensions \n");
    dprintf("!_ehcidd [addr] - addr = DEVICE_DATA\n");
    dprintf("!_ehciitd [addr] - addr = HCD_HSISO_TRANSFER_DESCRIPTOR (TD)\n");
    dprintf("!_ehcitd [addr] - addr = HCD_TRANSFER_DESCRIPTOR (ITD)\n");
    dprintf("!_ehcsitd [addr] - addr = HCD_SI_TRANSFER_DESCRIPTOR (SITD)\n");
    dprintf("!_ehciqh [addr] - addr = HCD_QUEUEHEAD_DESCRIPTOR\n");
    dprintf("!_ehcistq [addr] - addr = <static> HCD_QUEUEHEAD_DESCRIPTOR\n");
    dprintf("!_ehciep [addr] - addr = ENDPOINT_DATA\n");
    dprintf("!_ehcitfer [addr] - addr = TRANSFER_CONTEXT\n");
    dprintf("!_ehciregs [addr] - addr = OperationalRegisters\n");
    dprintf("!_ehciframe [addr], [n] - addr = FrameListBaseAddress \n");
    dprintf("---\n");

    dprintf("!_help - displays this screen\n");

    return S_OK;
}


DECLARE_API( _pow )

/*++

Routine Description:

   dumps a summary of the power info

   pow fdo_ext

Arguments:

    args - Address flags

Return Value:

    None

--*/

{
    MEMLOC addr;

    CHECKSYM();

    addr = GetExpression( args );

    DumpFdoPower (addr);

    return S_OK;

}


DECLARE_API( _usbport )

/*++

Routine Description:

   dumps the extension

Arguments:

    args -

Return Value:

    None

--*/

{
    MEMLOC          addr;

//    memLoc = GetExpression(args);

    // fetch the list head
    addr = GetExpression( "usbport!USBPORT_MiniportDriverList" );

    if (addr == 0) {
       dprintf("Error retrieving address of USBPORT_MiniportDriverList\n");
       return E_INVALIDARG;
    }

    DumpMiniportList(addr);

    return S_OK;
}


DECLARE_API( _spin )

/*++

Routine Description:

   dumps the extension

Arguments:

    args -

Return Value:

    None

--*/

{
    MEMLOC          addr;

    CHECKSYM();

    addr = GetExpression( args );

    DumpFdoSpin (addr);

    return S_OK;
}


DECLARE_API( _bw )

/*++

Routine Description:

   dumps the extension

Arguments:

    args -

Return Value:

    None

--*/

{
    MEMLOC          addr;

    CHECKSYM();

    addr = GetExpression( args );

    DumpBandwidth (addr);

    return S_OK;
}