/*	Copyright Motorola, Inc. 1993, 1994, 1999
 	ALL RIGHTS RESERVED

	You are hereby granted a copyright license to use, modify, and 
	distribute the SOFTWARE so long as this entire notice is retained 
	without alteration in any modified and/or redistributed versions, 
	and that such modified versions are clearly identified as such.  
	No licenses are granted by implication, estoppel or otherwise under 
	any patents or trademarks of Motorola, Inc.

	The SOFTWARE is provided on an "AS IS" basis and without warranty.  
	To the maximum extent permitted by applicable law, MOTOROLA DISCLAIMS 
	ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING IMPLIED 
	WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
	PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH 
	REGARD TO THE SOFTWARE (INCLUDING ANY MODIFIED VERSIONS 
	THEREOF) AND ANY ACCOMPANYING WRITTEN MATERIALS. 

	To the maximum extent permitted by applicable law, IN NO EVENT SHALL 
	MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER 
	(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF 
	BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS 
	INFORMATION, OR OTHER PECUNIARY LOSS) ARISING OF THE USE OR 
	INABILITY TO USE THE SOFTWARE.   Motorola assumes no responsibility 
	for the maintenance and support of the SOFTWARE.  

*/

/*  cmdtest Tests the COP command files for various processors. 
 *
 *  EJV 10/26/99-12/24/99 
 *
 *  NOTE:  
 *  the macro DEBUG can be defined in the makefile, it makes all the
 *  functions loud, i.e. they print when they are called.
 *  the default is #define DEBUG = 
 *  by setting     #define DEBUG = -DDEBUG 
 *  the user can turn on debug 
 *  or can turn on compilation debug info by setting #define DEBUG = -g
 *  #define DEBUG     print functions names on entry to all functions 
 */
/*  the macro NOT_PPC is defined in the makefile unix target and
 *  not defined in the makefile ppc (default) target because
 *  NOT_PPC is for gcc generating sun executables for debug
 *  makefile is for metaware/gcc for generating PPC executables
 *
 * #define NOT_PPC       compile for unix - for debug 
 */
/*  the macro DINKR12 is defined in the makefile  implied compile
 *  for use with dink R12.0 and beyond.
 */


/* File name: cmdtest.c */

#ifndef DINKR12  /*  notice  if undefined DINKR12  */
/*  This code is only for version of dink32 prior to Release 12.0,
 *  which include the release R11.0.2 which use static addresses.
 *  dink R12.0 and beyond use dynamic addresses.
The addresses defined in this file depend on the locations of
   the functions.  The addresses may be different with each version
   of DINK being built.  Make sure the addresses matches with what
   are defined in the dink_dir/ref.txt before running this l2test program
   These addresses correspond to dink32 V11.0.2

 */

                                                                
/*  These are the magic addresses for the DINK functions in Ver11.0.2  */   
#define  printf dink_printf
unsigned long (*dink_printf)() = (unsigned long (*)()) 0x6b58;
#endif   /* DINK32R12 */


#include "cmdtest.h"

#ifndef NOT_PPC
#ifdef   DINKR12
#include "../../dinkusr.h"
#endif   /* DINKR12 */
void smallscanf(char *, int *); /* understands one %d or %x int at a time */
#else
#define smallscanf scanf  /* use standard library if not ppc run */
#endif  /* NOT_PPC */

unsigned long MSRRead(void);
unsigned long CheckReg(void);

void MemWriteInit(void);
void MemWriteCheck(void);
void MemInit(void);
void TraceInit(void);
void TraceCheck(void);
void BpInit(void);
void BpCheck(void);
void DbatCheck(void);
void Dbatrestore(void);
void SetupSpin(void);
void Breakout(void);
void IBATWrite(void);
void DBATWrite(void);
void WriteMem(void);
void VRWrite(void);
void GPRInit(void);
void GPRCheck(void);
void GPRWrite(void);
void FPRWrite(void);
void MSRWrite(unsigned long);
unsigned long BATInit(void);
unsigned long HID0Init(void);
unsigned long HID0Read(void);
unsigned long HID0Write(int value);
unsigned long cacheFlush(void);
unsigned long DBATLRead(int number );
unsigned long DBATURead(int  number);
unsigned long IBATLRead(int number);
unsigned long IBATURead(int number);
unsigned long MemRead(int number);

