/*************************************************************************
 *
 *  File: iotest.c
 *
 *  This file contains the main test loop driver. This loop reads test
 *  input data from a text file, parses each input line for valid data, 
 *  and executes the corresponding test routine.
 *
 *  $Header: /root/leakn64/depot/rf/sw/n64os20l/iosim/src/iotest.c,v 1.2 2002/05/30 05:52:49 whs Exp $
 *
 */

#include <stdio.h>
#include <string.h>
#ifdef __sgi__
	#include <bstring.h>
#endif
#include "trace.h"
#include "iomap.h"
#include "iotest.h"
#include "simipc.h"


#define REQ_LOG		REQ_CONFIG_RDRAM


/***********************************************************************
 * Global definitions
 */
FILE	*dumpFp = NULL;


/***********************************************************************
 * Extern declarations
 */
extern int MemoryLoad;


/***********************************************************************
 * Local static definitions
 */
static IpcPkt		req, rsp;
static unsigned long	tstBuf[4];


IpcPkt *
SendConfirmReqPkt(char *buf, int len)
{
	IpcPkt *pkt;

	bzero((char *)&rsp, sizeof(IpcPkt));

	if (IpcFd != -1)
		IpcClose(IpcFd);

	if ((IpcFd = IpcOpen(IPC_CLIENT)) < 0) {
		return(NULL);
	}

	if (IpcConnect(IpcFd) < 0) {
		return(NULL);
	}

	if (IpcSend(IpcFd, (char *)buf, len) < 0) {
		IpcClose(IpcFd); IpcFd = -1;
		return(NULL);
	}
	if (IpcReceive(IpcFd, (char *)&rsp, sizeof(IpcPkt)) < 0) {
		IpcClose(IpcFd); IpcFd = -1;
		return(NULL);
	}

	IpcClose(IpcFd);
	IpcFd = -1;

	return(&rsp);

}  /* SendConfirmReqPkt */


int
IoCmd(int code, int data)
{
	IpcPkt *pkt;

	bzero(&req, sizeof(IpcPkt));
#ifdef __sgi__
	req.length = sizeof(IpcPkt);
	req.code = code;
	req.data[0] = data;
#else 
        req.length = htonl(sizeof(IpcPkt));
        req.code = htonl(code);
        req.data[0] = htonl(data);
#endif 

	if ((pkt = SendConfirmReqPkt((char *)&req, sizeof(IpcPkt))) == NULL) {
		return(-1);
	}
	if (pkt->code != RSP_OK) {
		return(-1);
	}

	return(0);

}  /* IoCmd */


int
IoSend(int code, unsigned int *data)
{
	IpcPkt *pkt;
	int	i;

	bzero(&req, sizeof(IpcPkt));
	req.length = sizeof(IpcPkt);
	req.code = code;

	for (i = 0; i < PKT_DATA_WORD; i++)
	    req.data[i] = data[i];

	if ((pkt = SendConfirmReqPkt((char *)&req, sizeof(IpcPkt))) == NULL) {
		return(-1);
	}
	if (pkt->code != RSP_OK) {
		return(-1);
	}

	return(0);

}  /* IoSend */


static int
parseSize(unsigned int *size, int nbytes)
{
	if (nbytes <= 0 || nbytes > 32)
		return(-1);

	switch (nbytes) {
		case  1: *size = SIZE_1BYTE; break;
		case  2: *size = SIZE_2BYTE; break;
		case  3: *size = SIZE_3BYTE; break;
		case  4: *size = SIZE_4BYTE; break;
		case  8: *size = SIZE_2WORD; break;
		case 16: *size = SIZE_4WORD; break;
		case 32: *size = SIZE_8WORD; break;
		default: return(-1);
	}

	return(0);

}  /* parseSize */


int
IoRead(unsigned int address, int nbytes, unsigned int *data)
{
	IpcPkt *pkt;

	bzero(&req, sizeof(IpcPkt));
	if (parseSize(&req.size, nbytes) < 0)
		return(-1);
	req.code = (nbytes <= 4) ? REQ_SINGLE_READ: REQ_BLOCK_READ;
	req.length = sizeof(IpcPkt);
	req.address = address;

	if ((pkt = SendConfirmReqPkt((char *)&req, sizeof(IpcPkt))) == NULL) {
		return(-1);
	}
	if (pkt->code != RSP_DATA) {
		return(-1);
	}
	bcopy((void *)pkt->data, (void *)data, nbytes);

	return(0);

}  /* IoRead */


int
IoWrite(unsigned int address, int nbytes, unsigned int *data)
{
	int i;
	IpcPkt *pkt;

	bzero(&req, sizeof(IpcPkt));
	if (parseSize(&req.size, nbytes) < 0)
		return(-1);
	req.code = (nbytes <= 4) ? REQ_SINGLE_WRITE: REQ_BLOCK_WRITE;
	req.length = sizeof(IpcPkt);
	req.address = address;

	req.data[0] = data[0];
	if (req.code == REQ_BLOCK_WRITE) {
		for (i=1; i < (2 << req.size); i++)
			req.data[i] = data[i];
	}

	if ((pkt = SendConfirmReqPkt((char *)&req, sizeof(IpcPkt))) == NULL) {
		return(-1);
	}
	if (pkt->code != RSP_OK) {
		return(-1);
	}

	return(0);

}  /* IoWrite */


/***********************************************************************
 *
 *  Main test driver
 *	- Read each line from test command file
 *	- Execute test based on id
 */
/* 
 * Perform lexical scan on input buffer by breaking input buffer into
 * tokens
 */
static int
lexScan(char *inBuf, char **argv)
{
        return(0);
}


static TstCmd *
lookupCmd(TstCmd *CmdTbl, int id)
{
	TstCmd *ct;

	/* Search through TstCmdTable to see if id exists 
	 * If found, return pointer to TstCmd structure, otherwise return NULL
	 */
	for (ct = CmdTbl; ct->id != -1; ct++) {
		if (ct->id == id) 
			return(ct);
	}
	return(NULL);
}  /* lookupCmd */


/***********************************************************************
 */
