# This is an ide startup file.
report=4 # set verbose, but not debug
$stoponerr=1
hinv -v

echo ""
echo "Ide included scripts are"
echo "	memory		ip20            cpudsp"
echo "	lg1		lg1_dma		lg1_all		srv2"
echo "	gr2_initsys     clear           gr2"
echo "	gr2_quad        gr2_fourquad    gr2_quadserial"
echo "	gr2_vdma"
echo "	kv              cc1             ab1"
echo "	ab1_red         ab1_green       ab1_blue"



printf "\n  - define list,"
list {
  if ($$ == 1) {
    printf "list "
    symbols -l
    printf "\n"
    return 0
  } else {
    $res_ult = symbols -t $1
    return $res_ult
  }
}

printf " match,"
match {
  if ($$ == 1) {
    printf "usage: match KEYSTRING\n"
    return -1
  } else {
    $res_ult = symbols -k $1
    return $res_ult
  }
}

printf " hx,"
hx {
  printf "0x%x\n" $1
}


# define simple usec, msec, and second delays
# printf "  - delays with intervals of usec, msec, and second granularity:\n"
# printf "    --> us_delay, ms_delay, and sleep.\n    usages: "
# printf "    'us_delay USECS'   'ms_delay MSECS'   'sleep SECS'\n"

us_delay {
  ide_delay -u $1
}
# eg: 'us_delay 100'

ms_delay {
  ide_delay -m $1
}
# eg: 'ms_delay 15'

sleep {
  ide_delay -s $1
}
# eg: 'sleep 5'

printf " symcmd, and charcmd\n"
# demonstrate parameter-passing for user-defined commands which 
# call functions using the 'sym_t *' argv format
symcmd {
  test_symcmd $1 $2
}

# and for udef commands calling functions using 'char *' argv format
charcmd {
  test_charcmd  $1 $2
}



# Startup script for the CPU DSP diagnostics

cpudsp {
# DSP static RAM
if ((cpudsp_sram) && $stoponerr)
	wait;

if ((dsp56) && $stoponerr)
	wait;

# END OF CPU DSP SCRIPT
}

# memory and cache test
memory {
$tmp = memtest;
if ($tmp && $stoponerr)
	wait;

$tmp = ldram;
if ($tmp && $stoponerr)
	wait;

$tmp = ldram -p;
if ($tmp && $stoponerr)
	wait;

$tmp = dram;
if ($tmp && $stoponerr)
	wait;

$tmp = dram -p;
if ($tmp && $stoponerr)
	wait;

$tmp = dcache1;
if ($tmp && $stoponerr)
	wait;

$tmp = icache1;
if ($tmp && $stoponerr)
	wait;

$tmp = icache2;
if ($tmp && $stoponerr)
	wait;

$tmp = scache1;
if ($tmp && $stoponerr)
	wait;
}
# END OF MEMORY SCRIPT

# THE FOLLOWING IS THE STARTUP SCRIPT FOR THE CPU DIAGNOSTICS.
#
# IN ORDER FOR THE SCRIPT TO RUN PROPERLY, THE FOLLOWING MUST BE DONE:
#	1. CONNECT THE TRANSMIT AND RECEIVE PINS ON CHANNEL A AND B OF DUART 0,
#	   CHANNEL B OF DUART 1 (FOR CHANNEL B OF DUART 1, THE REQUEST_TO_SEND
#	   AND CLEAR_TO_SEND PINS MUST ALSO BE CONNECTED).
#	2. CONNECT A MICROPHONE AND A SPEAKER TO THE AUDIO CIRCUITRY.
#	3. CONNECT A ETHERNET CABLE TO THE ONBOARD ETHERNET CONNECTOR, THE CABLE
#	   MUST BE CONNECTED TO A TRANSCEIVER.

ip20 {
# Interrupt mask registers data test.
if ((int2) && $stoponerr)
	wait;

# TLB test. Verify different tlb functions.
if ((tlb) && $stoponerr)
	wait;

# UTLB miss exception test. Verify the exception generating capability of the
# mips chip during a utlb miss.
if ((utlb) && $stoponerr)
	wait;

# Real time clock test. Verify the accuracy of the real time clock and the carry
# circuitry by using the timer within the ctl1 gate array.
if ((!clock) && $stoponerr)
	wait;

# Interval timer test. Verify the accuracy of the interval timer by using the
# real time clock.
if ((!timer) && $stoponerr)
	wait;

# DUART 0A/keyboard, 0B/mouse, 1B/modem, internal loopback test. Execute the
# internal loopback diagnostics provided by the DUART chips.
$tmp = duart -i0;
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

$tmp = duart -i1;
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

$tmp = duart -i2;
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

$tmp = duart -i3;
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

# DUART 0A/keyboard, 0B/mouse, 1B/modem, external loopback test. verify the
# operation of the DUART channels by simulating actual transmission.
# JUMPERS ARE NEEDED TO CONNECT TRANSMIT AND RECEIVE PINS ON ALL CHANNELS,
# REQUEST_TO_SEND AND CLEAR_TO_SEND PINS ON CHANNEL B OF DUART 1.
# >> FOR FIELD ENGINEERING ONLY <<
if ($report == 4) {
    $tmp = duart -e0;
}
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

if ($report == 4) {
    $tmp = duart -e2;
}
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

if ($report == 4) {
    $tmp = duart -e3;
}
if ($tmp) {
    resetcons 1;
    if ($stoponerr)
	wait;
}

# Since we just trashed the keyboard and mouse DUARTs let's reset the keyboard.
resetcons 1

# EEPROM pin signal test. Verify the pin signals provided for the EEPROM.
#if ((nvram5) && $stoponerr)
#	wait;

# Graphics dma channel register data test.

# HPC1 peripheral controller register data test.
if ((hpc1) && $stoponerr)
	wait;

# Test floating point unit
$fpufailed=0;
if ((!fpu) && $stoponerr)
	wait;

# Test local memory 0-4Mbytes
#if ((ldram) && $stoponerr)
#	wait;
#
#$tmp = ldram -p
#if ($tmp && $stoponerr)
#	wait;

# Test parity checking mechanism
if ((parity) && $stoponerr)
	wait;

# Test local memory above the 4 Mbytes mark
if ((dram) && $stoponerr)
	wait;
$tmp = dram -p
if ($tmp && $stoponerr)
	wait;

if ((memtest) && $stoponerr)
	wait;

# Test SCSI devices
$status1=scsi;
# Don't exercise the disk
#$status2=xscsi;
#$scsi_status=$status1 | $status2;
$scsi_status=$status1
$scsifailed = 0;
if (($scsi_status & 257) && $stoponerr) {
	# SCSI chip 0 or 1 failure
	wait;
}
if (($scsi_status & 98175) && $stoponerr) {
# 0x10000 (cabling) or any scsi device failure (not 1 or 0x100, which
# means chip failure, since for now, chip is always ID 0)
# scsi() puts the failure in a global for emfail.
	wait;
}

# END OF IP20 SCRIPT
}

# THE FOLLOWING IS THE STARTUP SCRIPT FOR THE LG1 GRAPHICS DIAGNOSTICS.
lg1 {
$lg1failed=0;
initgr
lg1_wsysctl 0x3d
buffon;

# REX register test
if (lg1_rexregs) {
    if (!$report) {
	emfail 2;
	wait;
	exit;
    }
    $lg1failed=1;
}

# VRAM test
if (lg1_vram) {
    if (!$report) {
	emfail 2;
	wait;
	exit;
    }
    $lg1failed=1;
}

# CID test
if (lg1_cid) {
    if (!$report) {
	emfail 2;
	wait;
	exit;
    }
    $lg1failed=1;
}

# VC1 register test
if (lg1_vc1regs) {
    if (!$report) {
	emfail 2;
	wait;
	exit;
    }
    $lg1failed=1;
}

# VC1 SRAM test
if (lg1_sram) {
    if (!$report) {
	emfail 2;
	wait;
	exit;
    }
    $lg1failed=1;
}

# DAC test
if (lg1_dac) {
    if (!$report) {
	emfail 2;
	wait;
	exit;
    }
    $lg1failed=1;
}

# DMA test
#if (lg1_dma) {
#    if (!$report) {
#	emfail 2;
#	wait;
#	exit;
#    }
#    $lg1failed=1;
#}

resetcons;
buffoff;

# END OF LG1 SCRIPT
}

# Multi-head support for LG1

lg1_all {
	$lg1failed = 2;
	$tmp = lg1_setboard 0;
	if ($tmp) {
		lg1;
	}
	$lg1_board0_failed = $lg1failed;
	$lg1failed = 2;
	$tmp = lg1_setboard 1;
	if ($tmp) {
		lg1;
	}
	$lg1_board1_failed = $lg1failed;
}

# LG1 VDMA DIAGNOSTICS.

lg1_dma {
        initgr
        lg1_probe
        lg1_cachefdma   800
        lg1_yzoomdma    800 700
        lg1_stridedma   512 0
        lg1_stridedma   512 -512
        lg1_mfilldma    1024 1
        lg1_mfilldma    1 1024
        lg1_sbdma       512 0
        lg1_sbdma       512 1
        lg1_sbdma       512 2
        lg1_sbdma       512 3
	lg1_decreadrdma 512 
        buffon;
}
# END OF LG1 VDMA DIAGNOSTICS


# Start of GR2 diagnostics 
gr2_vhwinit {
$grbd = gr2_getGR2ver;
if ($grbd < 4) { 
	gr2_videoclk 0x4;
	gr2_wrconfig 0x0;
	gr2_initclock 0x107b;
	gr2_wrconfig 0x40;
} else {
	gr2_videoclk 0x47;
 	gr2_initclock 0x107;
	gr2_wrconfig 0x0;
	gr2_delay 3;
 	gr2_wrconfig 0x1;
}
fi
gr2_vinitdac
}
gr2_initre {
	$a = gr2_getGR2ver;
	if ($a < 4) gr2_wrfifo 0 0;
	else if ($a == 4) gr2_wrfifo 0 1;
	else gr2_wrfifo 0 2;
}
gr2_initsys {
gr2_reset
gr2_vhwinit
gr2_xcol
$mon = gr2_getMonType;
if ($mon == 1) gr2_initvc1 4;
else gr2_initvc1 20;
fi
gr2_inithq
gr2_load_ucode ge
gr2_load_ucode hq
gr2_unstall
gr2_initre
}
clear {
gr2_wrfifo 35 0
gr2_wrfifo 6 0
}
gr2_quad {
gr2_wrfifo 33 0
}
gr2_fourquad {
gr2_wrfifo 34 0
}
srv2 {
lg1_video
lg1_video -f -l5
lg1_video -c -l5
}

$tmp = 0;
$failed = 0;
  
test_xmap{
	gr2_initsys;
	$a=gr2_txmap;
	return $a;
	}

test_xmap_clut{
	gr2_initsys;
	$a=gr2_txmap_clut;
	return $a;
	}

gr2_vdma{
	gr2_initsys;
	$b=gr2_cachefdma 32 1;
	$b=$b+gr2_cachefdma 256 1;
	$b=$b+gr2_cachefdma 512 1;
	$b=$b+gr2_cachefdma 128 1;
	$b=$b+gr2_yzoomdma ;
	$b=$b+gr2_yzoomdma 32 32;
	$b=$b+gr2_yzoomdma 128 128;
	$b=$b+gr2_yzoomdma 256 256;
	$b=$b+gr2_stridedma;
	$b=$b+gr2_stridedma 32 32;
	$b=$b+gr2_stridedma 256 1;
	$b=$b+gr2_stridedma 512 0;
	return $b;
	}

gr2 {
	$vc1_sram_failed=0;
	$tram0_failed=0;
	$tram1_failed=0;
	$tram2_failed=0;
	$tram3_failed=0;
	$tram8_failed=0;
	$tram9_failed=0;
	$tram10_failed=0;
	$hq2test_failed=0;
	$shram_failed=0;
	$ram12_failed=0;
	$seedrom_failed=0;
	$sqrom_failed=0;
	$gebus_failed=0;
	$gefloat_failed=0;
	$chkbt457_failed=0;
	$shramre3_failed=0;
	$cpushram_failed=0;
	$cpure3_failed=0;
	$ctxsw_failed=0;
	$quad_failed=0;
	$fourquad_failed=0;
	$bp_failed=0;
	$stride_failed=0;
	$zb_failed=0;
	$test_xmap_failed=0;
	$test_xmap_clut_failed=0;
	$vdma_failed=0;


	$failed=0;
	gr2_reset;
	buffon


# HQ2 internal register 19  must read 0xdeadbeef
	gr2_rdhqint 19;

# Test VC1 SRAM 
	gr2_vhwinit
	if (gr2_vc1_sram) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $vc1_sram_failed = 1;
	}
# Test ram 0 at Ge7 at 0
	$tmp = gr2_tram 0;
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram0_failed = 1;
	  }
# Test ram 0 at Ge7 at 1
	$tmp = gr2_tram 1;
	if ($tmp){
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram1_failed = $tmp;
	}
# Test ram 0 at Ge7 at 2
       $tmp = gr2_tram 2;
       if ($tmp){
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram2_failed = 1;
	}
# Test ram 0 at Ge7 at 3
	$tmp = gr2_tram 3 ;
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram3_failed = 1;
	}