void IcacheTest(void);
void DcacheTest(void);
void TraceTest(void);
void BPTest(void);
void DbatTest(void);
void IbatTest(void); 
void MemRWTest(void);
void HaltResumeTest(void);
void GPRTest(void);
void VRTest(void);
void FPRTest(void);

/* global variables  */
int chip_type; 
int dummy;
int MYSPACE[50];  /* Temporary memory location used to modify memory */

/***********************************************************
 *   main function:
 * This main routine will control the two menus which are  *
 * used to choose the processor under current use and the  *
 * individual tests which are being performed.             *
 * Each test will call its own subroutine which is written *
 * in PowerPC assembly.
 * RUN IN DINK32 BY STATING go 90000
 * 
 **********************************************************/
main()
{
int choice=0;

#ifdef DEBUG_FULL /*=========================================================*/

#ifdef  DINKR12
	set_up_transfer_base(); /*  get dink transfer table address */
#endif  /* DINKR12 */

#else
#ifdef  DINKR12
	set_up_transfer_base(); /*  get dink transfer table address */
#endif  /*  DINKR12 */

#endif  /* DEBUG_FULL ======================================================*/

          /*  turn on the caches  and set the dbats and ibats for this run*/
	printf("Initialize  HID0\n");

          /*  flush the caches initialize BATs */
	cacheFlush();
	HID0Write(0x8000c000);
	
	printf("*****************************************\n");
	printf("* Begin Command File Testing Procedures *\n");
	printf("*****************************************\n\n");
	chip_type=0;
        while(chip_type!=1 && chip_type!=2 && chip_type!=3 && chip_type!=4)
        {
	  printf("Please Select Current PowerPC processor: \n");
	  printf("1. 740/750 \n");
	  printf("2. 7400 \n");
 	  printf("3. 745/755 \n");
	  smallscanf ("%d",&chip_type);
	  printf("\nYou chose: %d\n",chip_type);
	  switch(chip_type)
	  {
	   case 1:
	    printf(" The MPC740/MPC750 interposer has Half Megabyte of L2 Cache\n");
	    MSRWrite(0x00003930);  /* Setup MSR */
	    break;
	   case 2:
	    printf(" The MPC7400 interposer has One Megabyte of L2 Cache\n");
	    MSRWrite(0x02003930); /* Enable vector assembly commands */
	    break;
	   case 3:
	    printf(" The MPC745/MPC755 interposer has Half Megabyte of L2 Cache\n");
 	    MSRWrite(0x00003930); /* Setup MSR */
	    break;
	   default:
	    printf("Invalid choice, %d, please choose 1-3\n\n",chip_type);
	    printf("Please enter a valid choice: \n");
	    smallscanf("%d",&chip_type);
	  }
	}

	while(choice != 12)
	{
	 printf("\nPlease Select Decired Test Routine:\n");
	 printf("=======================\n");
	 printf(" 1. Halt/Resume Test \n");
         printf(" 2. GPR Test\n");
       	 printf(" 3. FPR Test\n");
	 printf(" 4. VR Test\n");
         printf(" 5. Break Test \n");
         printf(" 6. Trace Test \n");
 	 printf(" 7. Memory Read/Write Test \n");
         printf(" 8. IBat Test \n");
 	 printf(" 9. DBat Test \n");
         printf("10. ICache Test \n");
	 printf("11. DCache Test\n");
	 printf("12. EXIT TEST PROCEDURE\n");
         printf("=======================\n");
	 smallscanf ("%d",&choice);
	 printf("\nYou chose test: %d\n",choice);
	 switch (choice)
	 {
	   case 1: /* Halt Resume Test */
	    HaltResumeTest();
   	    break;
	   case 2: /* General Purpose Register Test */
	    GPRTest();
	    break;
	   case 3: /* Floating Point Register Test */
	    FPRTest();
	    break;
	   case 4: /* Vector Register Test */
	    if(chip_type!=2) {
	      printf("Vector Registers only avaliable on 7400.\n");
	      break;
	    }
	    else { 
	      VRTest();
	      break;
	    }
	    break;
	   case 5: /* Breakpoint Test */
	    BPTest();
	    break;
	   case 6: /* Trace/Step Test */
	    TraceTest(); 
	    break;
	   case 7: /* Memory Read/Write Test */
	    MemRWTest();
	    break;
  	   case 8: /* IBAT Test */
	    IbatTest();
  	    break;
	   case 9: /* DBAT Test */
     	    DbatTest();
	    break;
	   case 10: /* Icache Test */
   	    IcacheTest();
            break;
	   case 11: /* Dcache Test */
	    DcacheTest();
	    break;
	   case 12:
	    printf("Thank you for chosing Jason's Testing Program.\n");
	    break;
	   default:
	    printf("Invalid choice, %d, please choose 1 through 12\n",choice);
	    choice=0;
	    break;
	 }
	}
}


