📄 main.c
字号:
// Parse to get size (byte, word, dword) - optional
eToken = LexGetNextToken();
eDataSize = sg_eDatasize;
if (LEX_BYTE == eToken || LEX_WORD == eToken || LEX_DWORD == eToken)
{
eDataSize = eToken;
eToken = LexGetNextToken();
}
if (eToken != LEX_CONSTANT)
{
EdbgOutputDebugString("Read address expected\r\n");
return(0);
}
if (LEX_BYTE == eDataSize)
{
pu8Pointer = (UINT8 *) sg_u32Constant;
u32Data = (UINT32) *pu8Pointer;
}
if (LEX_WORD == eDataSize)
{
pu16Pointer = (UINT16 *) sg_u32Constant;
u32Data = (UINT32) *pu16Pointer;
}
if (LEX_DWORD == eDataSize)
{
pu32Pointer = (UINT32 *) sg_u32Constant;
u32Data = *pu32Pointer;
}
u32Start = sg_u32Constant;
// Now see if there's a length, too
eToken = LexGetNextToken();
if (LEX_CONSTANT == eToken)
{
u32Length = sg_u32Constant;
}
u32End = u32Start + u32Length;
EdbgOutputDebugString("Dumping from %x to %x\r\n", u32Start, u32End - 1);
while (u32Start < u32End)
{
if (OEMReadDebugByte() == 0x03)
{
EdbgOutputDebugString("^C\r\n");
return(0);
}
EdbgOutputDebugString("%x: ", u32Start);
if (LEX_BYTE == eDataSize)
{
for (u8Loop = 0; u8Loop < 16; u8Loop++)
{
PrintHexValue(*pu8Pointer++, 8);
EdbgOutputDebugString(" ");
}
}
if (LEX_WORD == eDataSize)
{
for (u8Loop = 0; u8Loop < 8; u8Loop++)
{
PrintHexValue(*pu16Pointer++, 16);
EdbgOutputDebugString(" ");
}
}
if (LEX_DWORD == eDataSize)
{
for (u8Loop = 0; u8Loop < 4; u8Loop++)
{
PrintHexValue(*pu32Pointer++, 32);
EdbgOutputDebugString(" ");
}
}
EdbgOutputDebugString("\r\n");
u32Start += 16;
}
return(0);
}
static UINT32 DataSize(void)
{
ELex eDataSize;
eDataSize = LexGetNextToken();
if (eDataSize != LEX_BYTE && eDataSize != LEX_WORD && eDataSize != LEX_DWORD)
{
EdbgOutputDebugString("Datasize command expects 'byte', 'word', or 'dword'\r\n");
return(0);
}
sg_eDatasize = eDataSize;
EdbgOutputDebugString("Default data size set to ");
if (LEX_BYTE == sg_eDatasize)
{
EdbgOutputDebugString("BYTE\r\n");
}
if (LEX_WORD == sg_eDatasize)
{
EdbgOutputDebugString("WORD\r\n");
}
if (LEX_DWORD == sg_eDatasize)
{
EdbgOutputDebugString("DWORD\r\n");
}
return(0);
}
static UINT32 WriteRead(void)
{
ELex eDataSize;
volatile UINT8 *pu8Pointer;
volatile UINT16 *pu16Pointer;
volatile UINT32 *pu32Pointer;
UINT32 u32Address;
UINT32 u32Data;
BOOL bResult;
// Parse to get size (byte, word, dword)
bResult = ParseForAddressAndData(&eDataSize,
&u32Address,
&u32Data,
TRUE);
if (FALSE == bResult)
{
return(0);
}
// We know our size! Let's get our address.
if (LEX_BYTE == eDataSize)
{
pu8Pointer = (UINT8 *) u32Address;
}
if (LEX_WORD == eDataSize)
{
pu16Pointer = (UINT16 *) u32Address;
}
if (LEX_DWORD == eDataSize)
{
pu32Pointer = (UINT32 *) u32Address;
}
// Check data sizes
if (LEX_BYTE == eDataSize && u32Data > 0xff)
{
EdbgOutputDebugString(">8 Bit value cannot be written in a byte transaction\r\n");
return(0);
}
if (LEX_WORD == eDataSize && u32Data > 0xffff)
{
EdbgOutputDebugString(">16 Bit value cannot be written to a word transaction\r\n");
return(0);
}
// Now go write the data!
if (LEX_BYTE == eDataSize)
{
*pu8Pointer = (UINT8) u32Data;
}
if (LEX_WORD == eDataSize)
{
*pu16Pointer = (UINT16) u32Data;
}
if (LEX_DWORD == eDataSize)
{
*pu32Pointer = u32Data;
}
EdbgOutputDebugString("Write @ 0x%x=", u32Address);
// Now go read the data
if (LEX_BYTE == eDataSize)
{
PrintHexValue(*pu8Pointer, 8);
}
if (LEX_WORD == eDataSize)
{
PrintHexValue(*pu16Pointer, 16);
}
if (LEX_DWORD == eDataSize)
{
PrintHexValue(*pu32Pointer, 32);
}
EdbgOutputDebugString(", Read=");
// Now go read the data
if (LEX_BYTE == eDataSize)
{
u32Data = *pu8Pointer;
}
if (LEX_WORD == eDataSize)
{
u32Data = *pu16Pointer;
}
if (LEX_DWORD == eDataSize)
{
u32Data = *pu32Pointer;
}
// Now go read the data
if (LEX_BYTE == eDataSize)
{
PrintHexValue(u32Data, 8);
}
if (LEX_WORD == eDataSize)
{
PrintHexValue(u32Data, 16);
}
if (LEX_DWORD == eDataSize)
{
PrintHexValue(u32Data, 32);
}
EdbgOutputDebugString("\r\n");
return(0);
}
static UINT32 Map(void)
{
UINT32 u32Loop = 0;
UINT32 BOOT_FLASH_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(MAINSTONEII_BASE_PA_BOOT_FLASH);
UINT32 SECONDARY_FLASH_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(MAINSTONEII_BASE_PA_SECONDARY_FLASH);
UINT32 SDRAM_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(MAINSTONEII_BASE_PA_SDRAM);
UINT32 SMSC_ETHERNET_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(MAINSTONEII_BASE_REG_PA_SMSC_ETHERNET);
UINT32 FPGA_REGS_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(MAINSTONEII_BASE_REG_PA_FPGA);
UINT32 SRAM_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(MAINSTONEII_BASE_PA_SRAM);
UINT32 MARATHON_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BERRYDALE_BASE_PA_MARATHON);
UINT32 IM_STORAGE_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_IMSTORAGE);
UINT32 IM_CONTROL_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_IMCONTROL);
UINT32 USBH_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_USBH);
UINT32 MEMC_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_MEMC);
UINT32 LCD_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_LCD);
UINT32 PERIF_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PERIPH);
UINT32 PCMCIA_S1_CMN_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PCMCIA_S1_CMN);
UINT32 PCMCIA_S1_ATTR_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PCMCIA_S1_ATTR);
UINT32 PCMCIA_S1_IO_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PCMCIA_S1_IO);
UINT32 PCMCIA_S0_CMN_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PCMCIA_S0_CMN);
UINT32 PCMCIA_S0_ATTR_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PCMCIA_S0_ATTR);
UINT32 PCMCIA_S0_IO_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_PCMCIA_S0_IO);
UINT32 CMRA_BASE_C_VIRTUAL = (UINT32)OALPAtoCA(BULVERDE_BASE_REG_PA_CAMERA);
struct SRegionName *psRegion;
struct SRegionName sg_sRegions[] =
{
{BOOT_FLASH_BASE_C_VIRTUAL, "Primary boot flash"},
{SECONDARY_FLASH_BASE_C_VIRTUAL, "Secondary flash"},
{SDRAM_BASE_C_VIRTUAL, "SDRAM Region"},
{SMSC_ETHERNET_BASE_C_VIRTUAL, "Ethernet"},
{FPGA_REGS_BASE_C_VIRTUAL, "Mainstone/Berrydale FPGA - CS2 upper"},
{SRAM_BASE_C_VIRTUAL, "SRAM Region - CS2 lower"},
{MARATHON_BASE_C_VIRTUAL, "Marathon"},
{IM_STORAGE_BASE_C_VIRTUAL, "Internal memory storage"},
{IM_CONTROL_BASE_C_VIRTUAL, "Internal memory control"},
{USBH_BASE_C_VIRTUAL, "USB Host"},
{MEMC_BASE_C_VIRTUAL, "Memory controller"},
{LCD_BASE_C_VIRTUAL, "LCD"},
{PERIF_BASE_C_VIRTUAL, "Memory mapped registers (periph)"},
{PCMCIA_S1_CMN_C_VIRTUAL, "PCMCIA S1 Common memory"},
{PCMCIA_S1_ATTR_C_VIRTUAL, "PCMCIA S1 Attributes"},
{PCMCIA_S1_IO_C_VIRTUAL, "PCMCIA S1 I/O Space"},
{PCMCIA_S0_CMN_C_VIRTUAL, "PCMCIA S0 Common memory"},
{PCMCIA_S0_ATTR_C_VIRTUAL, "PCMCIA S0 Attributes"},
{PCMCIA_S0_IO_C_VIRTUAL, "PCMCIA S0 I/O Space"},
{ZBANK_BASE_C_VIRTUAL, "Zero bank"},
{CMRA_BASE_C_VIRTUAL, "Camera"},
{0, NULL}
};
EdbgOutputDebugString("Virtual addr Virtual addr Physical addr Size\r\n");
EdbgOutputDebugString(" cached uncached\r\n");
while (g_oalAddressTable[u32Loop].CA)
{
EdbgOutputDebugString(" 0x%x 0x%x 0x", g_oalAddressTable[u32Loop].CA,
OALCAtoUA(g_oalAddressTable[u32Loop].CA));
PrintHexValue(g_oalAddressTable[u32Loop].PA, 32);
EdbgOutputDebugString(" %d ", g_oalAddressTable[u32Loop].size);
if (g_oalAddressTable[u32Loop].size < 10)
{
EdbgOutputDebugString(" ");
}
psRegion = sg_sRegions;
while (psRegion->pu8TextName)
{
if (psRegion->u32CachedAddress == g_oalAddressTable[u32Loop].CA)
{
EdbgOutputDebugString("(%s)", psRegion->pu8TextName);
break;
}
++psRegion;
}
if (NULL == psRegion->pu8TextName)
{
EdbgOutputDebugString("ERROR - C/ASM OUT OF SYNC!!!");
}
EdbgOutputDebugString("\r\n");
u32Loop++ ;
}
return(0);
}
static UINT32 Comment(void)
{
return(0);
}
static UINT32 Fill(void)
{
ELex eDataSize;
ELex eToken;
volatile UINT8 *pu8Pointer;
volatile UINT16 *pu16Pointer;
volatile UINT32 *pu32Pointer;
UINT32 u32Address;
UINT32 u32Data;
UINT32 u32Length;
BOOL bResult;
// Parse to get size (byte, word, dword)
bResult = ParseForAddressAndData(&eDataSize,
&u32Address,
&u32Data,
TRUE);
if (FALSE == bResult)
{
return(0);
}
// We know our size! Let's get our address.
if (LEX_BYTE == eDataSize)
{
pu8Pointer = (UINT8 *) u32Address;
}
if (LEX_WORD == eDataSize)
{
pu16Pointer = (UINT16 *) u32Address;
}
if (LEX_DWORD == eDataSize)
{
pu32Pointer = (UINT32 *) u32Address;
}
// Check data sizes
if (LEX_BYTE == eDataSize && u32Data > 0xff)
{
EdbgOutputDebugString(">8 Bit value cannot be written in a byte transaction\r\n");
return(0);
}
if (LEX_WORD == eDataSize && u32Data > 0xffff)
{
EdbgOutputDebugString(">16 Bit value cannot be written to a word transaction\r\n");
return(0);
}
// Get # of bytes to write
eToken = LexGetNextToken();
if (eToken != LEX_CONSTANT)
{
EdbgOutputDebugString("Constant expected for length (in bytes)\r\n");
return(0);
}
u32Length = sg_u32Constant;
EdbgOutputDebugString("Filling address 0x%x-0x%x with 0x", u32Address, (u32Address + u32Length - 1));
if (LEX_BYTE == eDataSize)
{
PrintHexValue(u32Data, 8);
}
if (LEX_WORD == eDataSize)
{
PrintHexValue(u32Data, 16);
}
if (LEX_DWORD == eDataSize)
{
PrintHexValue(u32Data, 32);
}
EdbgOutputDebugString(" for 0x%x bytes: ", u32Length);
if (LEX_WORD == eDataSize)
{
u32Length >>= 1;
*pu16Pointer++ = (UINT16) u32Data;
}
if (LEX_DWORD == eDataSize)
{
u32Length >>= 2;
*pu32Pointer++ = u32Data;
}
// Length is in # of transactions, not bytes
while (u32Length)
{
// Now go write the data!
if (LEX_BYTE == eDataSize)
{
*pu8Pointer++ = (UINT8) u32Data;
}
if (LEX_WORD == eDataSize)
{
*pu16Pointer++ = (UINT16) u32Data;
}
if (LEX_DWORD == eDataSize)
{
*pu32Pointer++ = u32Data;
}
u32Length--;
}
EdbgOutputDebugString("Done!\r\n");
return(0);
}
static struct SCommandEntry sg_sCommands[] =
{
{LEX_WRITE, WriteData},
{LEX_READ, ReadData},
{LEX_EXIT, ExitDebugger},
{LEX_DUMP, Dump},
{(ELex) '?', Help},
{LEX_DATASIZE, DataSize},
{LEX_WRITEREAD, WriteRead},
{LEX_MAP, Map},
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -