modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/Kernel/Native/HalKd1394.cpp

811 lines
27 KiB
C++
Raw Blame History

//////////////////////////////////////////////////////////////////////////////
//
// Microsoft Research Singularity
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// File: halkd1394.cpp: runtime support for debugging over 1394.
//
// For more information see:
// \nt\base\ntos\kd64
// \nt\base\boot\kdcom
// \nt\base\boot\kd1394
// \nt\base\boot\kdusb2
// \nt\sdktools\debuggers\ntsd64
//
// Note: Kernel Only
//
#include "hal.h"
#include "halkd.h"
#include "halkd1394.h"
//
// Debugger Debugging
//
#define KDDBG if (0) kdprintf
#define KDDBG2 if (0) kdprintf
///////////////////////////////////////////////////////// Debugger Structures.
//
// These structures are accessed directly by the host using RDMA.
//
#define DEBUG_BUS1394_MAX_PACKET_SIZE 4000
#define DEBUG_1394_MAJOR_VERSION 0x1
#define DEBUG_1394_MINOR_VERSION 0x0
#define DEBUG_1394_CONFIG_TAG 0xBABABABA
struct DEBUG_1394_SEND_PACKET {
UINT32 TransferStatus;
UINT32 PacketHeader[4];
UINT32 Length;
UCHAR Packet[DEBUG_BUS1394_MAX_PACKET_SIZE];
UCHAR Padding[72];
};
STATIC_ASSERT(sizeof(DEBUG_1394_SEND_PACKET) == 4096);
struct DEBUG_1394_RECEIVE_PACKET {
UINT32 TransferStatus;
UINT32 Length;
UCHAR Packet[DEBUG_BUS1394_MAX_PACKET_SIZE];
UCHAR Padding[88];
};
STATIC_ASSERT(sizeof(DEBUG_1394_RECEIVE_PACKET) == 4096);
// exists on target, host reads it to match for id.
struct DEBUG_1394_CONFIG {
UINT32 Tag;
UINT16 MajorVersion;
UINT16 MinorVersion;
UINT32 Id;
UINT32 BusPresent;
UINT64 SendPacket;
UINT64 ReceivePacket;
};
STATIC_ASSERT(sizeof(DEBUG_1394_CONFIG) == 32);
struct DEBUG_1394_DATA {
// POHCI_REGISTER_MAP BaseAddress; // our OHCI register map
UINT32 CromBuffer[248]; // our config ROM - must be 1k aligned
DEBUG_1394_CONFIG Config; // our config for this session
DEBUG_1394_SEND_PACKET SendPacket; // our send packet (isoch packet)
DEBUG_1394_RECEIVE_PACKET ReceivePacket; // our receive packet
};
STATIC_ASSERT(sizeof(DEBUG_1394_DATA) == 1024 + 4096 + 4096);
STATIC_ASSERT(sizeof(DEBUG_1394_DATA) <= 3 * 4096); // we allocate 12KB in boot.
//////////////////////////////////////////////////////////////////////////////
//
#define TIMEOUT_COUNT 1024*500
#define MAX_REGISTER_READS 400000
//
// Global Data Structures
//
static DEBUG_1394_DATA * Kd1394Data;
static volatile OHCI_REGISTER_MAP * KdRegisters;
//
static ULONG_PTR MmGetPhysicalAddress(PVOID pv)
{
return (ULONG_PTR)pv;
}
// ?? need to look into this
static UINT32 Dbg1394_StallExecution(UINT32 LoopCount)
{
volatile UINT32 b = 1;
for (volatile UINT32 k = 0; k < LoopCount; k++) {
for (volatile UINT32 i = 1; i < 100000; i++) {
#ifdef ISA_IX86
__asm pause;
#endif
b = b * (i>>k);
}
}
return b;
}
// Exchange byte pairs 0:3 and 1:2 of Source and returns the resulting ULONG.
static inline UINT32 Dbg1394_ByteSwap(UINT32 Source)
{
return (((Source) << (8 * 3)) |
((Source & 0x0000FF00) << (8 * 1)) |
((Source & 0x00FF0000) >> (8 * 1)) |
((Source) >> (8 * 3)));
}
// Derive the 16 bit CRC as defined by IEEE 1212 clause 8.1.5.
// (ISO/IEC 13213) First edition 1994-10-05.
// data - UINT32 data to derive CRC from.
// check - check value.
static UINT32 Dbg1394_Crc16(UINT32 data, UINT32 check)
{
UINT32 next = check;
for (INT32 shift = 28; shift >= 0; shift -= 4) {
UINT32 sum = ((next >> 12) ^ (data >> shift)) & 0xf;
next = (next << 4) ^ (sum << 12) ^ (sum << 5) ^ (sum);
}
return (next & 0xFFFF);
}
// Calculate a CRC for the pointer to the Quadlet data.
// Quadlet - Pointer to data to CRC
// length - length of data to CRC
static UINT16 Dbg1394_CalculateCrc(UINT32 *Quadlet, UINT32 length)
{
UINT32 temp = 0;
for (UINT32 index = 0; index < length; index++) {
temp = Dbg1394_Crc16(Quadlet[index], temp);
}
return (UINT16)temp;
}
////////////////////////////////////////////////// Initialize the controller!
//
bool Kdp1394Init(UINT16 Channel, ULONG_PTR Base, ULONG_PTR BufferAddr32, UINT32 BufferSize32)
{
if (Base == 0 ||
BufferAddr32 == 0 ||
BufferSize32 < sizeof(DEBUG_1394_DATA)) {
return false;
}
// Note: Kd1394Data must be in the low 32-bits of address space due to
// limits on valid 1394 DMA addresses. It must also be contiguous.
Kd1394Data = (DEBUG_1394_DATA *)BufferAddr32;
memset(Kd1394Data, 0, sizeof(*Kd1394Data));
// get our base address
KdRegisters = (volatile OHCI_REGISTER_MAP *)Base;
// initialize our config info for host debugger to read.
Kd1394Data->Config.Tag = DEBUG_1394_CONFIG_TAG;
Kd1394Data->Config.MajorVersion = DEBUG_1394_MAJOR_VERSION;
Kd1394Data->Config.MinorVersion = DEBUG_1394_MINOR_VERSION;
Kd1394Data->Config.Id = (Channel < 0x100) ? Channel : 0;
Kd1394Data->Config.BusPresent = false;
Kd1394Data->Config.SendPacket = MmGetPhysicalAddress(&Kd1394Data->SendPacket);
Kd1394Data->Config.ReceivePacket = MmGetPhysicalAddress(&Kd1394Data->ReceivePacket);
// get our version
UINT32 ulVersion = KdRegisters->Version.all;
UCHAR MajorVersion = (UCHAR)(ulVersion >> 16);
// make sure we have a valid version
if (MajorVersion != 1) { // INVESTIGATE
kdprintf("1394: MajorVersion != 1\n");
return false;
}
// soft reset to initialize the controller
HC_CONTROL_REGISTER HCControl;
HCControl.all = 0;
HCControl.SoftReset = true;
KdRegisters->HCControlSet.all = HCControl.all;
// wait until reset complete - ??
UINT32 retry = 1000; // ??
do {
HCControl.all = KdRegisters->HCControlSet.all;
Dbg1394_StallExecution(1);
} while ((HCControl.SoftReset) && (--retry));
if (retry == 0) {
kdprintf("1394: Reset failed\n");
return false;
}
// enable link to phy communication.
HCControl.all = 0;
HCControl.Lps = true;
KdRegisters->HCControlSet.all = HCControl.all;
Dbg1394_StallExecution(20);
// initialize HCControl register
// send data in little-endian order (i.e. do byte swap).
HCControl.all = 0;
HCControl.NoByteSwapData = true;
KdRegisters->HCControlClear.all = HCControl.all;
// enable posted writes.
HCControl.all = 0;
HCControl.PostedWriteEnable = true;
KdRegisters->HCControlSet.all = HCControl.all;
// setup the link control
LINK_CONTROL_REGISTER LinkControl;
LinkControl.all = 0;
LinkControl.CycleTimerEnable = true;
LinkControl.CycleMaster = true;
LinkControl.RcvPhyPkt = true;
LinkControl.RcvSelfId = true;
KdRegisters->LinkControlClear.all = LinkControl.all;
LinkControl.all = 0;
LinkControl.CycleTimerEnable = true;
LinkControl.CycleMaster = true;
KdRegisters->LinkControlSet.all = LinkControl.all;
// set the bus number (hardcoded to 0x3FF) - ??? what about node id??
NODE_ID_REGISTER NodeId;
NodeId.all = 0;
NodeId.BusId = (UINT16)0x3FF;
KdRegisters->NodeId.all = NodeId.all;
// do something with the crom...
// 0xf0000404 - bus id register
Kd1394Data->CromBuffer[1] = 0x31333934;
// 0xf0000408 - bus options register
BUS_OPTIONS_REGISTER BusOptions;
BusOptions.all = Dbg1394_ByteSwap(KdRegisters->BusOptions.all);
BusOptions.Pmc = false;
BusOptions.Bmc = false;
BusOptions.Isc = false;
BusOptions.Cmc = false;
BusOptions.Irmc = false;
BusOptions.g = 1;
Kd1394Data->CromBuffer[2] = Dbg1394_ByteSwap(BusOptions.all);
// 0xf000040c - global unique id hi
Kd1394Data->CromBuffer[3] = KdRegisters->GuidHi;
// 0xf0000410 - global unique id lo
Kd1394Data->CromBuffer[4] = KdRegisters->GuidLo;
// 0xf0000400 - config ROM header - set last to calculate CRC!
CONFIG_ROM_INFO ConfigRomHeader;
ConfigRomHeader.all = 0;
ConfigRomHeader.CRI_Info_Length = 4;
ConfigRomHeader.CRI_CRC_Length = 4;
ConfigRomHeader.CRI_CRC_Value = Dbg1394_CalculateCrc(&Kd1394Data->CromBuffer[1],
ConfigRomHeader.CRI_CRC_Length);
Kd1394Data->CromBuffer[0] = ConfigRomHeader.all;
Kd1394Data->CromBuffer[6] = 0xC083000C; // 0xf0000418 - node capabilities
Kd1394Data->CromBuffer[7] = 0xF2500003; // 0xf000041C - module vendor id
// KD's state machine looks for 1c w/ 50f2, 1d w/ 02, then 1e w/ address.
Kd1394Data->CromBuffer[8] = 0xF250001C; // 0xf0000420 - extended key (for KD)
Kd1394Data->CromBuffer[9] = 0x0200001D; // 0xf0000424 - debug key (for KD)
// 0xf0000428 - debug value (for KD)
IMMEDIATE_ENTRY CromEntry;
CromEntry.all = (UINT32)MmGetPhysicalAddress(&Kd1394Data->Config);
CromEntry.IE_Key = 0x1E;
Kd1394Data->CromBuffer[10] = Dbg1394_ByteSwap(CromEntry.all);
// 0xf0000414 - root directory header - set last to calculate CRC!
DIRECTORY_INFO DirectoryInfo;
DirectoryInfo.all = 0;
DirectoryInfo.DI_Length = 5;
DirectoryInfo.DI_CRC = Dbg1394_CalculateCrc(&Kd1394Data->CromBuffer[6],
DirectoryInfo.DI_Length);
Kd1394Data->CromBuffer[5] = Dbg1394_ByteSwap(DirectoryInfo.all);
// write the first few registers
KdRegisters->ConfigRomHeader.all = Kd1394Data->CromBuffer[0];
KdRegisters->BusId = Kd1394Data->CromBuffer[1];
KdRegisters->BusOptions.all = Kd1394Data->CromBuffer[2];
KdRegisters->GuidHi = Kd1394Data->CromBuffer[3];
KdRegisters->GuidLo = Kd1394Data->CromBuffer[4];
// set our crom
KdRegisters->ConfigRomMap = (UINT32)MmGetPhysicalAddress(&Kd1394Data->CromBuffer);
// disable all interrupts. wdm driver will enable them later - ??
KdRegisters->IntMaskClear.all = 0xFFFFFFFF;
// enable the link
HCControl.all = 0;
HCControl.LinkEnable = true;
KdRegisters->HCControlSet.all = HCControl.all;
Dbg1394_StallExecution(1000);
// enable access filters to all nodes
KdRegisters->AsynchReqFilterLoSet = 0xFFFFFFFF;
KdRegisters->AsynchReqFilterHiSet = 0xFFFFFFFF;
KdRegisters->PhyReqFilterHiSet = 0xFFFFFFFF;
KdRegisters->PhyReqFilterLoSet = 0xFFFFFFFF;
// hard reset on the bus (so KD will look for us)
PHY_CONTROL_REGISTER PhyControl;
PhyControl.all = 0;
PhyControl.RdReg = true;
PhyControl.RegAddr = 1;
KdRegisters->PhyControl.all = PhyControl.all;
retry = MAX_REGISTER_READS;
do {
PhyControl.all = KdRegisters->PhyControl.all;
} while ((!PhyControl.RdDone) && --retry);
if (retry == 0) {
kdprintf("1394: Read on bus failed\n");
return false;
}
UCHAR Data = ((UCHAR)PhyControl.RdData | PHY_INITIATE_BUS_RESET);
PhyControl.all = 0;
PhyControl.WrReg = true;
PhyControl.RegAddr = 1;
PhyControl.WrData = Data;
KDDBG2("1394: Writing to PhyControl=%08x\n", PhyControl.all);
KdRegisters->PhyControl.all = PhyControl.all;
retry = MAX_REGISTER_READS;
do {
PhyControl.all = KdRegisters->PhyControl.all;
} while (PhyControl.WrReg && --retry);
if (retry == 0) {
kdprintf("1394: Hard reset on bus failed\n");
return false;
}
kdprintf("1394: Init Succeeded\n");
return true;
}
static void Dbg1394_EnablePhysicalAccess()
{
// see if ohci1394 is being loaded...
HC_CONTROL_REGISTER HCControl;
HCControl.all = KdRegisters->HCControlSet.all;
if (!HCControl.LinkEnable || !HCControl.Lps || HCControl.SoftReset) {
KDDBG("1394: EnablePhysicalAccess HCControl=%08x!\n", HCControl.all);
return;
}
// if the bus reset interrupt is not cleared, we have to clear it...
INT_EVENT_MASK_REGISTER IntEvent;
IntEvent.all = KdRegisters->IntEventSet.all;
if (IntEvent.BusReset) {
KDDBG("1394: EnablePhysicalAccess IntEvent =%08x!\n", IntEvent.all);
IntEvent.all = 0;
IntEvent.BusReset = 1;
KdRegisters->IntEventClear.all = IntEvent.all;
}
// we might need to re-enable physical access. If so, do it.
KdRegisters->AsynchReqFilterHiSet = 0xFFFFFFFF;
KdRegisters->AsynchReqFilterLoSet = 0xFFFFFFFF;
KdRegisters->PhyReqFilterHiSet = 0xFFFFFFFF;
KdRegisters->PhyReqFilterLoSet = 0xFFFFFFFF;
}
static KDP_STATUS
Dbg1394_ReadPacket(
OUT PKD_PACKET PacketHeader,
OUT PSTRING MessageHeader,
OUT PSTRING MessageData,
bool Wait
)
// KDP_PACKET_RESEND - if resend is required. = 2 = CP_GET_ERROR
// KDP_PACKET_TIMEOUT - if timeout. = 1 = CP_GET_NODATA
// KDP_PACKET_RECEIVED - if packet received. = 0 = CP_GET_SUCCESS
{
UINT32 timeoutLimit = 0;
do {
// make sure our link is enabled..
Dbg1394_EnablePhysicalAccess();
KdpSpin();
if (Kd1394Data->ReceivePacket.TransferStatus == STATUS_PENDING) {
KdDebuggerNotPresent = false;
memcpy(PacketHeader,
&Kd1394Data->ReceivePacket.Packet[0],
sizeof(KD_PACKET));
// make sure we have a valid PacketHeader
if (Kd1394Data->ReceivePacket.Length < sizeof(KD_PACKET)) {
// short packet, we are done...
Kd1394Data->ReceivePacket.TransferStatus = STATUS_SUCCESS;
return(KDP_PACKET_RESEND);
}
if (MessageHeader) {
memcpy(MessageHeader->Buffer,
&Kd1394Data->ReceivePacket.Packet[sizeof(KD_PACKET)],
MessageHeader->MaximumLength);
if (Kd1394Data->ReceivePacket.Length <= (UINT16)(sizeof(KD_PACKET)+MessageHeader->MaximumLength)) {
Kd1394Data->ReceivePacket.TransferStatus = STATUS_SUCCESS;
return(KDP_PACKET_RECEIVED);
}
if (MessageData) {
memcpy(MessageData->Buffer,
&Kd1394Data->ReceivePacket.Packet[sizeof(KD_PACKET) + MessageHeader->MaximumLength],
Kd1394Data->ReceivePacket.Length - (sizeof(KD_PACKET) + MessageHeader->MaximumLength));
}
}
Kd1394Data->ReceivePacket.TransferStatus = STATUS_SUCCESS;
return(KDP_PACKET_RECEIVED);
}
timeoutLimit++;
if (Wait == false) {
return(KDP_PACKET_RESEND);
}
} while (timeoutLimit <= TIMEOUT_COUNT);
return(KDP_PACKET_TIMEOUT);
}
//
// Send a control packet to the host machine that is running the
// kernel debugger and wait for an ACK.
//
// PacketType - Supplies the type of packet to send.
//
static void KdpSendControlPacket(IN UINT16 PacketType)
{
KD_PACKET PacketHeader;
//
// Initialize and send the packet header.
//
PacketHeader.PacketLeader = CONTROL_PACKET_LEADER;
PacketHeader.PacketId = 0;
PacketHeader.ByteCount = 0;
PacketHeader.Checksum = 0;
PacketHeader.PacketType = PacketType;
// setup our send packet
memset(&Kd1394Data->SendPacket, 0, sizeof(DEBUG_1394_SEND_PACKET));
Kd1394Data->SendPacket.Length = 0;
memcpy(&Kd1394Data->SendPacket.PacketHeader[0],
&PacketHeader, sizeof(KD_PACKET));
Kd1394Data->SendPacket.TransferStatus = STATUS_PENDING;
}
KDP_STATUS
Kdp1394ReceivePacket(
IN UINT32 PacketType,
OUT PSTRING MessageHeader,
OUT PSTRING MessageData,
OUT UINT32 * DataLength,
IN OUT PKD_CONTEXT KdContext
)
// Routine Description:
// This routine receives a packet from the host machine that is running
// the kernel debugger UI. This routine is ALWAYS called after packet being
// sent by caller. It first waits for ACK packet for the packet sent and
// then waits for the packet desired.
//
// N.B. If caller is KdPrintString, the parameter PacketType is
// PACKET_TYPE_KD_ACKNOWLEDGE. In this case, this routine will return
// right after the ack packet is received.
//
// Arguments:
// PacketType - Supplies the type of packet that is excepted.
// MessageHeader - Supplies a pointer to a string descriptor for the input
// message.
// MessageData - Supplies a pointer to a string descriptor for the input data.
// DataLength - Supplies pointer to UINT32 to receive length of recv. data.
// KdContext - Supplies a pointer to the kernel debugger context.
//
// Return Value:
// KDP_PACKET_RESEND - if resend is required. = 2 = CP_GET_ERROR
// KDP_PACKET_TIMEOUT - if timeout. = 1 = CP_GET_NODATA
// KDP_PACKET_RECEIVED - if packet received. = 0 = CP_GET_SUCCESS
{
UINT32 MessageLength;
KD_PACKET PacketHeader;
KDP_STATUS ReturnCode;
UINT32 Checksum;
KDDBG2("Kdp1394ReceivePacket\n");
// this dispatch gets called with PacketType != PACKET_TYPE_KD_POLL_BREAKIN for
// the number of times specified in KdCompNumberRetries (??).
WaitForPacketLeader:
// read in our packet, if available...
ReturnCode = Dbg1394_ReadPacket(&PacketHeader,
MessageHeader,
MessageData,
true);
//
// If we can successfully read packet leader, it has high possibility that
// kernel debugger is alive. So reset count.
//
if (ReturnCode != KDP_PACKET_TIMEOUT) {
KdCompNumberRetries = KdCompRetryCount;
}
if (ReturnCode != KDP_PACKET_RECEIVED) {
// see if it's a breakin packet...
if ((PacketHeader.PacketLeader & 0xFF) == BREAKIN_PACKET_BYTE) {
KdContext->KdpControlCPending = true;
return(KDP_PACKET_RESEND);
}
return(ReturnCode);
}
//
// if the packet we received is a resend request, we return true and
// let caller resend the packet.
//
if (PacketHeader.PacketLeader == CONTROL_PACKET_LEADER &&
PacketHeader.PacketType == PACKET_TYPE_KD_RESEND) {
return(KDP_PACKET_RESEND);
}
//
// Check ByteCount received is valid
//
MessageLength = MessageHeader->MaximumLength;
if ((PacketHeader.ByteCount > (UINT16)PACKET_MAX_SIZE) ||
(PacketHeader.ByteCount < (UINT16)MessageLength)) {
goto SendResendPacket;
}
*DataLength = PacketHeader.ByteCount - MessageLength;
MessageData->Length = (UINT16)*DataLength;
MessageHeader->Length = (UINT16)MessageLength;
//
// Check PacketType is what we are waiting for.
//
if (PacketType != PacketHeader.PacketType) {
goto SendResendPacket;
}
//
// Check checksum is valid.
//
Checksum = KdpComputeChecksum(MessageHeader->Buffer, MessageHeader->Length);
Checksum += KdpComputeChecksum(MessageData->Buffer, MessageData->Length);
if (Checksum != PacketHeader.Checksum) {
goto SendResendPacket;
}
return(KDP_PACKET_RECEIVED);
SendResendPacket:
KdpSendControlPacket(PACKET_TYPE_KD_RESEND);
goto WaitForPacketLeader;
}
void
Kdp1394SendPacket(
IN UINT32 PacketType,
IN PSTRING MessageHeader,
IN PSTRING MessageData OPTIONAL,
IN OUT PKD_CONTEXT KdContext
)
// Routine Description:
// This routine sends a packet to the host machine that is running the
// kernel debugger and waits for an ACK.
//
// Arguments:
// PacketType - Supplies the type of packet to send.
// MessageHeader - Supplies a pointer to a string descriptor that describes
// the message information.
// MessageData - Supplies a pointer to a string descriptor that describes
// the optional message data.
// KdContext - Supplies a pointer to the kernel debugger context.
//
// Return Value:
// None.
{
KD_PACKET PacketHeader;
UINT32 MessageDataLength;
UINT32 ReturnCode;
bool bException = false;
KDDBG2("Kdp1394SendPacket\n");
PacketHeader.Checksum = 0;
if (MessageData != NULL) {
MessageDataLength = MessageData->Length;
PacketHeader.Checksum = KdpComputeChecksum(MessageData->Buffer, MessageData->Length);
}
else {
MessageDataLength = 0;
PacketHeader.Checksum = 0;
}
PacketHeader.Checksum += KdpComputeChecksum(MessageHeader->Buffer, MessageHeader->Length);
//
// Initialize and send the packet header.
//
PacketHeader.PacketLeader = PACKET_LEADER;
PacketHeader.ByteCount = (UINT16)(MessageHeader->Length + MessageDataLength);
PacketHeader.PacketType = (UINT16)PacketType;
PacketHeader.PacketId = KdPacketId;
KdPacketId++;
KdCompNumberRetries = KdCompRetryCount;
// setup our send packet
memset(&Kd1394Data->SendPacket, 0, sizeof(DEBUG_1394_SEND_PACKET));
Kd1394Data->SendPacket.Length = 0;
// copy our packet header...
memcpy(&Kd1394Data->SendPacket.PacketHeader[0],
&PacketHeader, sizeof(KD_PACKET));
// setup our message header
if (MessageHeader) {
memcpy(&Kd1394Data->SendPacket.Packet[0],
MessageHeader->Buffer, MessageHeader->Length);
Kd1394Data->SendPacket.Length += MessageHeader->Length;
}
// setup our message data
if (MessageData != NULL) {
memcpy(&Kd1394Data->SendPacket.Packet[Kd1394Data->SendPacket.Length],
MessageData->Buffer, MessageData->Length);
Kd1394Data->SendPacket.Length += MessageData->Length;
}
Kd1394Data->SendPacket.TransferStatus = STATUS_PENDING;
//
// We sync on first STATE_CHANGE64 message like NT. If this
// is the first such message, drain receive pipe as nothing
// said before this instant is interesting (and any buffered
// packets may interact badly with SendWaitContinue).
//
if (PacketType == PACKET_TYPE_KD_STATE_CHANGE64 /* && !KdStateChange64Sent*/) {
// need to do this to fix pre-logging (eventually).
#if 0
UCHAR uDummy;
uint32 dwDrained = 0;
KdCompNextPacketIdToSend |= SYNC_PACKET_ID;
KdStateChange64Sent = true;
while (KdCompGetByte(&uDummy) == CP_GET_SUCCESS) {
dwDrained++;
}
#endif // 0
}
do {
KDDBG2("LOOP %d/%d [SendPacket=%p %08x %08x %08x %02x %02x %02x %02x]\n",
KdCompNumberRetries, KdCompRetryCount,
&Kd1394Data->SendPacket,
Kd1394Data->SendPacket.TransferStatus,
*(UINT32*)&Kd1394Data->SendPacket.PacketHeader,
Kd1394Data->SendPacket.Length,
Kd1394Data->SendPacket.Packet[0],
Kd1394Data->SendPacket.Packet[1],
Kd1394Data->SendPacket.Packet[2],
Kd1394Data->SendPacket.Packet[3]);
// make sure our link is enabled..
Dbg1394_EnablePhysicalAccess();
if (KdCompNumberRetries == 0) {
//
// If the packet is not for reporting exception, we give up
// and declare debugger not present.
//
if (PacketType == PACKET_TYPE_KD_DEBUG_IO) {
PDBGKD_DEBUG_IO DebugIo
= (PDBGKD_DEBUG_IO)MessageHeader->Buffer;
if (DebugIo->ApiNumber == DbgKdPrintStringApi) {
KdDebuggerNotPresent = true;
Kd1394Data->SendPacket.TransferStatus = STATUS_SUCCESS;
return;
}
}
else if (PacketType == PACKET_TYPE_KD_STATE_CHANGE64) {
PDBGKD_ANY_WAIT_STATE_CHANGE StateChange
= (PDBGKD_ANY_WAIT_STATE_CHANGE)MessageHeader->Buffer;
if (StateChange->NewState == DbgKdLoadSymbolsStateChange) {
KdDebuggerNotPresent = true;
Kd1394Data->SendPacket.TransferStatus = STATUS_SUCCESS;
return;
}
}
else if (PacketType == PACKET_TYPE_KD_FILE_IO) {
PDBGKD_FILE_IO FileIo
= (PDBGKD_FILE_IO)MessageHeader->Buffer;
if (FileIo->ApiNumber == DbgKdCreateFileApi) {
KdDebuggerNotPresent = true;
Kd1394Data->SendPacket.TransferStatus = STATUS_SUCCESS;
return;
}
}
else {
bException = true;
}
}
ReturnCode = KDP_PACKET_TIMEOUT;
{
UINT32 count = 0;
volatile NTSTATUS *pStatus;
pStatus = &Kd1394Data->ReceivePacket.TransferStatus;
//
// now sit here and poll for a response from the host machine
//
do {
// make sure our link is enabled..
Dbg1394_EnablePhysicalAccess();
KdpSpin();
//
// while in this loop check if the host has submitted a new request.
// If they did, abort processing of the current request.
//
count++;
if (Kd1394Data->SendPacket.TransferStatus != STATUS_PENDING) {
ReturnCode = KDP_PACKET_RECEIVED;
break;
}
if ((*pStatus == STATUS_PENDING) && (!bException)) {
ReturnCode = KDP_PACKET_RECEIVED;
break;
}
} while (count < TIMEOUT_COUNT);
}
if (ReturnCode == KDP_PACKET_TIMEOUT) {
KdCompNumberRetries--;
}
} while (ReturnCode != KDP_PACKET_RECEIVED);
//
// Since we are able to talk to debugger, the retrycount is set to
// maximum value.
//
KdCompRetryCount = KdContext->KdpDefaultRetries;
}
// Returns true if a breakin packet is pending.
// A packet is present if: There is a valid character which matches BREAK_CHAR.
bool Kdp1394PollBreakIn(void)
{
KDDBG2("Kdp1394PollBreakIn\n");
// make sure our link is enabled..
Dbg1394_EnablePhysicalAccess();
// let's peak into our receive packet and see if it's a breakin
if ((Kd1394Data->ReceivePacket.TransferStatus == STATUS_PENDING) &&
(Kd1394Data->ReceivePacket.Packet[0] == BREAKIN_PACKET_BYTE)) {
KdDebuggerNotPresent = false;
// we have a breakin packet
Kd1394Data->ReceivePacket.TransferStatus = STATUS_SUCCESS;
return true;
}
return false;
}
//
///////////////////////////////////////////////////////////////// End of File.
Reference in New Issue View Git Blame Copy Permalink