/*++
Copyright (c) 1991 Microsoft Corporation
Copyright (c) 1993 Digital Equipment Corporation
Module Name:
monitor.c
Abstract:
This file contains the monitor for the firmware.
Author:
Lluis Abello (lluis) 09-Sep-91
Revision History:
26-May-1992 John DeRosa [DEC]
Added Alpha/Jensen modifications.
--*/
#include "fwp.h"
#include "iodevice.h"
#include "monitor.h"
#include "sys\types.h"
#include "string.h"
#include "fwstring.h"
#define BYTE 1
#define HALF 2
#define MON_LONGWORD 4
#define MON_QUAD 8
VOID
FillVideoMemory(
IN ULONG,
IN ULONG,
IN ULONG
);
//
// declare static variables.
//
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.
//
ULONG errno;
PCHAR RegisterNameTable[(REGISTER_NAME_ID)invalidregister] = {
"???", // reserved for exception type
"ex1", // exception parameter 1
"ex2", // exception parameter 2
"ex3", // exception parameter 3
"ex4", // exception parameter 4
"ex5", // exception parameter 5
"psr", // exception psr
"mmc", // exception mm csr
"eva", // exception va
"pc", // exception pc
"v0", // general register 0
"t0", // general register 1
"t1", // general register 2
"t2", // general register 3
"t3", // general register 4
"t4", // general register 5
"t5", // general register 6
"t6", // general register 7
"t7", // general register 8
"s0", // general register 9
"s1", // general register 10
"s2", // general register 11
"s3", // general register 12
"s4", // general register 13
"s5", // general register 14
"fp", // general register 15
"a0", // general register 16
"a1", // general register 17
"a2", // general register 18
"a3", // general register 19
"a4", // general register 20
"a5", // general register 21
"t8", // general register 22
"t9", // general register 23
"t10", // general register 24
"t11", // general register 25
"ra", // general register 26
"t12", // general register 27
"at", // general register 28
"gp", // general register 29
"sp", // general register 30
"zero", // 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
};
// This is indexed by the low bits of the ExceptionType.
PCHAR ExceptionNameTable[14] = {
"** Machine Check", // exception code 0
"** Arithmetic", // exception code 1
"** Interrupt", // exception code 2
"** D-Stream Memory Fault", // exception code 3
"** I-Stream TB Miss", // exception code 4
"** I-Stream ACV", // exception code 5
"** Native D-Stream TB Miss", // exception code 6
"** PALcode D-Stream TB Miss", // exception code 7
"** Unaligned Data", // exception code 8
"** Opcode Reserved To DEC", // exception code 9
"** Floating Point Enable", // exception code a
"** Halt", // exception code b
"** Breakpoint", // exception code c
"** Divide by Zero" // exception code d
};
//
// I/O Write commands, and Available Devices, are disabled in the product.
//
#if 0
PCHAR CommandNameTable[(COMMAND_NAME_ID)invalidcommand] = {
"d",
"db",
"dw",
"dl",
"dq",
"e",
"eb",
"ew",
"el",
"eq",
"h",
"?",
"de",
"deb",
"dew",
"del",
"deq",
"ex",
"exb",
"exw",
"exl",
"exq",
"ior",
"iorb",
"iorw",
"iorl",
"iow",
"iowb",
"ioww",
"iowl",
"r",
"ir",
"fr",
"z",
"f",
"a",
"q"
};
#else
PCHAR CommandNameTable[(COMMAND_NAME_ID)invalidcommand] = {
"d",
"db",
"dw",
"dl",
"dq",
"e",
"eb",
"ew",
"el",
"eq",
"h",
"?",
"de",
"deb",
"dew",
"del",
"deq",
"ex",
"exb",
"exw",
"exl",
"exq",
"ior",
"iorb",
"iorw",
"iorl",
"r",
"ir",
"fr",
"z",
"f",
"q"
};
#endif
// Alpha/Jensen passes register table in as pointer to structure.
//extern ULONG RegisterTable[(REGISTER_NAME_ID)invalidregister];
extern LONG FwColumn;
extern LONG FwRow;
REGISTER_NAME_ID
GetRegister(
IN PCHAR RegName
)
/*++
Routine Description:
This routine returns the index in the exception frame 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 for the requested register.
--*/
{
REGISTER_NAME_ID RegId;
for (RegId = 0; RegId < invalidregister; RegId++) {
if (strcmp(RegisterNameTable[RegId],RegName) == 0) {
break;
}
}
return RegId;
}
BOOLEAN
GetAddress(
IN PUCHAR String,
IN PFW_EXCEPTION_FRAME Frame,
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.
Frame - Address of the exception frame that was passed to Monitor.
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)) == invalidregister) {
FwPrint(String);
FwPrint(MON_INVALID_REGISTER_MSG);
return FALSE;
} else {
//
// This is a hack to treat the structure as an array. It
// should have been an array to begin with. RegId is an
// index into the "array".
//
*Address = ((PULONGLONG)Frame)[RegId];
}
} else {
*Address=strtoul(String,&Terminator,16);
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[],
IN PFW_EXCEPTION_FRAME Frame,
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.
Frame - Address of the exception frame that was passed to Monitor.
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],Frame,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],Frame,EndAddress) == FALSE) {
return FALSE;
}
CurrentArg++;
*EndAddress = (*EndAddress<<DataSizeShift) + *StartAddress;
} else {
if (GetAddress(Argv[CurrentArg],Frame,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[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This routine will implement the Register, IntegerRegisterDump,
and FloatingRegisterDump commands given the arguments in the
argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Frame - the saved register & exception state.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
REGISTER_NAME_ID RegId;
CHAR Message[64];
if (
((strcmp(Argv[0], "ir") == 0) || (strcmp(Argv[0], "fr") == 0))
&&
(Argc != 1)
) {
// invalid ir or fr command.
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (
(strcmp(Argv[0], "r") == 0)
&&
(Argc != 2)
) {
// invalid r command.
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (strcmp(Argv[0], "ir") == 0) {
//
// ir command, and we know the argument count is 1.
// Dump the integer registers.
//
for (RegId=1;RegId<42;RegId++) {
sprintf(Message," %4s=%016Lx",RegisterNameTable[RegId],
((PULONGLONG)Frame)[RegId]);
FwPrint(Message);
if ((RegId%3) == 0) {
FwPrint(FW_CRLF_MSG);
}
}
FwPrint(FW_CRLF_MSG);
return TRUE;
}
if (strcmp(Argv[0], "fr") == 0) {
//
// fr command, and we know the argument count is 1.
// Dump the floating point registers.
//
for (RegId=42;RegId<74;RegId++) {
sprintf(Message," %3s=%016Lx",RegisterNameTable[RegId],
((PULONGLONG)Frame)[RegId]);
FwPrint(Message);
if ((RegId%3) == 2) {
FwPrint(FW_CRLF_MSG);
}
}
FwPrint(FW_CRLF_MSG);
return TRUE;
}
if (strcmp(Argv[0], "r") == 0) {
//
// r command, and we know the argument count is 2.
// Dump the specified register.
//
if ((RegId = GetRegister(Argv[1])) == invalidregister) {
FwPrint(Argv[1]);
FwPrint(MON_INVALID_REGISTER_MSG);
return FALSE;
} else {
sprintf(Message,"%s = %016Lx\r\n",RegisterNameTable[RegId],
((PULONGLONG)Frame)[RegId]);
FwPrint(Message);
return TRUE;
}
}
}
VOID
ExamineValue(
IN ULONG Address,
OUT PVOID Value
)
/*++
Routine Description:
This reads a value from the supplied address and displays it.
Arguments:
Address - Supplies the address where the value is to be read from.
Value - Pointer to where the value read is stored if DataSize = BYTE.
Return Value:
None.
--*/
{
CHAR Message[32];
switch(DataSize) {
case BYTE:
*(PUCHAR)Value = *(PUCHAR)Address;
sprintf(Message,"%02x ",*(PUCHAR)Value);
break;
case HALF:
sprintf(Message,"%04x ",*(PUSHORT)Address);
break;
case MON_LONGWORD:
sprintf(Message,"%08lx ",*(PULONG)Address);
break;
case MON_QUAD:
sprintf(Message,"%016Lx ", *(PULONGLONG)Address);
break;
}
FwPrint(Message);
}
BOOLEAN
DumpCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
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.
Frame - the saved register & exception state.
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,Frame,&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) {
ExamineValue(Start,&DataLine[i]);
Start+=DataSize;
}
if (DataSize == 1) {
//
// If bytes display same data in ASCII
//
VenMoveCursorToColumn(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[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
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.
Frame - the saved register & exception state.
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,Frame,&Start,&End) == FALSE) {
return FALSE;
}
//
// if after getting the range not all the argument were processsed, // error.
//
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
DepositValue(
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;
ULONGLONG Value;
PCHAR Terminator;
//
// Convert value to integer
//
Value = strtouq(AsciiValue,&Terminator,16);
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 MON_LONGWORD:*(PULONG)Address = (ULONG)Value;
break;
case MON_QUAD:*(PULONGLONG)Address = (ULONGLONG)Value;
break;
}
}
return TRUE;
}
BOOLEAN
DepositCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This routine will implement the Deposit command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Frame - the saved register & exception state.
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],Frame,&Start) == FALSE) {
return FALSE;
}
//
// Check for proper alignment.
//
if (DataSizeMask & Start) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
if (DepositValue(Argv[2],Start) == TRUE) {
//
// Set new default addresses
//
DefaultAddress = Start+DataSize;
}
return TRUE;
}
BOOLEAN
ExamineCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This routine will implement the Examine command given the
arguments in the argc,Argv form.
Arguments:
Argv - array of zero terminated argument strings.
Frame - the saved register & exception state.
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],Frame,&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);
ExamineValue(Start,&Trash);
FwPrint(FW_CRLF_MSG);
//
// Set new default addresses
//
DefaultAddress = Start+DataSize;
return TRUE;
}
BOOLEAN
EnterCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
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.
Frame - the saved register & exception state.
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],Frame,&Start) == FALSE) {
return FALSE;
}
break;
case 3:
//
// This is equivalent to the Deposit command
//
return DepositCommand(Argv,Frame);
default:
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
//
// Check for proper alignment.
//
if (DataSizeMask & Start) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
while (TRUE) {
//
// 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 MON_LONGWORD:
sprintf(String,"%08lx . ",*(PULONG)Start);
break;
case MON_QUAD:
sprintf(String,"%016Lx . ",*(PULONGLONG)Start);
break;
}
FwPrint(String);
do {
Action = JzGetString(String, 10, NULL, FwRow+1, FwColumn+1, FALSE);
} 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 (DepositValue(String,Start) == TRUE) { // deposit the value.
Start+=DataSize;
}
}
return TRUE;
}
BOOLEAN
FillCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This routine will implement the FILL command given the
arguments in the argc,Argv form.
This will remain a longword-based fill for now.
Arguments:
Argv - array of zero terminated argument strings.
Frame - the saved register & exception state.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start,End,Values[16];
ULONG Index,Count;
PCHAR Terminator;
if (GetAddressRange(Argv,Frame,&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++] = strtoul(Argv[CurrentArg],&Terminator,16);
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;
}
VOID
HelpCommand(
VOID
)
/*
Routine Description:
This outputs a simple command list.
Arguments:
None.
Return Value:
None.
*/
{
ULONG Index;
for (Index = 0; Index < MON_HELP_SIZE; Index++) {
VenPrint(MON_HELP_TABLE[Index]);
VenPrint(FW_CRLF_MSG);
}
}
BOOLEAN
FwDumpLookupTable(
VOID
)
/*++
Routine Description:
This displays the device names stored in the lookup table.
Arguments:
None.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
UCHAR C;
ULONG Count;
PDRIVER_LOOKUP_ENTRY PLookupTable;
FwPrint(MON_AVAILABLE_HW_DEVICES_MSG);
PLookupTable=&DeviceLookupTable[0];
while (PLookupTable->DevicePath != NULL) {
FwPrint(PLookupTable->DevicePath);
FwPrint(FW_CRLF_MSG);
PLookupTable++;
}
return(TRUE);
}
BOOLEAN
IOReadCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This implements the IORead command given the arguments in the
argc,Argv form. This reads I/O space.
Arguments:
Argv - array of zero terminated argument strings.
Frame - the saved register & exception state.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start;
UCHAR Message[32];
if (Argc!=2) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (GetAddress(Argv[1],Frame,&Start) == FALSE) {
return FALSE;
}
//
// Check for proper alignment in I/O space.
//
if (
(// combo space
((Start & 0xf0000000) == 0xa0000000)
&&
(DataSize != BYTE)
)
) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
//
// Do the I/O space read.
//
switch (DataSize) {
// Byte
case BYTE:
sprintf(Message,"0x%08lx: 0x%02x\r\n",
Start,
READ_PORT_UCHAR((PUCHAR)Start));
FwPrint(Message);
break;
// Word
case HALF:
sprintf(Message,"0x%08lx: 0x%04x\r\n",
Start,
READ_PORT_USHORT((PUSHORT)Start));
FwPrint(Message);
break;
// Longword
case MON_LONGWORD:
sprintf(Message,"0x%08lx: 0x%08x\r\n",
Start,
READ_PORT_ULONG((PULONG)Start));
FwPrint(Message);
break;
// bad data size
default:
FwPrint(MON_BAD_IO_OPERATION_MSG);
return FALSE;
}
//
// Set new default addresses
//
DefaultAddress = Start+DataSize;
return TRUE;
}
#if 0
//
// The I/O Write commands are disabled in the final product.
//
BOOLEAN
IOWriteCommand(
IN PCHAR Argv[],
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This implements the IOWrite command given the arguments in the
argc,Argv form. This writes I/O space.
Arguments:
Argv - array of zero terminated argument strings.
Frame - the saved register & exception state.
Return Value:
Returns TRUE if the command is valid, FALSE otherwise.
--*/
{
ULONG Start;
ULONG Value;
UCHAR Message[32];
PCHAR Terminator;
if (Argc!=3) {
FwPrint(MON_INVALID_ARGUMENT_COUNT_MSG);
return FALSE;
}
if (GetAddress(Argv[1],Frame,&Start) == FALSE) {
return FALSE;
}
//
// Check for proper alignment in I/O space.
//
if (// combo space check
((Start & 0xf0000000) == 0xa0000000)
&&
(DataSize != BYTE)
) {
FwPrint(MON_UNALIGNED_ADDRESS_MSG);
return FALSE;
}
//
// Convert deposit value to integer
//
Value = strtoul(Argv[2],&Terminator,16);
if (*Terminator != '\0') {
//
// Not the whole string was converted.
//
FwPrint(Terminator);
FwPrint(MON_INVALID_VALUE_MSG);
return FALSE;
} else {
//
// Do the I/O space write
//
switch (DataSize) {
// Byte
case BYTE:
WRITE_PORT_UCHAR((PUCHAR)Start, Value);
break;
// Word
case HALF:
WRITE_PORT_USHORT((PUSHORT)Start, Value);
break;
// Longword
case MON_LONGWORD:
WRITE_PORT_ULONG((PULONG)Start, Value);
break;
// bad data size
default:
FwPrint(MON_BAD_IO_OPERATION_MSG);
return FALSE;
}
}
//
// Set new default addresses
//
DefaultAddress = Start+DataSize;
return TRUE;
}
#endif
VOID
Monitor(
IN ULONG CallerSource,
IN PFW_EXCEPTION_FRAME Frame
)
/*++
Routine Description:
This is the main dispatch routine to the various commands
that can be typed at the monitor prompt.
Arguments:
For Alpha/Jensen:
CallerSource 0 if exception (or bugcheck, on Alpha/Jensen)
3 if called from boot menu
Frame the machine / exception state.
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;
#ifdef ALPHA_FW_KDHOOKS
//
// If this is a breakpoint exception which is recognized, process it.
// Otherwise, continue into the Monitor.
//
if ((Frame->ExceptionType == FW_EXC_BPT) &&
(FwKdProcessBreakpoint(Frame) == TRUE)) {
//
// This does not return.
//
FwRfe(Frame);
}
#endif
FwPrint(MON_MONITOR_MSG);
FwPrint(MON_PRESS_H_MSG);
//
// Initialize command line to null.
//
Argv[0] = (PCHAR)NULL;
if (CallerSource !=3) {
//
// Display Cause of exception.
//
if ((Frame->ExceptionType >= FW_EXC_FIRST) &&
(Frame->ExceptionType <= FW_EXC_LAST)
)
{ FwPrint(ExceptionNameTable[(Frame->ExceptionType & 0xf)]);}
else
{ FwPrint("** !! Unknown Exception"); }
FwPrint(MON_EXCEPTION_MSG);
FwPrint("PC = 0x%016Lx, VA = 0x%016Lx\r\n",
Frame->ExceptionFaultingInstructionAddress,
Frame->ExceptionVa);
//
// If an exception happened before the ARC console was opened,
// a call to JzGetString will not work since JzGetString calls
// ArcRead. So, close the console (nothing bad will happen if these
// are not already opened) and reopen it.
//
FwClose(ARC_CONSOLE_INPUT);
FwClose(ARC_CONSOLE_OUTPUT);
#ifdef ALPHA_FW_KDHOOKS
//
// If we are built with the kernel debugger stubs, and have come
// here because of an exception, we want to enter the debugger.
//
Frame->ExceptionType = FW_EXC_BPT;
DbgBreakPoint();
#endif
FwOpenConsole();
}
//
// Initialize Static variables.
//
DefaultAddress = KSEG0_BASE;
DataSize = MON_QUAD;
BufferIndex = 0;
//
// loop forever getting commands and dispatching them
//
while(TRUE) {
//
// print prompt
//
FwPrint(">");
//
// read a command.
//
do {
Action = JzGetString(Buffer[BufferIndex], 128, NULL,
FwRow+1, FwColumn+1, FALSE);
} 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++;
}
}
//
// 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 DumpLongword:
case DumpQuad:
DataSizeShift = (CurrentCommand - Dump -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Dump:
CommandValid = DumpCommand(Argv,Frame);
break;
case EnterByte:
case EnterWord:
case EnterLongword:
case EnterQuad:
DataSizeShift = (CurrentCommand - Enter -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Enter:
CommandValid = EnterCommand(Argv,Frame);
break;
case Help:
case Help2:
HelpCommand();
break;
case DepositByte:
case DepositWord:
case DepositLongword:
case DepositQuad:
DataSizeShift = (CurrentCommand - Deposit -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Deposit:
CommandValid = DepositCommand(Argv,Frame);
break;
case ExamineByte:
case ExamineWord:
case ExamineLongword:
case ExamineQuad:
DataSizeShift = (CurrentCommand - Examine -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case Examine:
CommandValid = ExamineCommand(Argv,Frame);
break;
case IOReadByte:
case IOReadWord:
case IOReadLongword:
DataSizeShift = (CurrentCommand - IORead -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case IORead:
CommandValid = IOReadCommand(Argv, Frame);
break;
#if 0
case IOWriteByte:
case IOWriteWord:
case IOWriteLongword:
DataSizeShift = (CurrentCommand - IOWrite -1);
DataSize = 1 << DataSizeShift;
DataSizeMask = DataSize-1;
case IOWrite:
CommandValid = IOWriteCommand(Argv, Frame);
break;
#endif
case Register:
case IntegerRegisterDump:
case FloatingRegisterDump:
CommandValid = RegisterCommand(Argv, Frame);
break;
case Zero:
CommandValid = ZeroCommand(Argv,Frame);
break;
case Fill:
CommandValid = FillCommand(Argv,Frame);
break;
#if 0
case AvailableDevices:
CommandValid = FwDumpLookupTable();
break;
#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 = JzGetString(Buffer[BufferIndex],
128,
NULL,
FwRow+1,
FwColumn+1,
FALSE);
} while ((Action != GetStringSuccess) && (Action != GetStringEscape));
FwPrint(FW_CRLF_MSG);
Buffer[BufferIndex][0]=tolower(Buffer[BufferIndex][0]);
if (strcmp(Buffer[BufferIndex],"y") == 0) {
ResetSystem();
}
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;
}
}
}
}