int 
IoProcessTestFile(char *testFile)
{


	FILE		*fp;
	char		line[BUF_SIZE], dumpFile[BUF_SIZE], fileName[BUF_SIZE];
	int 		ret, size, cycles, tid;
	unsigned int	address, data[PKT_DATA_WORD];
	unsigned int	a1, a2, a3, a4;
	TstCmd		*cmd;

	fp = (FILE *)NULL;
	line[0] = '\0';
	dumpFile[0] = '\0';


	/* Load test file */
	if ((fp = fopen(testFile, "r")) == NULL) {
		fprintf(LogFp, "ERROR: Unable to open file '%s'\n", testFile);
		return(-1);
	}
	
	/* 
	 * line format (size= # of bytes)
	 * ===========
	 * f <filename>			// dump file name
	 * s <cycles>			// stall for n clock cycles
	 * r <size> <address> 		// read from <address> of <size>
	 * w <size> <address> <data>	// write <size><data> to <address>
	 * l <file> <address> <size>	// load <file> <address> <size>
	 * u <file> <address> <size> 	// unload <file> <address> <size>
	 * v <id>			// execute verilog test <id>
	 * t <id> <a1> <a2> ... <a4>	// execute test <id>
	 * q				// quit
	 *
	 */
	while (fgets(line, BUF_SIZE, fp)) {
		if (line[0] == 's' || line[0] == 'S') {
			sscanf(line, "%*s %d", &cycles);
			_TRACE(DLOG, fprintf(LogFp, 
				"\ts c=%d\n", cycles));

			ret = IoCmd(REQ_STALL, cycles);
			continue;
		}
		else if (line[0] == 'r' || line[0] == 'R') {
			sscanf(line, "%*s %d %x", &size, &address);
			_TRACE(DLOG, fprintf(LogFp, 
				"\tr s=%d addr=0x%08x\n", size, address));

			bzero((char *)data, PKT_DATA_BYTES);
			ret = IoRead(address, size, data);
			if (ret < 0) {
				_TRACE(DERROR, fprintf(LogFp, MSG_RD_ERR, 
					address, size));
			}
			fprintf(FP_SET(dumpFp), 
				MSG_DATAOUT, address, 
				data[0], data[1], data[2], data[3],
				data[4], data[5], data[6], data[7]);
			continue;
		}
		else if (line[0] == 'w' || line[0] == 'W') {
			sscanf(line, "%*s %d %x %x %x %x %x %x %x %x %x", 
				&size, &address, 
				&data[0], &data[1], &data[2], &data[3],
				&data[4], &data[5], &data[6], &data[7]);
			_TRACE(DLOG, fprintf(LogFp, 
				"\tw s=%d addr=0x%08x data=0x%08x\n",
				size, address, data[0]));

			ret = IoWrite(address, size, data);
			if (ret < 0) {
				_TRACE(DERROR, fprintf(LogFp,
					MSG_WR_ERR, address, size,
					data[0], data[1], data[2], data[3]));
			}
			continue;
		} 
		else if (line[0] == 'v') { 
			sscanf(line, "%*s %d %x %x %x %x", 
			    &data[0], &data[1], &data[2], &data[3], &data[4]);

			_TRACE(DLOG, fprintf( LogFp,
			    "v %3d 0x%08x 0x%08x 0x%08x 0x%08x\n", 
			    data[0], data[1], data[2], data[3], data[4]));
			if (IoSend(REQ_LOG, data) < 0) {
			    _TRACE(DERROR, fprintf(LogFp,
				"ERROR: v %3d 0x%08x 0x%08x 0x%08x 0x%08x\n", 
			        data[0], data[1], data[2], data[3], 
				data[4]));
			}
			continue;
		} 
		else if (line[0] == 't') { 
			sscanf(line, "%*s %d %x %x %x %x", 
				&tid, &a1, &a2, &a3, &a4);

			printf("t %3d 0x%08x 0x%08x 0x%08x 0x%08x\n", 
				tid, a1, a2, a3, a4);

			if ((cmd = lookupCmd(TstCmdTbl, tid)) != NULL) {
				fprintf(LogFp, TST_MSG_RES_STR,
					cmd->id, cmd->name,
					a1, a2, a3, a4);
				ret = (*cmd->handler)(a1, a2, a3, a4);
				if (ret == 0)
					fprintf(LogFp, "-> %s\n", PASS_STR);
				else if (ret == -1)
					fprintf(LogFp, "-> %s\n", FAIL_STR);
				else fprintf(LogFp, "\n");
			}
			else {
				fprintf(LogFp, "ERROR: illegal test cmd=%d\n", 
					tid);
			}
			continue;
		}
		else if ((line[0] == 'l' || line[0] == 'L') && MemoryLoad) {
			sscanf(line, "%*s %s %x %d", fileName, &address, &size);
		        fprintf(LogFp, 
                            "LoadFile name=%s addr=0x%08x size=%d\n", 
                            fileName, address, size);
			if (LoadFile(fileName, address, size) != 0) {
				_TRACE(DERROR, fprintf(LogFp,
				    "ERROR: Fail to load %s!\n", fileName));
			}
			continue;
		} 
		else if ((line[0] == 'u' || line[0] == 'U') && MemoryLoad) {
			sscanf(line, "%*s %s %x %d", fileName, &address, &size);
		        fprintf(LogFp, 
                            "UnloadFile name=%s addr=0x%08x size=%d\n", 
                            fileName, address, size);
			if (UnloadFile(fileName, address, size)!= 0) {
				_TRACE(DERROR, fprintf(LogFp,
				    "ERROR: Fail to unload %s!\n", fileName));
			}
			continue;
		} 
		else if (line[0] == 'q' || line[0] == 'Q') {
			ret = IoCmd(REQ_QUIT, 0);
			break;
		}
		else if (line[0] == 'f' || line[0] == 'F') {
			sscanf(line, "%*s %s", dumpFile);

			if ((dumpFp = fopen(dumpFile, "w+")) == NULL) {
				fprintf(LogFp,
					"Unable to open %s\n", dumpFile);
			}
			continue;
		}  /* else */
	}  /* while */
	fclose(fp);

	fprintf(LogFp, 
		"\n***** End of IO verification (total error = %d) ****\n",
		errorTotal);
	if (dumpFp)
		fclose(dumpFp);

	return(0);

}  /* IoProcessTestFile */


int 
IoTest(void)
{
	return(IoProcessTestFile(CmdFile));

}  /* IoTest */