/***********************************************************
 *   Halt Resume Test:
 *   This routine will verify the function of the Black Box 
 *   command file.  It will halt the processor and then 
 *   attempt to regain control by using interactions with the
 *   COP interface.  
 */
void HaltResumeTest()
{
    long int a;

    printf("\n\n******************************************************************\n");
    printf("This test routine will use an spinning icon to represent the processor.\n");
    printf("IF AT ANY TIME THE WINDOW FREEZES GO OVER TO BLACK BOX AND HIT\n"); 
    printf("'RESET'\n\n");
    printf("Hit <ENTER> to begin Halt/Resume test.\n");
    smallscanf("%d",&dummy);

    printf("STEP1>You will notice the icon slowly spinning. Go over to the \n");
    printf("Black Box window and type the following command:\n");
    printf("    >>update <ENTER> \n");
    printf("\nYou should notice the icon has stopped. If not then the halt \n");
    printf("function does not work properly. \n");
    printf("\nSTEP2>Now in the same window type the next command:\n");
    printf("    >>cop resume <ENTER> \n");
    printf("\nThe icon should now continue to spin. If not then there is \n");
    printf("something wrong with the resume function of the Black Box.\n");
    printf("\nSTEP3>To end this test go over to the Black Box window and \n");
    printf("type the following, using 2222 as the new value for the r22 reg:\n");
    printf("    >>update <ENTER>\n");
    printf("    >>rm r22 <ENTER>\n");
    printf("        gpr22: 0x00001234 : ? <new value> \n");
    printf("    >>push <ENTER> \n");
    printf("    >>go <ENTER> \n");

    SetupSpin();
    printf("\n\n            ");
    while(1)
    {
       printf("-");
       for(a=0;a<40000000;a++);
       printf("\b\\");
       for(a=0;a<40000000;a++);
       printf("\b|");
       for(a=0;a<40000000;a++);
       printf("\b/");
       for(a=0;a<40000000;a++);
       printf("\b");
       if(CheckReg()) break;
    }

    printf("\n\n********************************\n");
    printf("****Halt/Resume Test Passed!****\n"); 
    printf("********************************\n");
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
}


/*************************************************************************
*   General Purpose Register Test Routine
*   This test routine will begin by testing the Read function of the GPR
*   registers. It will use only a few random registers due to the fact that
*   some GPR's are reserved and cannot be altered during certain parts of the
*   program. The Write function of the GPRs will be tested by altering a 
*   certain register to a given value. The Read function will be tested by 
*   comparison.   
*/
void GPRTest()

