?? main.c
字號:
if (g_dwMinImageStart == 0)
{
EdbgOutputDebugString("WARNING: OEMMultiBINNotify: Bad start address for region (%d).\r\n", nCount);
return;
}
}
}
memcpy((LPBYTE)&g_BINRegionInfo, (LPBYTE)pInfo, sizeof(MultiBINInfo));
}
BOOL OEMCheckSignature(DWORD dwImageStart, DWORD dwROMOffset, DWORD dwLaunchAddr, BOOL bDownloaded)
{
if(gbStoreSDRAMImageToFlash){
gdwSavedPhysStart = dwImageStart;
gdwSaveLaunchAddr = dwLaunchAddr;
}
return TRUE;
}
//------------------------------------------------------------------------------
// Function: OEMDebugInit
//
// Callback to initialized debug transport
//
BOOL OEMDebugInit( void )
{
InitDebugSerial();
// Initialize function pointers
g_pOEMVerifyMemory = OEMVerifyMemory;
g_pOEMMultiBINNotify = OEMMultiBINNotify;
g_pOEMCheckSignature = OEMCheckSignature;
// Indicate success
return( TRUE );
}
//------------------------------------------------------------------------------
// Function: OEMReadData
//
// Reads data from transport.
//
BOOL OEMReadData( DWORD cbData, LPBYTE pbData )
{
return pfnReadData (cbData, pbData);
}
//------------------------------------------------------------------------------
// Function: AskUser
//
// Ask user to select transport options.
//
BOOL AskUser (EDBG_ADDR *pMyAddr, DWORD *pdwSubnetMask)
{
static char szbuf[IPADDR_MAX+1];
EdbgOutputDebugString ("Hit ENTER within 5 seconds to enter static IP address!");
szbuf[IPADDR_MAX] = 0; // for safe measure, make sure null termination
if( !ReadIPLine (szbuf, 5) )
{
return FALSE;
}
EdbgOutputDebugString ("Enter IP address, or CR for default (%s): ", inet_ntoa (pMyAddr->dwIP));
ReadIPLine (szbuf, INFINITE);
if( szbuf[0] )
{
pMyAddr->dwIP = inet_addr (szbuf);
}
EdbgOutputDebugString ("Enter Subnet Masks, or CR for default (%s): ", inet_ntoa (*pdwSubnetMask));
ReadIPLine (szbuf, INFINITE);
if( szbuf[0] )
{
*pdwSubnetMask = inet_addr (szbuf);
}
EdbgOutputDebugString ( "\r\nUsing IP Address %s, ", inet_ntoa (pMyAddr->dwIP));
EdbgOutputDebugString ( "subnet mask %s\r\n", inet_ntoa (*pdwSubnetMask));
return TRUE;
}
//------------------------------------------------------------------------------
// Function: ReadIPLine
//
// Read a line from the debug port. Returns FALSE if times out. Timeout
// value is in seconds.
//
static BOOL ReadIPLine (char *pbuf, DWORD dwTimeout)
{
DWORD dwCurrSec = OEMEthGetSecs ();
char ch;
int nLen = 0;
while( OEMEthGetSecs () - dwCurrSec < dwTimeout )
{
switch( ch = OEMReadDebugByte () )
{
case OEM_DEBUG_COM_ERROR:
case OEM_DEBUG_READ_NODATA:
// no data or error, keep reading
break;
case BACKSPACE:
nLen --;
OEMWriteDebugByte (ch);
break;
case '\r':
case '\n':
OEMWriteDebugByte ('\n');
pbuf[nLen] = 0;
return( TRUE );
default:
if( (ch == '.' || (ch >= '0' && ch <= '9')) && (nLen < IPADDR_MAX) )
{
pbuf[nLen ++] = ch;
OEMWriteDebugByte (ch);
}
}
}
return( FALSE ); // timeout
}
void OEMShowProgress (DWORD dwPacketNum)
{
DisplayNumLED(dwPacketNum);
}
static void DisplayLED(CHAR *data)
{
volatile char *pAlphaLED;
int i;
pAlphaLED = (volatile char*)LED_ALPHA;
i = 0;
while (i < 8 && *data != '\0') {
*pAlphaLED++ = *data++;
*pAlphaLED++; // byte size registers allocated in word space
i++;
}
}
static void DisplayNumLED(DWORD data)
{
volatile char *pAlphaLED;
int i;
char c;
pAlphaLED = (volatile char*)LED_ALPHA;
for (i = 7; i >= 0; i--) {
c = (char)((data >> i * 4) & 0x0f);
if (c < 10) c += '0'; // '0' - '9'
else c += 'A' - 10; // 'A' - 'F'
*pAlphaLED++ = c;
*pAlphaLED++; // byte size registers allocated in word space
}
}
void SC_WriteDebugLED (WORD wIndex, DWORD dwPattern)
{
}
static void DUMPREG_PMSR()
{
ULONG uTemp;
uTemp = READ_REGISTER_ULONG (VCRSYS_PMSR1);
EdbgOutputDebugString("PMSR1: 0x%X / 0x%X\r\n", VCRSYS_PMSR1, uTemp);
uTemp = READ_REGISTER_ULONG (VCRSYS_PMSR2);
EdbgOutputDebugString("PMSR2: 0x%X / 0x%X\r\n", VCRSYS_PMSR2, uTemp);
uTemp = READ_REGISTER_ULONG (VCRSYS_PMSR3);
EdbgOutputDebugString("PMSR3: 0x%X / 0x%X\r\n", VCRSYS_PMSR3, uTemp);
uTemp = READ_REGISTER_ULONG (VCRSYS_PMSR4);
EdbgOutputDebugString("PMSR4: 0x%X / 0x%X\r\n", VCRSYS_PMSR4, uTemp);
uTemp = READ_REGISTER_ULONG (VCRSYS_PMSRG);
EdbgOutputDebugString("PMSRG: 0x%X / 0x%X\r\n", VCRSYS_PMSRG, uTemp);
return;
}
static void DUMPREG_FRQCR()
{
// ULONG ulBBGVCR0, ulBBGVCR1;
// ulBBGVCR0 = READ_REGISTER_ULONG (BBGVCR0);
// ulBBGVCR1 = READ_REGISTER_ULONG (BBGVCR1);
// EdbgOutputDebugString("BBGVCR0:0x%X\r\n", ulBBGVCR0);
// EdbgOutputDebugString("BBGVCR1:0x%X\r\n", ulBBGVCR1);
return;
}
static void DUMPREG_BUSBRIDGE()
{
ULONG ulBBGVCR0, ulBBGVCR1;
ulBBGVCR0 = READ_REGISTER_ULONG (VCRSYS_BBGVCR0);
ulBBGVCR1 = READ_REGISTER_ULONG (VCRSYS_BBGVCR1);
EdbgOutputDebugString("BBGVCR0:0x%X\r\n", ulBBGVCR0);
EdbgOutputDebugString("BBGVCR1:0x%X\r\n", ulBBGVCR1);
return;
}
static void DUMPREG_BUSBRIDGE_BSC()
{
ULONG uTemp;
uTemp = READ_REGISTER_ULONG (BSC_CS0CTRL);
EdbgOutputDebugString("CS0CTRL: 0x%X / 0x%X\r\n", BSC_CS0CTRL, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_CS1CTRL);
EdbgOutputDebugString("CS1CTRL: 0x%X / 0x%X\r\n", BSC_CS1CTRL, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECS0CTRL);
EdbgOutputDebugString("ECS0CTRL: 0x%X / 0x%X\r\n", BSC_ECS0CTRL, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECS1CTRL);
EdbgOutputDebugString("ECS1CTRL: 0x%X / 0x%X\r\n", BSC_ECS1CTRL, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECS2CTRL);
EdbgOutputDebugString("ECS2CTRL: 0x%X / 0x%X\r\n", BSC_ECS2CTRL, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_EXWTSYNC);
EdbgOutputDebugString("EXWTSYNC: 0x%X / 0x%X\r\n", BSC_EXWTSYNC, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_CSPWCR0);
EdbgOutputDebugString("CSPWCR0: 0x%X / 0x%X\r\n", BSC_CSPWCR0, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_CSPWCR1);
EdbgOutputDebugString("CSPWCR1: 0x%X / 0x%X\r\n", BSC_CSPWCR1, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECSPWCR0);
EdbgOutputDebugString("ECSPWCR0: 0x%X / 0x%X\r\n", BSC_ECSPWCR0, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECSPWCR1);
EdbgOutputDebugString("ECSPWCR1: 0x%X / 0x%X\r\n", BSC_ECSPWCR1, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECSPWCR2);
EdbgOutputDebugString("ECSPWCR2: 0x%X / 0x%X\r\n", BSC_ECSPWCR2, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_CS1GDST);
EdbgOutputDebugString("CS1GDST: 0x%X / 0x%X\r\n", BSC_CS1GDST, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECS0GDST);
EdbgOutputDebugString("ECS0GDST: 0x%X / 0x%X\r\n", BSC_ECS0GDST, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECS1GDST);
EdbgOutputDebugString("ECS1GDST: 0x%X / 0x%X\r\n", BSC_ECS1GDST, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECS2GDST);
EdbgOutputDebugString("ECS2GDST: 0x%X / 0x%X\r\n", BSC_ECS2GDST, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_CSWCR0);
EdbgOutputDebugString("CSWCR0: 0x%X / 0x%X\r\n", BSC_CSWCR0, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_CSWCR1);
EdbgOutputDebugString("CSWCR1: 0x%X / 0x%X\r\n", BSC_CSWCR1, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECSWCR0);
EdbgOutputDebugString("ECSWCR0: 0x%X / 0x%X\r\n", BSC_ECSWCR0, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECSWCR1);
EdbgOutputDebugString("ECSWCR1: 0x%X / 0x%X\r\n", BSC_ECSWCR1, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_ECSWCR2);
EdbgOutputDebugString("ECSWCR2: 0x%X / 0x%X\r\n", BSC_ECSWCR2, uTemp);
uTemp = READ_REGISTER_ULONG (BSC_BCINTMR);
EdbgOutputDebugString("BCINTMR: 0x%X / 0x%X\r\n", BSC_BCINTMR, uTemp);
return;
}
static void DUMPREG_GPIO()
{
ULONG uTemp;
uTemp = READ_REGISTER_ULONG (GPIO_GPIO0_IOINTSEL);
EdbgOutputDebugString("GPIO_GPIO0_IOINTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO0_IOINTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO0_INOUTSEL);
EdbgOutputDebugString("GPIO_GPIO0_INOUTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO0_INOUTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO1_IOINTSEL);
EdbgOutputDebugString("GPIO_GPIO1_IOINTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO1_IOINTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO1_INOUTSEL);
EdbgOutputDebugString("GPIO_GPIO1_INOUTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO1_INOUTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO2_IOINTSEL);
EdbgOutputDebugString("GPIO_GPIO2_IOINTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO2_IOINTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO2_INOUTSEL);
EdbgOutputDebugString("GPIO_GPIO2_INOUTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO2_INOUTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO3_IOINTSEL);
EdbgOutputDebugString("GPIO_GPIO3_IOINTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO3_IOINTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO3_INOUTSEL);
EdbgOutputDebugString("GPIO_GPIO3_INOUTSEL: 0x%X / 0x%X\r\n", GPIO_GPIO3_INOUTSEL, uTemp);
uTemp = READ_REGISTER_ULONG (GPIO_GPIO3_POSNEG);
EdbgOutputDebugString("GPIO_GPIO3_POSNEG: 0x%X / 0x%X\r\n", GPIO_GPIO3_POSNEG, uTemp);
return;
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -