//
//  memtest.c - Copyright 1998 (c) Kevin W Ross, all rights reserved
//
// This program implements a set of test functions for the sermem routines 
// You need to compile this and set the address of the interrupt_vectors segment
// to be up in the interrupt area. On the Imagecraft compiler, the command line
// argument
//
// -binterrupt_vectors=0xffd0
//
// will do the trick!


#define _SCI
#include <stdio.h>
#include <hc12.h>
#include "sermem.h"

void main();

void _HC12Setup(void)
{
  COPCTL &=0xF8;     /* disable COP */
}
	
int MemCompare(unsigned char *src, unsigned char *data, int count, int address)
{
	 int i;
	 for(i=0;i<count;i++)
	 {
	 	 if(src[i] != data[i])
		 {
		     printf("MemCompare failed at %d src(%u) data(%u)\n",
			 		address+i,
					src[i],
					data[i]);
			 return 0;
		 }
	 }
	 return 1;
}
void FillTest(unsigned char byte)
{
	 unsigned char buf[SERMEM_PAGE_SIZE*2];
	 int i;
	 
	 
	 //
	 // Fill the entire memory array with 'byte', then read them all back in to
	 // determine if the fill worked correctly.
	 //
	 printf("Fill Test (%u) Started...",byte);
	 sermem_Fill(0,byte,SERMEM_SIZE);
	 
	 // Test the entire array
	 for(i=0;i<SERMEM_SIZE;i+=sizeof(buf))
	 {
	    int j;
	 	sermem_ReadBlock(i,buf,sizeof(buf));
		for(j=0;j<sizeof(buf);j++)
		{
			if(buf[j] != byte)
			{
				printf("failed: offset %d, read (%u)\n",i+j,buf[j]);
				return;
			}
		}
	 }
	 // Zero fill the entire array
	 sermem_Fill(0,0,SERMEM_SIZE);
	 
	 // Test a page worth
	 sermem_Fill(SERMEM_PAGE_SIZE/2,byte,SERMEM_PAGE_SIZE);
	 
	 // Test the entire array
	 {
	    int j;
		i = SERMEM_PAGE_SIZE/2;
	 	sermem_ReadBlock(SERMEM_PAGE_SIZE/2,buf,SERMEM_PAGE_SIZE);
		for(j=0;j<SERMEM_PAGE_SIZE;j++)
		{
			if(buf[j] != byte)
			{
				printf("failed: offset %d, read (%u)\n",i+j,buf[j]);
				return;
			}
		}
	 }
	 printf("Success!\n");
}
void DataTest()
{
 	 unsigned char buf[SERMEM_PAGE_SIZE*2];
	 int i;
	 unsigned char *p = (unsigned char *)main;
	 //
	 // Do a couple of boundary cases, such as crossing page boundaries, etc
	 // We need a fairly large buffer for this, so we are going to use the
	 // code space.
	 //
	 printf("Data Test Start....");
	 // First test, write a large block, then read it back to verify it worked
	 sermem_WriteBlock(0,p,sizeof(buf));
	 sermem_ReadBlock(0,buf,sizeof(buf));
	 
	 if(!MemCompare(p,buf,sizeof(buf),0))
	 {
	 	printf("Data Test 1 Failed!\n");
		return;
	 }
	 
	 // Bump the code address up by 1 byte. That assures we aren't just
	 // reading and writing the same data all the time.
	 p++;
	 
	 //
	 // Start half way through a page, and span to the other half. This should
	 // incur two partial writes
	 //
	 
	 sermem_WriteBlock(SERMEM_PAGE_SIZE/2,p,sizeof(buf));
	 sermem_ReadBlock(SERMEM_PAGE_SIZE/2,buf,sizeof(buf));
	 
	 if(!MemCompare(p,buf,sizeof(buf),SERMEM_PAGE_SIZE/2))
	 {
	 	printf("Data Test 2 Failed!\n");
		return;
	 }
	 
     // Bump the code address up by 1 byte. That assures we aren't just
	 // reading and writing the same data all the time.
	 p++;
	 
	 //
	 // Write a single byte at the end of the page.
	 //
	 
	 sermem_WriteBlock(SERMEM_PAGE_SIZE-1,p,1);
	 sermem_ReadBlock(SERMEM_PAGE_SIZE-1,buf,1);
	 
	 if(!MemCompare(p,buf,1,SERMEM_PAGE_SIZE-1))
	 {
	 	printf("Data Test 3 Failed!\n");
		return;
	 }	 
	 //
	 // Write a single byte at the start of the page.
	 //
	 
	 sermem_WriteBlock(SERMEM_PAGE_SIZE,p,1);
	 sermem_ReadBlock(SERMEM_PAGE_SIZE,buf,1);
	 
	 if(!MemCompare(p,buf,1,SERMEM_PAGE_SIZE))
	 {
	 	printf("Data Test 4 Failed!\n");
		return;
	 }	 
	 //
	 // Write a couple of bytes at the start of the page.
	 //
	 
	 sermem_WriteBlock(SERMEM_PAGE_SIZE,p,3);
	 sermem_ReadBlock(SERMEM_PAGE_SIZE,buf,3);
	 
	 if(!MemCompare(p,buf,3,SERMEM_PAGE_SIZE))
	 {
	 	printf("Data Test 5 Failed!\n");
		return;
	 }	 
	 printf("Success!\n");
}

void main()
{
	 char buf[32];
	 COPCTL = 0;
	 
	 setbaud(BAUD19K);
	 printf("memtest.c started\n");
	 
	 sermem_Initialize();
	 sermem_BlockProtection(0);

	 FillTest(0);
	 FillTest(0xAA);
	 DataTest();
	 for(;;)
	 {
	 	char c =  ((SC0SR1 & RDRF) == 0)? 0 : SC0DRL;
		switch (c)
		{
		case 't':
		  {
		  	 FillTest(0);
			 FillTest(255);
			 FillTest(0xAA);
			 FillTest(0x55);
			 
			 DataTest();
	
			 break;		 			 
		  }
		case 'f':
		  {
		  	 FillTest(0);
			 FillTest(255);
			 FillTest(0xAA);
			 FillTest(0x55);
		  	   	
			   break;
		  }
		case 'd':
		  {
		  	   DataTest();
			   break;
		  }
		case 'v':
			 {
#ifdef DEBUG			 
			   sermem_fVerbose = 1;
#endif			   
			   break;
			 }
		}
			  
	 }
}

/* As is, all interrupts except reset jumps to 0xffff, which is most
 * likely not going to useful. To replace an entry, declare your function,
 * and then change the corresponding entry in the table. For example,
 * if you have a SCI handler (which must be defined with
 * #pragma interrupt_handler ...) then in this file:
 * add
 *      extern void SCIHandler();
 * before th table.
 * In the SCI entry, change:
 *      DUMMY_ENTRY,
 * to
 *  SCIHandler,
 */
extern void _start();   /* entry point in crt??.s */

#define DUMMY_ENTRY     (void (*)())0xFFFF

#pragma abs_address:0xFFFE

/* change the above address if your vector starts elsewhere
 */
void (*interrupt_vectors[])() =
        {
        _start  /* RESET */
        };
#pragma end_abs_address