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.
744 lines
19 KiB
744 lines
19 KiB
/*++
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
usbohci.c
|
|
|
|
Abstract:
|
|
|
|
WinDbg Extension Api
|
|
implements !_ohcitd
|
|
!_ohcied
|
|
!_ohciep
|
|
!_ohcitfer
|
|
|
|
Author:
|
|
|
|
jd
|
|
|
|
Environment:
|
|
|
|
User Mode.
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "usb.h"
|
|
#include "usbhcdi.h"
|
|
#include "..\miniport\usbohci\openhci.h"
|
|
#include "..\miniport\usbohci\usbohci.h"
|
|
#include "usbhcdkd.h"
|
|
|
|
VOID
|
|
DumpOHCI_EpTransfers(
|
|
ULONG HeadP_MemLoc,
|
|
ULONG TailP_MemLoc
|
|
);
|
|
|
|
VOID
|
|
HwConditionCode(
|
|
ULONG cc
|
|
)
|
|
{
|
|
|
|
switch (cc) {
|
|
case HcCC_NoError:
|
|
dprintf("HcCC_NoError");
|
|
break;
|
|
case HcCC_CRC:
|
|
dprintf("HcCC_CRC ");
|
|
break;
|
|
case HcCC_BitStuffing:
|
|
dprintf("HcCC_BitStuffing");
|
|
break;
|
|
case HcCC_DataToggleMismatch:
|
|
dprintf("HcCC_DataToggleMismatch");
|
|
break;
|
|
case HcCC_Stall:
|
|
dprintf("HcCC_Stall ");
|
|
break;
|
|
case HcCC_DeviceNotResponding:
|
|
dprintf("HcCC_DeviceNotResponding");
|
|
break;
|
|
case HcCC_PIDCheckFailure:
|
|
dprintf("HcCC_PIDCheckFailure");
|
|
break;
|
|
case HcCC_UnexpectedPID:
|
|
dprintf("HcCC_UnexpectedPID");
|
|
break;
|
|
case HcCC_DataOverrun:
|
|
dprintf("HcCC_DataOverrun");
|
|
break;
|
|
case HcCC_DataUnderrun:
|
|
dprintf("HcCC_DataUnderrun");
|
|
break;
|
|
case HcCC_BufferOverrun:
|
|
dprintf("HcCC_BufferOverrun ");
|
|
break;
|
|
case HcCC_BufferUnderrun:
|
|
dprintf("HcCC_BufferUnderrun");
|
|
break;
|
|
case HcCC_NotAccessed:
|
|
dprintf("HcCC_NotAccessed");
|
|
break;
|
|
default:
|
|
dprintf("???");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpOHCI_Td(
|
|
MEMLOC MemLoc
|
|
)
|
|
{
|
|
|
|
HCD_TRANSFER_DESCRIPTOR td;
|
|
ULONG cb;
|
|
ULONG i;
|
|
|
|
// tds are a fixed size of 64/32 platforms so
|
|
// we can just read it in
|
|
|
|
ReadMemory(MemLoc,
|
|
&td,
|
|
sizeof(td),
|
|
&cb);
|
|
|
|
PrintfMemLoc("*USBOHCI TD ", MemLoc, "\n");
|
|
|
|
dprintf("HwTD");
|
|
if (td.HwTD.Asy.Isochronous) {
|
|
// dump as iso
|
|
dprintf("\tIsochronous %x, \n", td.HwTD.Iso.Isochronous);
|
|
dprintf("\tStartingFrame: %x\n", td.HwTD.Iso.StartingFrame);
|
|
dprintf("\tFrameCount: %d (%d frames) \n", td.HwTD.Iso.FrameCount,
|
|
td.HwTD.Iso.FrameCount+1);
|
|
// dump the psw
|
|
|
|
dprintf("\tPSW:\n");
|
|
for (i=0; i< td.HwTD.Iso.FrameCount+2; i++) {
|
|
// input
|
|
dprintf("\t\tinput:[%d].Offset: x%x - %d\n", i,
|
|
td.HwTD.Packet[i].Offset,
|
|
td.HwTD.Packet[i].Offset);
|
|
dprintf("\t\tinput:[%d].Ones: x%x \n", i, td.HwTD.Packet[i].Ones);
|
|
|
|
dprintf("\t\toutput:[%d].Size: %d\n", i, td.HwTD.Packet[i].Size);
|
|
dprintf("\t\toutput:[%d].ConditionCode: %d\n", i, td.HwTD.Packet[i].ConditionCode);
|
|
}
|
|
} else {
|
|
|
|
// dump as async
|
|
dprintf("\tIsochronous %x, \n", td.HwTD.Asy.Isochronous);
|
|
dprintf("\tShortXferOk: %x\n", td.HwTD.Asy.ShortXferOk);
|
|
dprintf("\tDirection: %x\n", td.HwTD.Asy.Direction);
|
|
dprintf("\tToggle: %x", td.HwTD.Asy.Toggle);
|
|
dprintf("\tIntDelay: %x", td.HwTD.Asy.IntDelay);
|
|
dprintf("\tErrorCount: %x\n", td.HwTD.Asy.ErrorCount);
|
|
dprintf("\tConditionCode: x%x - ", td.HwTD.Asy.ConditionCode);
|
|
HwConditionCode(td.HwTD.Asy.ConditionCode);
|
|
dprintf("\n");
|
|
|
|
switch (td.HwTD.Asy.Toggle) {
|
|
case HcTDToggle_FromEd:
|
|
dprintf("HcTDToggle_FromEd\n");
|
|
break;
|
|
case HcTDToggle_Data0:
|
|
dprintf("HcTDToggle_Data0\n");
|
|
break;
|
|
case HcTDToggle_Data1:
|
|
dprintf("HcTDToggle_Data1\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
// these fields are common for iso & async
|
|
|
|
dprintf("\tCBP: ! %x\n", td.HwTD.CBP);
|
|
dprintf("\tBE: ! %x\n", td.HwTD.BE);
|
|
dprintf("\tNextTD: ! %x\n", td.HwTD.NextTD);
|
|
|
|
dprintf("PhysicalAddress: %08.8x\n", td.PhysicalAddress);
|
|
Sig(td.Sig, "");
|
|
dprintf("Flags: 0x%08.8x\n", td.Flags);
|
|
dprintf("EndpointData: %08.8x\n", td.EndpointData);
|
|
dprintf("TransferContext: %08.8x\n", td.TransferContext);
|
|
dprintf("TransferCount: 0x%08.8x\n", td.TransferCount);
|
|
dprintf("FrameIndex: %d\n", td.FrameIndex);
|
|
dprintf("NextHcdTD: %08.8x\n", td.NextHcdTD);
|
|
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpOHCI_Ed(
|
|
ULONG MemLoc
|
|
)
|
|
{
|
|
|
|
HCD_ENDPOINT_DESCRIPTOR ed;
|
|
ULONG result;
|
|
|
|
if (!ReadMemory (MemLoc, &ed, sizeof(ed), &result)) {
|
|
BadMemLoc(MemLoc);
|
|
return;
|
|
}
|
|
|
|
dprintf("*USBOHCI ED %08.8x\n", MemLoc);
|
|
dprintf("HwED");
|
|
dprintf("\tFunctionAddress: 0x%x\n", ed.HwED.FunctionAddress);
|
|
dprintf("\tEndpointNumber: %x\n", ed.HwED.EndpointNumber);
|
|
dprintf("\tDirection: %x\n", ed.HwED.Direction);
|
|
dprintf("\tLowSpeed: %x\n", ed.HwED.LowSpeed);
|
|
dprintf("\tsKip: %x\n", ed.HwED.sKip);
|
|
dprintf("\tIsochronous: %x\n", ed.HwED.Isochronous);
|
|
dprintf("\tMaxPacket: 0x%x\n", ed.HwED.MaxPacket);
|
|
|
|
dprintf("\tTailP: ! %x\n", ed.HwED.TailP);
|
|
dprintf("\tHeadP: ! %x", ed.HwED.HeadP);
|
|
if (ed.HwED.HeadP & HcEDHeadP_HALT) {
|
|
dprintf(" (halted)");
|
|
}
|
|
dprintf("\n");
|
|
dprintf("\tNextED: %x\n", ed.HwED.NextED);
|
|
|
|
dprintf("PhysicalAddress: %08.8x\n", ed.PhysicalAddress);
|
|
Sig(ed.Sig, "");
|
|
dprintf("EdFlags: 0x%08.8x\n", ed.EdFlags);
|
|
dprintf("EndpointData: %08.8x\n", ed.EndpointData);
|
|
dprintf("SwLink.List.Flink: %08.8x\n", ed.SwLink.List.Flink);
|
|
dprintf("SwLink.List.Blink: %08.8x\n", ed.SwLink.List.Blink);
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpOHCI_EndpointData(
|
|
MEMLOC MemLoc
|
|
)
|
|
{
|
|
|
|
UCHAR cs[] = "usbohci!_ENDPOINT_DATA";
|
|
|
|
PrintfMemLoc("*USBOHCI ENDPOINT_DATA ", MemLoc, "\n");
|
|
|
|
Sig(UsbReadFieldUlong(MemLoc, cs, "Sig"), "");
|
|
// dprintf("MaxPendingTransfers: 0x%08.8x\n", epData.MaxPendingTransfers);
|
|
dprintf("PendingTransfers: 0x%08.8x\n",
|
|
UsbReadFieldUlong(MemLoc, cs, "PendingTransfers"));
|
|
PrintfMemLoc("StaticEd: ",
|
|
UsbReadFieldPtr(MemLoc, cs, "StaticEd"),
|
|
"\n");
|
|
PrintfMemLoc("TdList: ",
|
|
UsbReadFieldPtr(MemLoc, cs, "TdList"),
|
|
"\n");
|
|
PrintfMemLoc("HcdEd: ",
|
|
UsbReadFieldPtr(MemLoc, cs, "HcdEd"),
|
|
"\n");
|
|
|
|
dprintf("TdCount: 0x%08.8x\n",
|
|
UsbReadFieldUlong(MemLoc, cs, "TdCount"));
|
|
|
|
PrintfMemLoc("HcdTailP: ",
|
|
UsbReadFieldPtr(MemLoc, cs, "HcdTailP"),
|
|
"\n");
|
|
PrintfMemLoc("HcdHeadP: ",
|
|
UsbReadFieldPtr(MemLoc, cs, "HcdHeadP"),
|
|
"\n");
|
|
|
|
// DumpOHCI_Ed(epData.HcdEd);
|
|
|
|
// DumpOHCI_EpTransfers((ULONG) epData.HcdHeadP, (ULONG) epData.HcdTailP);
|
|
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpOHCI_TransferContext(
|
|
ULONG MemLoc
|
|
)
|
|
{
|
|
|
|
TRANSFER_CONTEXT tc;
|
|
ULONG result;
|
|
SIG s;
|
|
|
|
if (!ReadMemory (MemLoc, &tc, sizeof(tc), &result)) {
|
|
BadMemLoc(MemLoc);
|
|
return;
|
|
}
|
|
|
|
dprintf("*USBOHCI TRANSFER_CONTEXT %08.8x\n", MemLoc);
|
|
Sig(tc.Sig, "");
|
|
dprintf("BytesTransferred: 0x%08.8x\n", tc.BytesTransferred);
|
|
dprintf("TransferParameters: %x\n",
|
|
tc.TransferParameters);
|
|
dprintf("PendingTds: %d\n", tc.PendingTds);
|
|
dprintf("Flags: %08.8x\n", tc.TcFlags);
|
|
dprintf("UsbdStatus: 0x%08.8x\n", tc.UsbdStatus);
|
|
dprintf("NextXferTd: %08.8x\n", tc.NextXferTd);
|
|
dprintf("StatusTd: %08.8x\n", tc.StatusTd);
|
|
dprintf("EndpointData: %08.8x\n", tc.EndpointData);
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpOHCI_EpTransfers(
|
|
ULONG HeadP_MemLoc,
|
|
ULONG TailP_MemLoc
|
|
)
|
|
{
|
|
#if 0
|
|
HCD_TRANSFER_DESCRIPTOR td;
|
|
ULONG memLoc, result;
|
|
|
|
// start at headp and walk to tail
|
|
dprintf("\t TRANSFERS: HeadP\n");
|
|
|
|
memLoc = HeadP_MemLoc;
|
|
|
|
do {
|
|
|
|
if (!ReadMemory (memLoc, &td, sizeof(td), &result)) {
|
|
break;
|
|
}
|
|
|
|
dprintf("\t> TD %8.8x(! %8.8x) - Transfer %8.8x Next-> ! %8.8x\n",
|
|
memLoc, td.PhysicalAddress, td.TransferContext.Pointer,
|
|
td.HwTD.NextTD);
|
|
|
|
|
|
if (memLoc == TailP_MemLoc) {
|
|
break;
|
|
}
|
|
|
|
memLoc = (ULONG) td.NextHcdTD.Pointer;
|
|
|
|
} while (1);
|
|
#endif
|
|
}
|
|
|
|
|
|
VOID
|
|
DumpOHCI_DeviceData(
|
|
MEMLOC MemLoc,
|
|
BOOLEAN Verbose
|
|
)
|
|
{
|
|
UCHAR cs[] = "usbohci!_DEVICE_DATA";
|
|
ULONG f, i;
|
|
UCHAR fld[40], fld1[40], fld2[40], fld3[40], fld4[40];
|
|
STRUC_ENTRY t[] = {
|
|
"Sig", FT_SIG,
|
|
"HC", FT_PTR,
|
|
"BIOS_Interval", FT_ULONG,
|
|
"SofModifyValue", FT_ULONG,
|
|
"FrameHighPart", FT_ULONG,
|
|
"HcHCCA", FT_PTR,
|
|
"HcHCCAPhys", FT_ULONG,
|
|
"HydraLsHsHackEd", FT_PTR,
|
|
"StaticEDs", FT_PTR,
|
|
"StaticEDsPhys", FT_ULONG,
|
|
"ControllerFlavor", FT_ULONG,
|
|
|
|
};
|
|
ULONG period[] = {1, 2, 2, 4, 4, 4, 4, 8,
|
|
8, 8, 8, 8, 8, 8, 8,16,
|
|
16,16,16,16,16,16,16,16,
|
|
16,16,16,16,16,16,16,32,
|
|
32,32,32,32,32,32,32,32,
|
|
32,32,32,32,32,32,32,32,
|
|
32,32,32,32,32,32,32,32,
|
|
32,32,32,32,32,32,32,
|
|
0, 0};
|
|
// FLAG_TABLE ddFlags[] = {
|
|
// "EHCI_DD_FLAG_NOCHIRP", EHCI_DD_FLAG_NOCHIRP,
|
|
// "EHCI_DD_FLAG_SOFT_ERROR_RETRY", EHCI_DD_FLAG_SOFT_ERROR_RETRY
|
|
// };
|
|
|
|
PrintfMemLoc("*USBOHCI DEVICE DATA ", MemLoc, "\n");
|
|
UsbDumpStruc(MemLoc, cs,
|
|
&t[0], sizeof(t)/sizeof(STRUC_ENTRY));
|
|
|
|
if (Verbose) {
|
|
for (i= 0; i< NO_ED_LISTS; i++) {
|
|
dprintf("\t[%02.2d] (%2.2dms): ", i, period[i]);
|
|
sprintf(fld , "StaticEDList[%d]", i);
|
|
sprintf(fld1, "StaticEDList[%d].HwED", i);
|
|
sprintf(fld2, "StaticEDList[%d].HwEDPhys", i);
|
|
PrintfMemLoc("StaticED @ ",
|
|
MemLoc + UsbFieldOffset(cs, fld),
|
|
" ");
|
|
PrintfMemLoc("HwED ",
|
|
UsbReadFieldPtr(MemLoc, cs, fld1),
|
|
" ");
|
|
|
|
dprintf("(!%08.8x)\n",
|
|
UsbReadFieldUlong(MemLoc, cs, fld2));
|
|
|
|
sprintf(fld1, "StaticEDList[%d].NextIdx", i);
|
|
sprintf(fld2, "StaticEDList[%d].EdFlags", i);
|
|
sprintf(fld3, "StaticEDList[%d].HccaOffset", i);
|
|
sprintf(fld4, "StaticEDList[%d].PhysicalHead", i);
|
|
|
|
dprintf("\t\tNextIdx(%03.3d) EdFlags %08.8x Hcca Offset %d ",
|
|
UsbReadFieldUlong(MemLoc, cs, fld1),
|
|
UsbReadFieldUlong(MemLoc, cs, fld2),
|
|
UsbReadFieldUlong(MemLoc, cs, fld3));
|
|
PrintfMemLoc("PhysicalHead ",
|
|
MemLoc + UsbFieldOffset(cs, fld4),
|
|
"\n");
|
|
|
|
sprintf(fld1, "StaticEDList[%d].TransferEdList.Flink", i);
|
|
PrintfMemLoc("\t\tTransferEdList.Flink ",
|
|
UsbReadFieldPtr(MemLoc, cs, fld1),
|
|
"\n");
|
|
sprintf(fld1, "StaticEDList[%d].TransferEdList.Blink", i);
|
|
PrintfMemLoc("\t\tTransferEdList.Blink ",
|
|
UsbReadFieldPtr(MemLoc, cs, fld1),
|
|
"\n");
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
VOID
|
|
DumpOHCI_Ints(
|
|
ULONG i
|
|
)
|
|
{
|
|
if (i & HcInt_SchedulingOverrun) {
|
|
dprintf("\t HcInt_SchedulingOverrun \n");
|
|
}
|
|
if (i & HcInt_WritebackDoneHead) {
|
|
dprintf("\t HcInt_WritebackDoneHead \n");
|
|
}
|
|
if (i & HcInt_StartOfFrame) {
|
|
dprintf("\t HcInt_StartOfFrame \n");
|
|
}
|
|
if (i & HcInt_ResumeDetected) {
|
|
dprintf("\t HcInt_ResumeDetected \n");
|
|
}
|
|
if (i & HcInt_UnrecoverableError) {
|
|
dprintf("\t HcInt_UnrecoverableError \n");
|
|
}
|
|
if (i & HcInt_RootHubStatusChange) {
|
|
dprintf("\t HcInt_RootHubStatusChange \n");
|
|
}
|
|
if (i & HcInt_OwnershipChange) {
|
|
dprintf("\t HcInt_OwnershipChange \n");
|
|
}
|
|
if (i & HcInt_MasterInterruptEnable) {
|
|
dprintf("\t HcInt_MasterInterruptEnable \n");
|
|
}
|
|
if (i & HcInt_FrameNumberOverflow) {
|
|
dprintf("\t HcInt_FrameNumberOverflow \n");
|
|
}
|
|
|
|
dprintf("\n");
|
|
}
|
|
|
|
VOID
|
|
DumpOHCI_OpRegs(
|
|
MEMLOC MemLoc
|
|
)
|
|
{
|
|
HC_OPERATIONAL_REGISTER hc;
|
|
HC_CONTROL cmd;
|
|
HC_COMMAND_STATUS sts;
|
|
ULONG l, i, p;
|
|
ULONG cb;
|
|
|
|
ReadMemory(MemLoc,
|
|
&hc,
|
|
sizeof(HC_OPERATIONAL_REGISTER),
|
|
&cb);
|
|
|
|
PrintfMemLoc("*(ohci)HC_OPERATIONAL_REGISTER ", MemLoc, "\n");
|
|
|
|
cmd = hc.HcControl;
|
|
dprintf("\tHC_CONTROL %08.8x\n" , cmd.ul);
|
|
dprintf("\t.ControlBulkServiceRatio: %d\n", cmd.ControlBulkServiceRatio);
|
|
dprintf("\t.IsochronousEnable: %d\n", cmd.IsochronousEnable);
|
|
dprintf("\t.ControlListEnable: %d\n", cmd.ControlListEnable);
|
|
dprintf("\t.BulkListEnable: %d\n", cmd.BulkListEnable);
|
|
dprintf("\t.HostControllerFunctionalState: %d\n", cmd.HostControllerFunctionalState);
|
|
dprintf("Reset=0 Resume=1 Operational=2 Suspend=3\n");
|
|
|
|
dprintf("\t.InterruptRouting: %d\n", cmd.InterruptRouting);
|
|
dprintf("\t.RemoteWakeupConnected: %d\n", cmd.RemoteWakeupConnected);
|
|
dprintf("\t.RemoteWakeupEnable: %d\n", cmd.RemoteWakeupEnable);
|
|
dprintf("\n");
|
|
|
|
sts = hc.HcCommandStatus;
|
|
dprintf("\tHC_COMMAND_STATUS %08.8x\n" , sts.ul);
|
|
dprintf("\t.HostControllerReset: %d\n", sts.HostControllerReset);
|
|
dprintf("\t.ControlListFilled: %d\n", sts.ControlListFilled);
|
|
dprintf("\t.BulkListFilled: %d\n", sts.BulkListFilled);
|
|
dprintf("\t.OwnershipChangeRequest: %d\n", sts.OwnershipChangeRequest);
|
|
dprintf("\t.SchedulingOverrunCount: %d\n", sts.SchedulingOverrunCount);
|
|
dprintf("\n");
|
|
|
|
dprintf("\tHcInterruptStatus: %08.8x\n" , hc.HcInterruptStatus);
|
|
DumpOHCI_Ints(hc.HcInterruptStatus);
|
|
dprintf("\tHcInterruptEnable: %08.8x\n" , hc.HcInterruptEnable);
|
|
DumpOHCI_Ints(hc.HcInterruptEnable);
|
|
dprintf("\tHcInterruptDisable: %08.8x\n" , hc.HcInterruptDisable);
|
|
DumpOHCI_Ints(hc.HcInterruptDisable);
|
|
dprintf("\tHcHCCA: %08.8x\n" , hc.HcHCCA);
|
|
dprintf("\tHcPeriodCurrentED: %08.8x\n" , hc.HcPeriodCurrentED);
|
|
dprintf("\tHcControlHeadED: %08.8x\n" , hc.HcControlHeadED);
|
|
dprintf("\tHcControlCurrentED: %08.8x\n" , hc.HcControlCurrentED);
|
|
dprintf("\tHcBulkHeadED: %08.8x\n" , hc.HcBulkHeadED);
|
|
dprintf("\tHcBulkCurrentED: %08.8x\n" , hc.HcBulkCurrentED);
|
|
dprintf("\tHcDoneHead: %08.8x\n" , hc.HcDoneHead);
|
|
dprintf("\tHcFmInterval: %08.8x\n" , hc.HcFmInterval.ul);
|
|
dprintf("\tHcFmRemaining: %08.8x\n" , hc.HcFmRemaining.ul);
|
|
dprintf("\tHcFmNumber: %08.8x\n" , hc.HcFmNumber);
|
|
dprintf("\tHcPeriodicStart: %08.8x\n" , hc.HcPeriodicStart);
|
|
dprintf("\tHcLSThreshold: %08.8x\n" , hc.HcLSThreshold);
|
|
|
|
dprintf("\t-------\n");
|
|
dprintf("\tCurrent Frame Index = %d\n", hc.HcFmNumber & 0x0000001f);
|
|
dprintf("\t-------\n");
|
|
|
|
dprintf("\tHcRhDescriptorA: %08.8x\n" , hc.HcRhDescriptorA.ul);
|
|
dprintf("\t\tNumberDownstreamPorts: %d\n" , hc.HcRhDescriptorA.s.NumberDownstreamPorts);
|
|
dprintf("\t\tHubChars: %x\n" , hc.HcRhDescriptorA.s.HubChars);
|
|
dprintf("\t\tPowerOnToPowerGoodTime: %d\n" , hc.HcRhDescriptorA.s.PowerOnToPowerGoodTime);
|
|
dprintf("\tHcRhDescriptorB: %08.8x\n" , hc.HcRhDescriptorB.ul);
|
|
dprintf("\tHcRhStatus: %08.8x\n" , hc.HcRhStatus);
|
|
for (p=0; p< hc.HcRhDescriptorA.s.NumberDownstreamPorts; p++) {
|
|
dprintf("\tHcRhPortStatus[%d]: %08.8x\n",p ,hc.HcRhPortStatus[p]);
|
|
}
|
|
}
|
|
|
|
|
|
DECLARE_API( _ohcitd )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
dumps the extension
|
|
|
|
Arguments:
|
|
|
|
args - Address flags
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
MEMLOC addr;
|
|
|
|
// fetch the list head
|
|
addr = GetExpression(args);
|
|
|
|
DumpOHCI_Td (addr);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
DECLARE_API( _ohcied )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
dumps the extension
|
|
|
|
Arguments:
|
|
|
|
args - Address flags
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG memLoc;
|
|
UCHAR buffer[256];
|
|
ULONG len = 30;
|
|
ULONG result;
|
|
|
|
//UNREFERENCED_PARAMETER (dwProcessor);
|
|
//UNREFERENCED_PARAMETER (dwCurrentPc);
|
|
//UNREFERENCED_PARAMETER (hCurrentThread);
|
|
//UNREFERENCED_PARAMETER (hCurrentProcess);
|
|
|
|
buffer[0] = '\0';
|
|
|
|
sscanf(args, "%lx, %s", &memLoc, buffer);
|
|
|
|
if ('\0' != buffer[0]) {
|
|
sscanf(buffer, "%d", &len);
|
|
}
|
|
|
|
DumpOHCI_Ed (memLoc);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
DECLARE_API( _ohciep )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
dumps the extension
|
|
|
|
Arguments:
|
|
|
|
args - Address flags
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
MEMLOC addr;
|
|
|
|
// fetch the list head
|
|
addr = GetExpression(args);
|
|
|
|
DumpOHCI_EndpointData (addr);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
DECLARE_API( _ohcitfer )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
dumps TRANSFER_CONTEXT
|
|
Arguments:
|
|
|
|
args - Address flags
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG memLoc;
|
|
UCHAR buffer[256];
|
|
ULONG len = 30;
|
|
ULONG result;
|
|
|
|
//UNREFERENCED_PARAMETER (dwProcessor);
|
|
//UNREFERENCED_PARAMETER (dwCurrentPc);
|
|
//UNREFERENCED_PARAMETER (hCurrentThread);
|
|
//UNREFERENCED_PARAMETER (hCurrentProcess);
|
|
|
|
buffer[0] = '\0';
|
|
|
|
sscanf(args, "%lx, %s", &memLoc, buffer);
|
|
|
|
if ('\0' != buffer[0]) {
|
|
sscanf(buffer, "%d", &len);
|
|
}
|
|
|
|
DumpOHCI_TransferContext (memLoc);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
DECLARE_API( _ohciregs )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
dumps the extension
|
|
|
|
Arguments:
|
|
|
|
args - Address flags
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
MEMLOC addr;
|
|
|
|
// fetch the list head
|
|
addr = GetExpression(args);
|
|
|
|
DumpOHCI_OpRegs(addr);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
DECLARE_API( _ohcidd )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
dumps the extension
|
|
|
|
Arguments:
|
|
|
|
args - Address flags
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
MEMLOC addr;
|
|
PCSTR s;
|
|
UCHAR parm[32];
|
|
|
|
GetExpressionEx( args, &addr, &s );
|
|
|
|
sscanf(s, ",%s", &parm);
|
|
dprintf("%s\n", parm);
|
|
|
|
DumpOHCI_DeviceData(addr, parm[0] == 'v');
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|