Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce47f986d8
NT4/private/ntos/fw/mips/monitor.c

1500 lines
37 KiB
C
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
monitor.c
Abstract:
This file contains the monitor for the firmware.
Author:
Lluis Abello (lluis) 09-Sep-91
--*/
#include "fwp.h"
#include "monitor.h"
#include "selfmap.h"
#include "sys\types.h"
#include "stdlib.h"
#include "string.h"
#include "jzsetup.h"
#include "selftest.h"
#include "fwstring.h"
#define BYTE 1
#define HALF 2
#define WORD 4
#define R4000_XCODE_MASK (0x1f << 2)
#define XCODE_INSTRUCTION_BUS_ERROR 0x18
#define XCODE_DATA_BUS_ERROR 0x1c
VOID
RomPutLine(
IN PCHAR String
);
VOID
FillVideoMemory(
IN ULONG,
IN ULONG,
IN ULONG
);
#define MoveCursorToColumn(Spaces) \
FwPrint("\r\x9B"#Spaces"C")
//
// declare static variables.
//
extern BOOLEAN ProcessorBEnabled;
ULONG Argc;
ULONG CurrentArg;
COMMAND_NAME_ID CurrentCommand;
ULONG DataSize;
ULONG DataSizeMask;
ULONG DataSizeShift;
ULONG DefaultAddress;
// ****** temp ******
// strtoul sets errno in case of overflow and is not declared anywhere else.
//
// int errno;
PCHAR RegisterNameTable[(REGISTER_NAME_ID)invalidregister] = {
"zero", // general register 0
"at", // general register 1
"v0", // general register 2
"v1", // general register 3
"a0", // general register 4
"a1", // general register 5
"a2", // general register 6
"a3", // general register 7
"t0", // general register 8
"t1", // general register 9
"t2", // general register 10
"t3", // general register 11
"t4", // general register 12
"t5", // general register 13
"t6", // general register 14
"t7", // general register 15
"s0", // general register 16
"s1", // general register 17
"s2", // general register 18
"s3", // general register 19
"s4", // general register 20
"s5", // general register 21
"s6", // general register 22
"s7", // general register 23
"t8", // general register 24
"t9", // general register 25
"k0", // general register 26
"k1", // general register 27
"gp", // general register 28
"sp", // general register 29
"s8", // general register 30
"ra", // general register 31
"f0", // fp register 0
"f1", // fp register 1
"f2", // fp register 2
"f3", // fp register 3
"f4", // fp register 4
"f5", // fp register 5
"f6", // fp register 6
"f7", // fp register 7
"f8", // fp register 8
"f9", // fp register 9
"f10", // fp register 10
"f11", // fp register 11
"f12", // fp register 12
"f13", // fp register 13
"f14", // fp register 14
"f15", // fp register 15
"f16", // fp register 16
"f17", // fp register 17
"f18", // fp register 18
"f19", // fp register 19
"f20", // fp register 20
"f21", // fp register 21
"f22", // fp register 22
"f23", // fp register 23
"f24", // fp register 24
"f25", // fp register 25
"f26", // fp register 26
"f27", // fp register 27
"f28", // fp register 28
"f29", // fp register 29
"f30", // fp register 30
"f31", // fp register 31
"fsr", // fp status register
"index", // cop0 register 0
"random", // cop0 register 1
"entrylo0", // cop0 register 2
"entrylo1", // cop0 register 3
"context", // cop0 register 4
"pagemask", // cop0 register 5
"wired", // cop0 register 6
"badvaddr", // cop0 register 8
"count", // cop0 register 9
"entryhi", // cop0 register 10
"compare", // cop0 register 11
"psr", // cop0 register 12
"cause", // cop0 register 13
"epc", // cop0 register 14
"prid", // cop0 register 15
"config", // cop0 register 16
"lladdr", // cop0 register 17
"watchlo", // cop0 register 18
"watchhi", // cop0 register 19
"ecc", // cop0 register 26
"cacheerror", // cop0 register 27
"taglo", // cop0 register 28
"taghi", // cop0 register 29
"errorepc" // cop0 register 30
};
CHAR UnknownException[] = "Unknown";
PCHAR ExceptionNameTable[32] = {
"Int", // exception code 0
"Mod", // exception code 1
"TlbL", // exception code 2
"TlbS", // exception code 3
"AdEL", // exception code 4
"AdES", // exception code 5
"IBE", // exception code 6
"DBE", // exception code 7
"Sys", // exception code 8
"Bp", // exception code 9
"RI", // exception code 10
"CpU", // exception code 11
"Ov", // exception code 12
"Tr", // exception code 13
"VCEI", // exception code 14
"FPE", // exception code 15
UnknownException, // exception code 16
UnknownException, // exception code 17
UnknownException, // exception code 18
UnknownException, // exception code 19
UnknownException, // exception code 20
UnknownException, // exception code 21
UnknownException, // exception code 22
"WATCH", // exception code 23
UnknownException, // exception code 24
UnknownException, // exception code 25
UnknownException, // exception code 26
UnknownException, // exception code 27
UnknownException, // exception code 28
UnknownException, // exception code 29
UnknownException, // exception code 30
"VCED" // exception code 31
};
PCHAR CommandNameTable[(COMMAND_NAME_ID)invalidcommand] = {
"d",
"db",
"dw",
"dd",
"e",
"eb",
"ew",
"ed",
"o",
"ob",
"ow",
"od",
"i",
"ib",
"iw",
"id",
"r",
"z",
"f",
"a",
"h",
"?",
#ifdef DUO
"s",
#endif
"q"
};
extern ULONG RegisterTable[(REGISTER_NAME_ID)invalidregister];
extern LONG FwRow;
extern LONG FwColumn;
REGISTER_NAME_ID
GetRegister(
IN PCHAR RegName
)
/*++
Routine Description:
This routine returns the index in the register table for the
given register. Or invalid if the given register name doesn't
match any register.
Arguments:
RegName - Null terminated string that contains the name of the register.
Return Value:
Index on the Register Table for the requested register.
--*/
{
REGISTER_NAME_ID RegId;
for (RegId = 0; RegId < MON_INVALID_REGISTER_MSG; RegId++) {
if (strcmp(RegisterNameTable[RegId],RegName) == 0) {
break;
}
}
return RegId;
}
ULONG
StrToUlong(
IN PCHAR String,
OUT CHAR ** Terminator
)
/*++
Routine Description:
This routine converts an ascii string to an unsigned long
Arguments:
String - Null terminated string that contains the value to convert.
Terminator - Address of a pointer to a character. This routine
sets it to point to the cahracter in String that terminated
the conversion. This is '\0' in a normal case or whatever
garbage the string contained.
Return Value:
Returns the converted string
--*/
{
ULONG Ulong = 0;
ULONG Index;
for (Index=0;String[Index]; Index++) {
if ((String[Index] >= '0') && (String[Index] <= '9')) {
Ulong <<= 4;
Ulong |= String[Index] - '0';
continue;
}
//
// Strings are always lower case so this is not needed.
//
//if ((String[Index] >= 'A') && (String[Index] <= 'F')) {
// Ulong <<= 4;
// Ulong |= String[Index] - 'A' + 10;
// continue;
//}
if ((String[Index] >= 'a') && (String[Index] <= 'f')) {
Ulong <<= 4;
Ulong |= String[Index] - 'a' + 10;
continue;
}
*Terminator = &String[Index];
return 0xFFFFFFF;
}
//
// Check for overflow
//
if (Index > 8) {
*Terminator = &String[0];
} else {
*Terminator = &String[Index];
}
return Ulong;
}
BOOLEAN
GetAddress(
IN PUCHAR String,
OUT PULONG Address
)
/*++
Routine Description:
This routine converts an ascii string to an address. The string
is the form:
[@reg | value]
Arguments:
String - Null terminated string that contains the address to convert.
Address - Supplies a pointer to where the converted address is stored
Return Value:
Returns TRUE if the string can be converted.
FALSE otherwise.
--*/
{
PUCHAR Terminator;
UCHAR Delimiter;
REGISTER_NAME_ID RegId;
if (*String == '@') {
String++; // skip @
if ((RegId = GetRegister(String)) == MON_INVALID_REGISTER_MSG) {
FwPrint(String);
FwPrint(MON_INVALID_REGISTER_MSG);
return FALSE;
} else {
*Address = RegisterTable[RegId];
}
} else {
*Address=StrToUlong(String,&Terminator);
if (*Terminator != '\0') {
//
// Not the whole string was converted.
//
FwPrint(Terminator);
FwPrint(MON_NOT_VALID_ADDRESS_MSG);
return FALSE;
}
}
return TRUE;
}
BOOLEAN
GetAddressRange(
IN PCHAR Argv[],
OUT PULONG StartAddress,
OUT PULONG EndAddress
)
/*++
Routine Description:
This routine converts an ascii string to a range, returning the starting
and end address.
The syntax for an address range is one of the following
startaddress endaddres
startaddress l numberofelements
Arguments:
Argv - array of zero terminated argument strings.
StartAddress - Supplies a pointer to where the Start address is stored
EndAddress - Supplies a pointer to where the End address is stored
Return Value:
Returns TRUE if Argv specifies a valid address range.
FALSE otherwise.
--*/
{
PCHAR Tmp;
CHAR Delimiter;
if (CurrentArg == Argc) {
return;
}
if (GetAddress(Argv[CurrentArg],StartAddress) == FALSE) {
return FALSE;
}
CurrentArg++;
if (CurrentArg == Argc) {
*EndAddress = *StartAddress+128;
return TRUE;
}
if (strcmp(Argv[CurrentArg],"l") == 0 ) {
//
// this is a range of the form "startaddress l count"
//
CurrentArg++;
if (CurrentArg == Argc) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (GetAddress(Argv[CurrentArg],EndAddress) == FALSE) {
return FALSE;
}
CurrentArg++;
*EndAddress = (*EndAddress<<DataSizeShift) + *StartAddress;
} else {
if (GetAddress(Argv[CurrentArg],EndAddress) == FALSE) {
//
// the argument didn't convert the range is Start+128
//
*EndAddress = *StartAddress+128;
} else {
CurrentArg++;
}
}
//
// Check that the range is correct End > Start
//
if (*EndAddress <= *StartAddress) {
FwPrint(MON_INVALID_ADDRESS_RANGE_MSG);
return FALSE;
}
return TRUE;
}
COMMAND_NAME_ID
GetCommand(
IN PCHAR CommandName
)
/*++
Routine Description:
This routine tries to match the supplied string
with one of the recognized commands.
Arguments:
CommandName - Supplies a string to be matched with one of the monitor commands.
Return Value:
Returns a value that identifies the command.
--*/
{
COMMAND_NAME_ID Index;
for (Index=0;Index<invalidcommand;Index++) {
if (strcmp(CommandNameTable[Index],CommandName) == 0) {
break;
}
}
return Index;
}
BOOLEAN
RegisterCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the REGISTER command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
REGISTER_NAME_ID RegId;
CHAR Message[64];
switch(Argc) {
case 1:
//
// Dump the value of all the registers
//
for (RegId=1;RegId<32;RegId++) {
sprintf(Message,MON_FORMAT1_MSG,RegisterNameTable[RegId],RegisterTable[RegId]);
FwPrint(Message);
if ((RegId%6) == 0) {
FwPrint(FW_CRLF_MSG);
}
}
sprintf(Message,MON_FORMAT1_MSG,RegisterNameTable[psr],RegisterTable[psr]);
FwPrint(Message);
sprintf(Message,MON_FORMAT1_MSG,RegisterNameTable[epc],RegisterTable[epc]);
FwPrint(Message);
sprintf(Message,MON_FORMAT1_MSG,RegisterNameTable[cause],RegisterTable[cause]);
FwPrint(Message);
sprintf(Message,MON_FORMAT1_MSG,RegisterNameTable[errorepc],RegisterTable[errorepc]);
FwPrint(Message);
FwPrint(FW_CRLF_MSG);
sprintf(Message,MON_FORMAT1_MSG,RegisterNameTable[badvaddr],RegisterTable[badvaddr]);
FwPrint(Message);
FwPrint(FW_CRLF_MSG);
return TRUE;
case 2:
//
// Dump the value of the specified register.
//
if ((RegId = GetRegister(Argv[1])) == MON_INVALID_REGISTER_MSG) {
FwPrint(Argv[1]);
FwPrint(MON_INVALID_REGISTER_MSG);
return FALSE;
} else {
sprintf(Message,"%s = %08lx\r\n",RegisterNameTable[RegId],RegisterTable[RegId]);
FwPrint(Message);
return TRUE;
}
default:
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
}
VOID
InputValue(
IN ULONG Address,
OUT PVOID Value
)
/*++
Routine Description:
This routine reads a value from the supplied address and displays
it. DataSize is set to the size of the value to read.
Arguments:
Address - Supplies the address where the value is to be read from.
Value - Pointer to where the value read is stored.
Return Value:
None.
--*/
{
CHAR Message[32];
switch(DataSize) {
case BYTE:
*(PUCHAR)Value = *(PUCHAR)Address; // read byte
sprintf(Message,"%02x ",*(PUCHAR)Value);
break;
//
// Display same data in ascii
//
case HALF:
sprintf(Message,"%04x ",*(PUSHORT)Address);
break;
case WORD:
sprintf(Message,"%08lx ",*(PULONG)Address);
break;
}
FwPrint(Message);
}
BOOLEAN
DumpCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the DUMP command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start,End;
ULONG i,LineLength;
ULONG DataLine[16];
UCHAR Message[32];
//
// Set the right range of addresses. If none specified use last
// set of addresses+128.
//
if (Argc == 1) {
Start = DefaultAddress;
End = Start + 128;
} else {
if (GetAddressRange(Argv,&Start,&End) == FALSE) {
return FALSE;
}
//
// if after getting the range not all the argument were processsed.
//
if (CurrentArg != Argc) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
}
//
// Check for proper alignment.
//
if ((DataSizeMask&Start) || (DataSizeMask&End)) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
} else {
//
// Set new addresses
//
DefaultAddress = End;
}
while (Start < End) {
//
// Print address of line.
//
sprintf(Message,"0x%08lx: ",Start);
FwPrint(Message);
LineLength = End-Start;
if (LineLength > 16) {
LineLength = 16;
}
for (i=0;i<LineLength;i+=DataSize) {
InputValue(Start,&DataLine[i]);
Start+=DataSize;
}
if (DataSize == 1) {
//
// If bytes display same data in ASCII
//
MoveCursorToColumn(60);
for (i=0;i<LineLength;i++) {
if (isprint((UCHAR)DataLine[i])) {
sprintf(Message,"%c",DataLine[i]);
FwPrint(Message);
} else {
FwPrint(".");
}
}
}
FwPrint(FW_CRLF_MSG);
}
return TRUE;
}
BOOLEAN
ZeroCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the Zero command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start,End;
//
// Set the right range of addresses. If none specified use last
// set of addresses+128.
//
if (Argc == 1) {
Start = DefaultAddress;
End = Start + 128;
} else {
if (GetAddressRange(Argv,&Start,&End) == FALSE) {
return FALSE;
}
//
// if after getting the range not all the argument were processsed.
//
if (CurrentArg != Argc) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
}
//
// Check for proper alignment.
//
if ((0xF&Start) || (0xF&End)) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
} else {
//
// Set new addresses
//
DefaultAddress = End;
}
FillVideoMemory(Start,End-Start,0);
return TRUE;
}
BOOLEAN
OutputValue(
IN PCHAR AsciiValue,
IN ULONG Address
)
/*++
Routine Description:
This routine writes the converted value to the specified
address. DataSize is set to the size of the data to be written.
Arguments:
AsciiValue - Supplies a pointer to a string that contains an hexadecimal
value.
Address - Supplies the address where the value is to be written to.
Return Value:
TRUE if the value is successfully converted.
FALSE otherwise.
--*/
{
ULONG Value;
PCHAR Terminator;
//
// Conver value to integer
//
Value = StrToUlong(AsciiValue,&Terminator);
if (*Terminator != '\0') {
//
// Not the whole string was converted.
//
FwPrint(Terminator);
FwPrint(MON_INVALID_VALUE_MSG);
return FALSE;
} else {
//
// Store the value.
//
switch (DataSize) {
case BYTE:*(PUCHAR)Address = (UCHAR)Value;
break;
case HALF:*(PUSHORT)Address = (USHORT)Value;
break;
case WORD: *(PULONG)Address = (ULONG)Value;
break;
}
}
return TRUE;
}
BOOLEAN
OutputCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the OUTPUT command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start;
if (Argc!=3) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (GetAddress(Argv[1],&Start) == FALSE) {
return FALSE;
}
//
// Check for proper alignment.
//
if (DataSizeMask & Start) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
if (OutputValue(Argv[2],Start) == TRUE) {
//
// Set new default addresses
//
DefaultAddress = Start+DataSize;
}
return TRUE;
}
BOOLEAN
InputCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the INPUT command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start;
UCHAR Message[16];
ULONG Trash;
if (Argc!=2) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (GetAddress(Argv[1],&Start) == FALSE) {
return FALSE;
}
//
// Check for proper alignment.
//
if (DataSizeMask & Start) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
sprintf(Message,"0x%08lx: ",Start);
FwPrint(Message);
InputValue(Start,&Trash);
FwPrint(FW_CRLF_MSG);
//
// Set new default addresses
//
DefaultAddress = Start+DataSize;
return TRUE;
}
BOOLEAN
EnterCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the ENTER command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start;
CHAR String[32];
GETSTRING_ACTION Action;
//
// Set the right range of addresses. If none specified use last
// set of addresses+128.
//
switch(Argc) {
case 1:
Start = DefaultAddress;
break;
case 2:
if (GetAddress(Argv[1],&Start) == FALSE) {
return FALSE;
}
break;
case 3:
//
// This is equivalent to the output command
//
return OutputCommand(Argv);
default:
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
//
// Check for proper alignment.
//
if (DataSizeMask & Start) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
for (;;) {
//
// Print address of line.
//
sprintf(String,"0x%08lx: ",Start);
FwPrint(String);
switch (DataSize) {
case BYTE:
sprintf(String,"%02x . ",*(PUCHAR)Start);
break;
case HALF:
sprintf(String,"%04x . ",*(PUSHORT)Start);
break;
case WORD:
sprintf(String,"%08lx . ",*(PULONG)Start);
break;
}
FwPrint(String);
do {
Action = FwGetString(String,10,NULL,FwRow,FwColumn);
} while ((Action != GetStringSuccess) && (Action != GetStringEscape));
FwPrint(FW_CRLF_MSG);
if (String[0] == '\0') { // carriage return exit enter command
//
// set new default address.
//
DefaultAddress = Start;
return TRUE;
}
if (String[0] == ' ') { // blank = next data element.
Start+=DataSize;
continue;
}
if (String[0] == '-') { // hypen = previous data element.
Start-=DataSize;
continue;
}
if (OutputValue(String,Start) == TRUE) { // deposit the value.
Start+=DataSize;
}
}
return TRUE;
}
BOOLEAN
FillCommand(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine will implement the FILL command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start,End,Values[16];
ULONG Index,Count;
PCHAR Terminator;
if (GetAddressRange(Argv,&Start,&End) == FALSE) {
return FALSE;
}
//
// if there are no more arguments we don't know what to fill with.
//
if (CurrentArg == Argc) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
//
// Convert the values
//
for (Count=0;CurrentArg < Argc; CurrentArg++) {
Values[Count++] = StrToUlong(Argv[CurrentArg],&Terminator);
if (*Terminator != '\0') {
//
// Not the whole string was converted.
//
FwPrint(Terminator);
FwPrint(MON_INVALID_VALUE_MSG);
return FALSE;
}
}
Index = 0;
for (;Start < End;Start++) {
*((PCHAR)Start) = Values[Index++];
if (Index == Count) {
Index=0;
}
}
return TRUE;
}
BOOLEAN
FwDumpLookupTable(
IN PCHAR Argv[]
)
/*++
Routine Description:
This routine displays the device names stored in the lookup table.
Arguments:
Argv - array of zero terminated argument strings.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
UCHAR C;
ULONG Count;
PDRIVER_LOOKUP_ENTRY PLookupTable;
PLookupTable=&DeviceLookupTable[0];
while (PLookupTable->DevicePath != NULL) {
FwPrint(PLookupTable->DevicePath);
FwPrint(FW_CRLF_MSG);
PLookupTable++;
}
return(TRUE);
}
VOID
Monitor(
IN ULONG CallerSource
)
/*++
Routine Description:
This is the main dispatch routine to the various commands
that can be typed at the monitor prompt.
Arguments:
CallerSource - 0 if a UTLB or General exception occurred.
- 1 if an NMI_EXCEPTION occurred.
- 2 if a CACHE_EXCEPTION occurred.
- 3 if the caller is not an exception handler.
Return Value:
None.
--*/
{
CHAR Buffer[2][128];
ULONG ParityDiag[3];
PULONG ParDiag;
ULONG BufferIndex;
PCHAR Argv[10];
PCHAR Tmp;
CHAR String[128];
BOOLEAN CommandValid;
GETSTRING_ACTION Action;
ULONG Index;
JzSetScreenAttributes( TRUE, FALSE, FALSE);
#ifdef DUO
//
// Set text White for processor A. Yellow for processor B
//
if (READ_REGISTER_ULONG(&DMA_CONTROL->WhoAmI.Long) == 0) {
JzSetScreenColor(ArcColorWhite, ArcColorBlue);
} else {
JzSetScreenColor(ArcColorYellow, ArcColorBlue);
}
#else
JzSetScreenColor(ArcColorWhite, ArcColorBlue);
#endif
FwPrint(MON_JAZZ_MONITOR_MSG);
sprintf(String,"%ld\r\n",*(PULONG)(PROM_ENTRY(2)));
FwPrint(String);
FwPrint(MON_PRESS_H_MSG);
//
// Initialize command line to null.
//
Argv[0] = (PCHAR)NULL;
if (CallerSource !=3) {
//
// Display Cause of exception.
//
switch(CallerSource) {
case 0:
FwPrint(ExceptionNameTable[((RegisterTable[cause])&0xFF) >> 2]);
break;
case NMI_EXCEPTION:
FwPrint(MON_NMI_MSG);
break;
case CACHE_EXCEPTION:
FwPrint(MON_CACHE_ERROR_MSG);
break;
}
FwPrint(MON_EXCEPTION_MSG);
//
// simulate a dump all registers command;
//
Argc = 1;
RegisterCommand(Argv);
Argc = 0;
}
//
// Initialize Static variables.
//
DefaultAddress = KSEG1_BASE;
DataSize = WORD;
BufferIndex = 0;
#ifdef DUO
//
// Report system parity exceptions.
//
//
if ((((RegisterTable[cause]&R4000_XCODE_MASK) == XCODE_DATA_BUS_ERROR) ||
((RegisterTable[cause]&R4000_XCODE_MASK) == XCODE_INSTRUCTION_BUS_ERROR)) &&
(READ_REGISTER_ULONG(&DMA_CONTROL->NmiSource.Long) == 1)) {
//
// This is a bus error exception. And the cause is ecc error.
//
sprintf(String,
MON_ECC_ERROR_MSG,
RegisterTable[epc]
);
FwPrint(String);
//
// align ParDiag to a double word address
//
ParDiag = (PULONG) ((ULONG)(&ParityDiag[1]) & 0xFFFFFFF8);
LoadDoubleWord(&DMA_CONTROL->EccDiagnostic,ParDiag);
sprintf(String,
MON_MEM_ECC_FAILED_MSG,
READ_REGISTER_ULONG(&DMA_CONTROL->MemoryFailedAddress.Long),
*ParDiag,
*(ParDiag+1)
);
}
#endif
if (CallerSource == CACHE_EXCEPTION) {
//
// try to print as much info as possible.
//
sprintf(String,
MON_CACHE_ERROR_EPC_MSG,
RegisterTable[cacheerror],
RegisterTable[errorepc]
);
FwPrint(String);
#ifndef DUO
//
// Do not print Parity Diag for a DUO CacheError exception since it's only
// an internal one.
//
//
// align ParDiag to a double word address
//
ParDiag = (PULONG) ((ULONG)(&ParityDiag[1]) & 0xFFFFFFF8);
LoadDoubleWord(&DMA_CONTROL->ParityDiagnosticLow.Long,ParDiag);
sprintf(String,
MON_PARITY_DIAG_MSG,
*ParDiag,
*(ParDiag+1)
);
FwPrint(String);
#endif
//
// Now we will probably die, as the keyboard is interrupt
// driven and the interrupt handler is cached... Life is Tough!
//
}
//
// loop forever getting commands and dispatching them
//
while(TRUE) {
//
// print prompt
//
FwPrint(">");
//
// read a command.
//
do {
Action = FwGetString(Buffer[BufferIndex],128,NULL,FwRow,FwColumn);
} while ((Action != GetStringSuccess) && (Action != GetStringEscape));
FwPrint(FW_CRLF_MSG);
//
// convert string to lower case.
//
for(Tmp=Buffer[BufferIndex];*Tmp;*Tmp++) {
*Tmp=tolower(*Tmp);
}
//
// if escape was pressed, simulate a quit command.
//
if (Action == GetStringEscape) {
Argc = 1;
Argv[0] = "q";
//
// separate command line into tokens delimited by spaces
// load up Argv with pointers to arguments and put count in Argc
//
} else if (*Buffer[BufferIndex] != '\0') {
Tmp = Buffer[BufferIndex];
Argc = 0;
//
// Skip leading blanks
//
while ( *Tmp == ' ') {
Tmp++;
}
while ( *Tmp ) {
Argv[Argc++] = Tmp;
while ( *Tmp ) {
if (*Tmp == ' ') {
*Tmp++ = '\0';
while ( *Tmp == ' ') {
Tmp++;
}
break;
}
Tmp++;
}
}
//if ((Argv[Argc] = strtok(Buffer[BufferIndex]," ")) != NULL) {
// Argc++;
// while((Argv[Argc]=strtok((PCHAR)NULL," ")) != NULL) {
// Argc++;
// }
//}
//
// Increment index so that next command is read into the other
// buffer. And we preserve the previous one.
//
BufferIndex = (BufferIndex+1) & 0x1;
} else {
//
// repeat the last command already in Argv Argc
//
}
//
// if first argument is not null, then dispatch to routines.
//
if (Argv[0] != (PCHAR) NULL) {
CurrentArg = 1;
CurrentCommand = GetCommand(Argv[0]);
switch(CurrentCommand) {
case DumpByte:
case DumpWord:
case DumpDouble:
DataSizeShift = (CurrentCommand - Dump -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Dump:
CommandValid = DumpCommand(Argv);
break;
case EnterByte:
case EnterWord:
case EnterDouble:
DataSizeShift = (CurrentCommand - Enter -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Enter:
CommandValid = EnterCommand(Argv);
break;
case OutputByte:
case OutputWord:
case OutputDouble:
DataSizeShift = (CurrentCommand - Output -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Output:
CommandValid = OutputCommand(Argv);
break;
case InputByte:
case InputWord:
case InputDouble:
DataSizeShift = (CurrentCommand - Input -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Input:
CommandValid = InputCommand(Argv);
break;
case Register:
CommandValid = RegisterCommand(Argv);
break;
case Zero:
CommandValid = ZeroCommand(Argv);
break;
case Fill:
CommandValid = FillCommand(Argv);
break;
case AvailableDevices:
CommandValid = FwDumpLookupTable(Argv);
break;
case Help:
case Help2:
for (Index = 0 ; Index < MON_HELP_SIZE ; Index++) {
FwPrint(MON_HELP_TABLE[Index]);
FwPrint(FW_CRLF_MSG);
}
break;
#ifdef DUO
case SwitchProcessor:
if (ProcessorBEnabled == FALSE) {
FwPrint(MON_PROCESSOR_B_MSG);
break;
}
if (READ_REGISTER_ULONG(&DMA_CONTROL->WhoAmI.Long) == 0) {
PPROCESSOR_B_TASK_VECTOR TaskVector;
//
// Set the monitor entry point in the TaskVector
//
TaskVector = (PPROCESSOR_B_TASK_VECTOR)&ProcessorBTask;
TaskVector->Routine = FwMonitor;
TaskVector->Data = 0;
WRITE_REGISTER_ULONG(&DMA_CONTROL->IpInterruptRequest.Long,2);
WaitForIpInterrupt(0);
JzSetScreenColor(ArcColorWhite, ArcColorBlue);
break;
}
//
// if processor B then do the same as in a quit command.
//
#endif
case Quit:
if (CallerSource == 3) {
return;
} else {
//
// We came because of an exception.
// The only way to exit is reseting the system.
//
FwPrint(MON_NO_RETURN_MSG);
FwPrint(MON_RESET_MACHINE_MSG);
do {
Action = FwGetString(Buffer[BufferIndex],128,NULL,FwRow,FwColumn);
} while ((Action != GetStringSuccess) && (Action != GetStringEscape));
FwPrint(FW_CRLF_MSG);
Buffer[BufferIndex][0]=tolower(Buffer[BufferIndex][0]);
if (strcmp(Buffer[BufferIndex],"y") == 0) {
ResetSystem();
// ArcReboot();
}
break;
}
case invalidcommand:
FwPrint(MON_UNRECOGNIZED_COMMAND_MSG);
//
// Clear the argument so that re-do last command
// doesn't repeat the erroneous command.
//
CommandValid = FALSE;
break;
}
if (!CommandValid) {
Argv[0] = (PCHAR) NULL;
}
}
}
}
Reference in New Issue Copy Permalink