Subversion Repositories wbscope

////////////////////////////////////////////////////////////////////////////////
//
// Filename:	wbscopc_tb.cpp
//
// Project:	WBScope, a wishbone hosted scope
//
// Purpose:	A quick test bench to determine if the run-length encoded
//		wbscopc module works.
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2017, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program.  (It's in the $(ROOT)/doc directory.  Run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:	GPL, v3, as defined and found on www.gnu.org,
//		http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
//
//
#include <stdio.h>
 
#include <verilated.h>
#include <verilated_vcd_c.h>
#include "Vwbscopc_tb.h"
#include "testb.h"
#include "devbus.h"
#define	INTERRUPTWIRE	o_interrupt
#include "wb_tb.h"
 
const int LGMEMSIZE = 15;
 
class	WBSCOPC_TB : public WB_TB<Vwbscopc_tb> {
	bool		m_debug;
public:
 
	WBSCOPC_TB(void) {
		m_debug = true;
	}
 
	void	tick(void) {
 
		WB_TB<Vwbscopc_tb>::tick();
 
		bool	writeout = true;
		if ((m_debug)&&(writeout)) {}
	}
 
	void reset(void) {
		m_core->i_rst    = 1;
		m_core->i_wb_cyc = 0;
		m_core->i_wb_stb = 0;
		tick();
		m_core->i_rst  = 0;
	}
 
	unsigned	trigger(void) {
		m_core->i_trigger = 1;
		idle();
		m_core->i_trigger = 0;
		printf("TRIGGERED AT %08x\n", m_core->o_data);
		return m_core->o_data;
	}
 
	bool	debug(void) const { return m_debug; }
	bool	debug(bool nxtv) { return m_debug = nxtv; }
};
 
int main(int  argc, char **argv) {
	Verilated::commandArgs(argc, argv);
	WBSCOPC_TB	*tb = new WBSCOPC_TB;
	unsigned	v, addr, trigger_addr;
	unsigned *buf;
	int	trigpt;
 
	tb->opentrace("wbscopc_tb.vcd");
	printf("Giving the core 2 cycles to start up\n");
	// Before testing, let's give the unit time enough to warm up
	tb->reset();
	tb->idle(2);
 
#define	WBSCOPE_STATUS	0
#define	WBSCOPE_DATA	4
#define	WBSCOPE_NORESET	0x80000000
#define	WBSCOPE_TRIGGER	(WBSCOPE_NO_RESET|0x08000000)
#define	WBSCOPE_MANUAL	(WBSCOPE_TRIGGER)
#define	WBSCOPE_PRIMED	0x10000000
#define	WBSCOPE_TRIGGERED 0x20000000
#define	WBSCOPE_STOPPED 0x40000000
#define	WBSCOPE_DISABLED  0x04000000
#define	WBSCOPE_LGLEN(A)	((A>>20)&0x01f)
#define	WBSCOPE_LENGTH(A)	(1<<(LGLEN(A)))
 
	// First test ... read the status register
	v = tb->readio(WBSCOPE_STATUS);
	int ln = WBSCOPE_LGLEN(v);
	printf("V   = %08x\n", v);
	printf("LN  = %d, or %d entries\n", ln, (1<<ln));
	printf("DLY = %d\n", (v&0xfffff));
	if (((1<<ln) < tb->m_tickcount)&&(v&0x10000000)) {
		printf("SCOPE is already triggered! ??\n");
		goto test_failure;
	}
	buf = new unsigned[(1<<ln)];
 
	tb->idle((1<<(12+4)) + (1<<ln) +240);
 
	v = tb->readio(WBSCOPE_STATUS);
	if ((v&WBSCOPE_PRIMED)==0) {
		printf("v = %08x\n", v);
		printf("SCOPE hasn\'t primed! ??\n");
		goto test_failure;
	}
 
	tb->trigger();
	v = tb->readio(WBSCOPE_STATUS);
	if ((v&WBSCOPE_TRIGGERED)==0) {
		printf("v = %08x\n", v);
		printf("SCOPE hasn\'t triggered! ??\n");
		goto test_failure;
	}
 
	while((v & WBSCOPE_STOPPED)==0)
		v = tb->readio(WBSCOPE_STATUS);
	printf("SCOPE has stopped, reading data\n");
 
	tb->readz(WBSCOPE_DATA, (1<<ln), buf);
	addr = 0;
	trigger_addr = 0xffffffff;
	for(int i=0; i<(1<<ln); i++) {
		if (buf[i] & 0x80000000)
			addr += (buf[i]&0x7fffffff) + 1;
		else {
			if ((i > 0)&&(buf[i-1]&0x80000000))
				printf("     [*****]:\n");
			printf("%5d[%5d]: %08x", addr, i, buf[i]);
			if (buf[i] & 0x40000000) {
				printf(" <<--- TRIGGER!");
				trigger_addr = addr;
			} printf("\n");
 
			addr++;
		}
	} if ((buf[(1<<ln)-1]&0x80000000))
		printf("     [*****]:\n");
 
	if (buf[(1<<ln)-1] & 0x80000000) {
		printf("ERR: LAST VALUE IS A RUN, 0x%08x\n", buf[(1<<ln)-1]);
		goto test_failure;
	}
 
	if (trigger_addr == 0xffffffff) {
		printf("ERR: TRIGGER NOT FOUND IN THE DATA!\n");
		goto test_failure;
	}
 
 
	printf("TRIGGER ADDRESS = %08x (%5d)\n", trigger_addr, trigger_addr);
	printf("V               = %08x\n", v & 0x0fffff);
	printf("Difference      = %08x (%5d)\n", addr - trigger_addr,
			addr - trigger_addr);
	if (addr - 1 - trigger_addr != (v & 0x0fffff)) {
		printf("TRIGGER AT THE WRONG LOCATION!\n");
		goto test_failure;
	}
 
	printf("SUCCESS!!\n");
	delete tb;
	exit(0);
test_failure:
	printf("FAIL-HERE\n");
	for(int i=0; i<4; i++)
		tb->tick();
	printf("TEST FAILED\n");
	delete tb;
	exit(-1);
}