{
    printf("\n\n******************************************************************\n");
    printf("This test routine will test the read and write functions of the GPR\n");
    printf("registers. IF AT ANY TIME THE WINDOW FREEZES, GO OVER TO BLACK BOX\n"); 
    printf("AND TYPE 'RESET'.\n");
    GPRInit();
    printf("STEP1>Go over to the Black Box window and type the following:\n");
    printf("    >>update  <ENTER>\n");
    printf("    >>rd r13-r16 <ENTER>\n");
    printf("    >>cop resume <ENTER>\n");
    printf("These 4 registers should have the value zero assigned to them.\n");
    printf("If not then GPR Read should be looked into.\n");
    printf("\nPlease hit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
    GPRWrite();
    printf("\n** GPRs r13-r16 have been written to! **\n");
    printf("\nSTEP2>Now the Read function of the GPR's will be tested.\n");
    printf("      Now go back to the Black Box window and type the following: \n");
    printf("    >>update <ENTER>\n");
    printf("    >>rd r13-r16 <ENTER>\n");
    printf("    >>cop resume <ENTER>\n");
    printf("\nThe registers should hold their corresponding register number.\n");
    printf("       r13=0x13    r14=0x14    r15=0x15    r16=0x16 \n");
    printf("If there are any differences then Read does not function properly.\n");
    printf("\nPlease hit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
    printf("\nSTEP3>Now the write function of the GPR's will be tested:\n");
    printf("      You will now attempt to modify a current register. After \n");
    printf("      the following command enter a value of 2222 for the new r13\n");
    printf("      register value. Type the following:\n");
    printf("    >>update <ENTER>\n");
    printf("    >>rm r13 <ENTER>\n");
    printf("        gpr13: 0x00000013 : ? <new value> \n");
    printf("      \nAfter updating r13 continue with the following in Black Box:\n");
    printf("    >>push <ENTER>\n");
    printf("    >>go <ENTER> \n"); 
    GPRCheck();
    printf("\n*****************************\n");
    printf(  "****GPR Write test passed****\n");
    printf(  "*****************************\n");
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
}

/************************************************************************
*   Vector Register Test Routine
* This routine will test the read and write function of the Vector 
* registers which are only available on the 7400. The read function will
* be tested by comparison while the write function will be tested by 
* modifing one of the registers.
* NOT COMPLETE. DUE TO INCONSISTANCIES IN HALT/RESUME ON 7400
*
*/
void VRTest()
{
    printf("\n\n******************************************************************\n");
    printf("STEP1>Please type the following commands in the Black Box window:\n");
    printf("IF AT ANY TIME THE WINDOW FREEZES, HIT 'RESET' IN THE BLACK BOX \n");
    printf("WINDOW.\n\n");	
    printf("    >>update <ENTER>\n");
    printf("    >>rd v <ENTER>\n");
    printf("    >>cop resume <ENTER>\n");
    printf("Hit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
    VRWrite();
    printf("\nSTEP2>Type the following commands in the Black Box window:\n");
    printf("    >>update <ENTER>\n");
    printf("    >>rd v <ENTER>\n");
    printf("    >>cop resume <ENTER>\n");
    printf("The value for the Vector Register should now hold a value of:\n");
    printf("   v5 = ??????? \n");
    printf("If this values do not match then the write portion of the vector\n");
    printf("registers is invalid.\n\n");
    printf("Hit <ENTER> within this window to continue.\n");
    smallscanf("\n%d",&dummy);

}

/*************************************************************************
*   Floating Point Register Test Routine
* This routine will test the floating point registers. It will test the 
* read function by writing to a few registers and then comparing them in 
* the black box window. The write function of the command file will be 
* tested by modifiing one register which should brake dink out of a loop
* which looks for a modification in one of the floating point registers.
* NOT COMPLETE. DUE TO INCONSISTANCIES OF COMMAND FILE.
*
*/
void FPRTest()
{
    printf("\n\n******************************************************************\n");
    printf("STEP1>Please type the following commands:\n");
    printf("    >>update <ENTER>\n");
    printf("    >>rd f <ENTER>\n");
    printf("    >>cop resume <ENTER>\n");
    printf("Now you should see a listing of all 32 floating point registers \n");
    printf("with a initial value of 0x318000000000000000\n");
    printf("Continue by hiting <ENTER> in this window.\n");
    smallscanf("%d",&dummy);
    FPRWrite();
    printf("\nSTEP2>Type the following commands in the Black Box window:\n");
    printf("    >>update <ENTER>\n");
    printf("    >>rd f10 <ENTER>\n");
    printf("    >>cop resume <ENTER>\n");
    printf("You should see a value of 0x??????? for the f10 register.\n");
    printf("If not then the FPR write routine should be looked at.\n\n");
    printf("Hit <ENTER> to continue.\n");
    smallscanf("%d",&dummy);
}

/*************************************************************************
*   Memory Read/Write Test Routine
*   This test will check the read and write functions of the command file.
*   It will write certain values within Dink and the user will then be 
*   asked to verify the values in the Black Box window. To test the write 
*   function, the program will maintain a loop check locations in memory for 
*   specific values. When the user modifies a piece of memory in the Black
*   Box window the program will escape and the user will regain control
*   of the Dink window. 
*/
void MemRWTest()
{
    printf("\n\n******************************************************************\n");
    printf("You will first begin by testing Memory Reads of the command file.\n");
    printf("TYPE 'RESET' IN THE BLACK BOX WINDOW IF THE DINK WINDOW FREEZES.\n");
    MemInit(); 
    printf("\nSTEP1>Type the following commands in the Black Box window:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>md 9403c-94048 <ENTER> \n");
    printf("    >>cop resume <ENTER> \n");
    printf("You should see a value of zero in the four locations in memory.\n");
    printf("If they are not zero then the current command file is invalid \n");
    printf("for this function.\n");
    printf("\nHit <ENTER> to continue.\n");
    smallscanf("%d",&dummy);
    WriteMem();
    printf("\nSTEP2>Now type the following cammands in Black Box:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>md 9403c <ENTER> \n");
    printf("    >>md 94040 <ENTER> \n");
    printf("    >>md 94044 <ENTER> \n");
    printf("    >>md 94048 <ENTER> \n");
    printf("    >>cop resume <ENTER> \n");
    printf("The four memory locations should now contain the following values:\n");
    printf("If these are different values then the current command file is \n");
    printf("invalid for this function.\n");
    printf("  0009403c: 00001111 \n");
    printf("  00094040: 00002222 \n");
    printf("  00094044: 00003333 \n");
    printf("  00094048: 00004444 \n\n"); 
    printf("Hit <ENTER> in this window to continue with Write Test.\n");
    smallscanf("%d",&dummy);
    printf("\nSTEP1>You will now begin the Memory Write test. You will change\n");
    printf("certain memory locations listed below. After each 'mm <addr>'\n");
    printf("command you will need to type the following value of <12345678>\n");
    printf("Type the following commands within Black Box entering the new \n");
    printf("value for each memory modify. PLEASE IGNORE ANY MEMORY WRITE ERRORS!\n");
    printf("    >>update <ENTER>\n");
    printf("    >>mm 9403c <ENTER>\n");
    printf("    >>mm 94040 <ENTER>\n");
    printf("    >>mm 94044 <ENTER>\n");
    printf("    >>mm 94048 <ENTER>\n");
    printf("    >>push <ENTER>\n");
    printf("    >>go <ENTER>\n");
    printf("\nHit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
    printf("\nSTEP2>The results should be as follows. If these values are not\n");
    printf("set to the value <12345678> then the write function of the command\n");
    printf("file is not correct.\n");
    printf("    9403c:0x%x\n",MemRead(0x0009403c));
    printf("    94040:0x%x\n",MemRead(0x00094040));
    printf("    94044:0x%x\n",MemRead(0x00094044));
    printf("    94048:0x%x\n",MemRead(0x00094048));
    printf("\nHit <ENTER> to continue.\n");
    smallscanf("%d",&dummy);

}

/**************************************************************************
*   IBAT Test Routine
* This test routine will test the IBAT registers available on PowerPC 
* processors. This only attempts to write to specific registers.
* NOT COMPLETE. DUE TO INCONSISTANCIES IN COMMAND FILE.
* WILL NOT WORK CORRECTLY. 
*
*/
void IbatTest()
{
    long int a; 
    printf("\n\n******************************************************************\n");
    printf("This test routine will test the Read and Write function of the two\n");
    printf("Ibat and Dbat registers. \n");
    printf("STEP1>Please type the following commands:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>rd ibat0u <ENTER>\n");
    printf("    >>rd ibat0l <ENTER> \n");
    printf("    >>rd ibat1u <ENTER> \n");
    printf("    >>rd ibat1l <ENTER> \n");
    printf("    >>rd ibat2u <ENTER> \n");
    printf("    >>rd ibat2l <ENTER> \n");
    printf("    >>rd ibat3u <ENTER> \n");
    printf("    >>rd ibat3l <ENTER> \n");
    printf("    >>cop resume <ENTER> \n");
    printf("The results should be as follows:\n");
    for(a=0; a<4; a++) {
       printf("   IBAT%dU = 0x%x\n",a,IBATURead(a));
       printf("   IBAT%dL = 0x%x\n",a,IBATLRead(a));
       }
    printf("Which verifies the Read function of the IBAT registers. \n");
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
    IBATWrite();
    printf("\nSTEP2>Retype the previous commands and compare with the following:\n");
    for(a=0; a<4; a++) {
       printf("   IBAT%dU = 0x%x\n",a,IBATURead(a));
       printf("   IBAT%dL = 0x%x\n",a,IBATLRead(a));
       }
    printf("A match will verify the write function of the IBAT registers.\n\n");
    printf("Hit <ENTER> in this window to continue. \n");
    smallscanf("%d",&dummy);
}

/*************************************************************************
*   DABT Test Routine
*   This routine will test the Read and Write functions of the DBAT registers.
*   The user will first test the Read function by comparing the register 
*   values of the DBATs which are given specific values by the test routine.
*   To test the Write function the user will be asked to change a certain 
*   DABT register to a given value in order to complete the test routine.
*   Before returning to the main menu, the test routine will restore the DBATS
*   to their orginal values. 
*/
void DbatTest()
{
 long int a; 
    printf("\n\n********************************************************************\n");
    printf("This routine will test the Read and Write functions of the DBAT\n");
    printf("registers. IF AT ANY TIME THIS WINDOW FREEZES TYPE 'RESET' WITHIN\n");
    printf("THE BLACK BOX WINDOW.\n\n");
    printf("STEP1>Type the following commands in the Black Box window:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>rd dbat0u <ENTER> \n");
    printf("    >>rd dbat0l <ENTER> \n");
    printf("    >>rd dbat1u <ENTER> \n");
    printf("    >>rd dbat1l <ENTER> \n");
    printf("    >>rd dbat2u <ENTER> \n");
    printf("    >>rd dbat2l <ENTER> \n");
    printf("    >>rd dbat3u <ENTER> \n");
    printf("    >>rd dbat3l <ENTER> \n");
    printf("    >>cop resume <ENTER> \n");
    printf("The results should be as follows:\n");
    for(a=0; a<4; a++) {
       printf("   DBAT%dU = 0x%x\n",a,DBATURead(a));
       printf("   DBAT%dL = 0x%x\n",a,DBATLRead(a));
       }
    printf("Which verifies the Read function of the DBAT registers.\n");
    printf("\nHit <ENTER> to continue. \n");
    smallscanf("%d",&dummy);
    DBATWrite();
    printf("STEP2>Retype the previous commands and compare with the following:\n");
    for(a=0; a<4; a++) {
       printf("   DBAT%dU = 0x%x\n",a,DBATURead(a));
       printf("   DBAT%dL = 0x%x\n",a,DBATLRead(a));
       }
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
    Dbatrestore();
    printf("\nSTEP3>The Write function of the DBAT registers will now be tested.\n");
    printf("Go over to the Black Box window and type the following commands:\n");
    printf("Changing the dbat3u register to a value of 0x12.\n");
    printf("    >>update <ENTER> \n");
    printf("    >>rm dbat3u <ENTER> \n");
    printf("  dbat3u: 0x00000000 ? <new value> \n");
    printf("    >>push <ENTER> \n");
    printf("    >>go <ENTER> \n");
    DbatCheck();

    printf("\n**************************\n");
    printf(  "* DBAT Write Test Passed *\n");
    printf(  "**************************\n\n");
    printf("Hit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
}

/**************************************************************************
*   Breakpoint Test Routine
* This test routine will test the breakpoint functionality of the command
* files. It will issue a breakpoint at a known value in memory which has 
* lines of code which modify GPRs one by one. If the breakpoints do work 
* then the result should be as described below. 
*/
void BPTest() 
{
    printf("\n\n******************************************************************\n");
    BpInit();
    printf("STEP1>Type the following commands within the Black Box window:\n");
    printf("IF AT ANY TIME THE WINDOW FREEZES HIT 'RESET' IN THE BLACK BOX \n");
    printf("WINDOW TO CONTINUE.\n\n");
    printf("    >>update <ENTER> \n");
    printf("    >>rd r14-r17 <ENTER> \n");
    printf("    >>cop resume <ENTER> \n");
    printf("\nYou should see the four registers with a value of zero.\n");
    printf("Hit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
    printf("\nSTEP2>Go over to the Black Box window and type the following:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>bs -i 916e4 <ENTER> \n");
    printf("    >>push <ENTER> \n");
    printf("    >>go <ENTER> \n");
    printf("\nYou have now set the instruction breakpoint.\n");
    printf("Hit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
    printf("\nSTEP3>Go to the Black Box window and type the following:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>rd r14-r17 <ENTER> \n\n");
    printf("Only the first two registers should have been written to. If the\n");
    printf("words 'dead' or 'beef' appear in any of the other registers, then\n");
    printf("the breakpoint did not set properly.\n");
    printf("\nSTEP4>To continue execution type the following commands within\n");
    printf("the Black Box window:\n");
    printf("    >>bd -i <ENTER> \n");
    printf("    >>push <ENTER>\n");
    printf("    >>go <ENTER> \n");
    BpCheck();
    printf("**************************\n");
    printf("* Breakpoint Test passed *\n");
    printf("**************************\n");
    printf("\nHit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
}

/***************************************************************************
*   Trace/Step Test Routine
* This test routine will make sure the black box is able to set up a trace 
* and step through line by line. The address is determined by reading the 
* xref.txt file and determining where the TraceCheck subroutine is located 
* in memory. 
*/
void TraceTest() 
{
    printf("\n\n******************************************************************\n");
    TraceInit();
    printf("STEP1>Type the following commands in the Black Box window:\n");
    printf("IF AT ANY TIME THE WINDOW FREEZES, HIT 'RESET' IN BLACK BOX TO \n");    printf("REGAIN CONTROL.\n\n");
    printf("    >>update <ENTER>\n");
    printf("    >>rd r14-r19 <ENTER> \n");
    printf("    >>cop resume <ENTER> \n");
    printf("These six registers should hold a value of zero. Otherwise the\n");
    printf("read function of the GPR registers should be looked at.\n");
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
    printf("\nSTEP2>Now type the following commands in Black Box:\n");
    printf("    >>update <ENTER> \n");
    printf("    >>st 9171c <ENTER>\n\n");
    printf("STEP3>You should be able to type 'st' one at a time and see the IAR\n");
    printf("increment after each depression. Each time issue a 'rd14-r17'\n");
    printf("to see the registers change their value.\n");
    printf("If this does not work then the trace functionality is invalid.\n");
    printf("For example: \n");
    printf("    **st <ENTER> \n");
    printf("    **rd r14-r19 <ENTER> \n");
    printf(" gpr14: 00000014         gpr15: 00000015 \n");
    printf(" gpr16: 00000000         gpr17: 00000000 \n"); 
    printf(" gpr18: 00000000         gpr19: 00000000 \n");
    printf("    **st <ENTER> \n\n");
    printf("STEP4>To clear the trace intstruction step and continue execution,\n");
    printf("issue the following command.\n"); 
    printf("     >>st - <ENTER> \n");
    TraceCheck();
    printf("*********************\n");
    printf("* Trace Test Passed *\n");
    printf("*********************\n\n");
    printf("Hit <ENTER> within this window to continue.\n");
    smallscanf("%d",&dummy);
}

/*************************************
*   Instruction Cache Test Routine
* NOT COMPLETE. DUE TO INVALIDNESS IN COMMAND FILE
*/
void IcacheTest()
{
    printf("\n\n******************************************************************\n");
    printf("Not currently avaliable due to the current system setup.\n");
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);
}

/************************************
*   Data Cache Test Routine
* NOT COMPLETE. DUE TO INVALIDNESS IN COMMAND FILES
*/
void DcacheTest()
{
    printf("\n\n******************************************************************\n");
    printf("Not currently avaliable due to the current system setup.\n");
    printf("\nHit <ENTER> in this window to continue.\n");
    smallscanf("%d",&dummy);

}