# Test shram  
	$tmp = gr2_tram 8 ;
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram8_failed = 1;
	}
# Test Hq2uram
	$tmp = gr2_tram 9 ;
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram9_failed = $tmp;
	}
# Test ge7uram
	$tmp = gr2_tram 10;
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $tram10_failed = $tmp;
	 }
	gr2_initsys;
	clear;

# Test HQ2
	if(gr2_hq2test) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $hq2test_failed = 1;
	}
# Test shareram using Ucode
	if (gr2_shram) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $shram_failed = 1;
	}
# Test internal GE7 ram
	if (gr2_ram12) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $ram12_failed =1;
	}
# Test seedrom 
	if (gr2_seedrom) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $seedrom_failed =1;
	}
# Test the squaroot rom
	if (gr2_sqrom) { 
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $sqrom_failed =1;
	}
	gr2_initsys ;

# Test Ge 7 bus
	if (gr2_gebus) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $gebus_failed =1;
	}

# Test ge floating point unit
	if (gr2_gefloat) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $gefloat_failed = 1;
	}
	gr2_initsys;
	clear;
resetcons
buffoff
$err = 0;
if ($vc1_sram_failed)
{
	echo "VC1 SRAM  test failed"; 
	$err = 1
} 
if ($tram0_failed)
{ 
	echo "Ram 0 at GE7 - 0 failed "; 
	$err = 1
} 
if ($tram1_failed)
{ 
	echo "Ram 0 at GE7 - 1 failed "; 
	$err = 1
} 
if ($tram2_failed)
{ 
	echo "Ram 0 at GE7 - 2 failed "; 
	$err = 1
} 
if ($tram3_failed)
{ 
	echo "Ram 0 at GE7 - 3 failed "; 
	$err = 1
} 
if ($tram8_failed)
{ 
	echo "Share ram test failed "; 
	$err = 1
}
if ($tram9_failed)
{ 
	echo "Hq2uram  ram failed "; 
	$err = 1
}
if ($tram10_failed)  
{ 
	echo "ge7uram failed " ;
	$err = 1
}
if ($hq2test_failed)
{ 
	echo "HQ2 Test failed ";
	$err = 1
}
if ($shram_failed)
{ 
	echo "shram test failed";
	$err = 1
}
if ($ram12_failed)
{
	echo "GE7 ram 1/2 test failed "; 
	$err = 1
}
if ($seedrom_failed) 
{ 
	echo "seedrom test failed ";
	$err = 1
}
if ($sqrom_failed)
{
	echo "squaroot test failed";
	$err = 1
}
if ($gebus_failed) 
{ 
	echo "gebus test failed";
	$err = 1
}
if ($gefloat_failed)  
{ 
	echo "gefloat test failed";
	$err = 1
}

if ( $err )
{
    if (!$report) {
       	emfail 2;
       	wait;
       	exit;
    }	
echo "HQ & GE Tests failed\n";
wait
$err=0
$failed=1
}
else echo "HQ & GE Tests passed\n"
buffon

# Test bt457 
	if (gr2_chkbt457) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $chkbt457_failed = 1;
	    $err=1;
	}
# Test Shared ram and Re
	gr2_initsys
	$tmp = gr2_shramre3
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $shramre3_failed =1;
	    $err=1;
	}
# Test DMA between host and GE7 shared ram
	gr2_initsys
	clear
	$tmp = gr2_cpushram
	if ($tmp)  {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $cpushram_failed =1;
	    $err=1;
	}
# Test DMA between host and and RE3
	resetcons
	buffon
	gr2_initsys
	$tmp = gr2_cpure3
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $cpure3_failed =1;
	    $err=1;
	}
# Test VDMA controller
	if(gr2_vdma) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $vdma_failed =1;
	    $err=1;
	}
# Test GE7 context switching
	if(gr2_ctxsw) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $ctxsw_failed =1;
	    $err=1;
	}
	clear;
# Test quad drawing
	$tmp = gr2_quad
	if ($tmp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $quad_failed =1;
	    $err=1;
	}
	$tmp = gr2_fourquad
	if ($tmp){
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $fourquad_failed = 1;
	    $err=1;
	}
	clear;
resetcons
buffoff
if ($chkbt457_failed) echo "Bt457 test failed";
if ($shramre3_failed) echo "shramre3 test failed"
if ($cpushram_failed) echo "CPU shram test failed";
if ($cpure3_failed) echo "cpure3 test failed ";
if ($ctxsw_failed) echo "context switching test failed ";
if ($vdma_failed) echo "vdma controller test failed ";
if ($quad_failed) echo "quad test failed";
if ($fourquad_failed) echo "fourquad test failed";

if ($err)
{
    if (!$report) {
       	emfail 2;
       	wait;
       	exit;
    }	
echo "******  PRESS RETURN TO CONTINUE OR ^C TO EXIT ************"
wait
$err=0
$failed=1
}
else echo "BT457, DMA and QUADs Tests Passed.\n"
buffon

# Test bitplane VM2
	gr2_initsys
	if (gr2_bp) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $bp_failed = 1;
	    $err=1;
	}
# Test stridedma between shram and re3
	resetcons
	buffon
	gr2_initsys
	$tmp = gr2_stride
	if ($tmp)  {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $stride_failed =1 ;
	    $err=1;
	}
# Test Zbuffer
	gr2_initsys
	$tmp=gr2_zb
	if($tmp)  {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $zb_failed =1;
	    $err=1;
	}
# Test Xmap 
	if (test_xmap) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $test_xmap_failed =1;
	    $err=1;
	}
# Test Xmap CLUT 
	if (test_xmap_clut) {
	    if (!$report) {
        	emfail 2;
        	wait;
        	exit;
    	    }	
	    $test_xmap_clut_failed =1;
	    $err=1;
	}
resetcons
buffoff
echo "************************* RESULTS ********************************"
if ($bp_failed) {
  echo "bitplane test failed";
  $failed = 1;
}
if ($stride_failed)  {
   echo "stride test failed";
   $failed = 1;
}
if ($zb_failed) { 
   echo "Zbuffer test failed";
  $failed = 1;
}
if ($test_xmap_failed) {
   echo "test_xmap test failed";
  $failed = 1;
}
if ($test_xmap_clut_failed) {
   echo "test_xmap_clut test failed";
  $failed = 1;
}
if (!$err) echo "Frame Buffer, Bit-Plane, and XMAPs Test Passed.\n"
resetcons 
buffoff
if ($failed) echo "ERROR: Failure detected on graphics board."
else echo "graphics board tests passed"
fi
echo " *****************END OF THE TEST *****************"
}
# END OF GR2 SUPPORT

#Start of Galileo diagnostics
CheckSlot {
		echo "GR2 Board Found in slot 0."
}

cc1 {
	CheckSlot;
	echo "CC1 Frame Buffer Test";
	$status =ev1_init ;
	if ($status)  {
		echo " Galileo Board Initialization FAILED"
		return ($status);
	}
	echo "Galileo Board Initialized Properly"
	echo "CC1 Memory Test";
	$status = cc1_mem;
	if ($status) 
		wait;
	echo "CC1 (DMA MODE)Memory Test";
	$status = cc1_dma;
	if ($status) 
		wait;
}

ab1_red {
	CheckSlot;
	$status =ev1_init ;
	if ($status)  {
		echo " Galileo Board Initialization FAILED"
		return ($status);
	}
	echo "Galileo Board Initialized Properly"
	echo "AB1 Red Channel Memory Test ";
	ab1_rmem;
}

ab1_blue {
	CheckSlot;
	$status =ev1_init ;
	if ($status)  {
		echo " Galileo Board Initialization FAILED"
		return ($status);
	}
	echo "Galileo Board Initialized Properly"
	echo "AB1 Blue Channel Memory Test ";
	ab1_bmem;
}

ab1_green {
	CheckSlot;
	$status =ev1_init ;
	if ($status)  {
		echo " Galileo Board Initialization FAILED"
		return ($status);
	}
	echo "Galileo Board Initialized Properly"
	echo "AB1 Green Channel Memory Test ";
	ab1_gmem;
}

ab1 {
	CheckSlot;
	$status =ev1_init ;
	if ($status)  {
		echo " Galileo Board Initialization FAILED"
		return ($status);
	}
	echo "Galileo Board Initialized Properly"
	echo "AB1 Memory Test (Red, Green, Blue)";
	status = ab1_mem;
	if ($status) 
		wait;
}

kv {
	CheckSlot;
	$status =ev1_init ;
	if ($status)  {
		echo " Galileo Board Initialization FAILED"
		return ($status);
	}
	echo "Galileo Board Initialized Properly"
	echo "Test Disply Control Bus";
	$status = ev1_dcb;
	if ($status)
		wait;
	echo "CC1 Memory Test";
	cc1;
	echo "AB1 Memory Test (Red, Green, Blue)";
	ab1;
}


#END of Galileo diagnostics