Subversion Repositories wbscope

////////////////////////////////////////////////////////////////////////////////
//
// Filename:	wbscope_tb.cpp
//
// Project:	WBScope, a wishbone hosted scope
//
// Purpose:	A quick test bench to determine if the wbscope 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 "Vwbscope_tb.h"
#include "testb.h"
#define	INTERRUPTWIRE	o_interrupt
#include "wb_tb.h"
 
const int	LGMEMSIZE = 15;
 
class	WBSCOPE_TB : public WB_TB<Vwbscope_tb> {
	bool		m_bomb, m_debug;
public:
 
	WBSCOPE_TB(void) {
		m_debug = true;
	}
 
	void	tick(void) {
 
		WB_TB<Vwbscope_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;
		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);
	WBSCOPE_TB	*tb = new WBSCOPE_TB;
	unsigned	v;
	unsigned *buf;
	int	trigpt;
	unsigned	trigger_time, expected_first_value;
 
	tb->opentrace("wbscope_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<<ln);
 
	v = tb->readio(WBSCOPE_STATUS);
	if ((v&WBSCOPE_PRIMED)==0) {
		printf("v = %08x\n", v);
		printf("SCOPE hasn\'t primed! ??\n");
		goto test_failure;
	}
 
	trigger_time = tb->trigger() & 0x7fffffff;
	printf("TRIGGERED AT %08x\n", trigger_time);
 
	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);
	for(int i=0; i<(1<<ln); i++) {
		printf("%4d: %08x%s\n", i, buf[i],
			(i== (1<<ln)-1-(v&0x0fffff)) ? " <<--- TRIGGER!":"");
		if ((i>0)&&(((buf[i]&0x7fffffff)-(buf[i-1]&0x7fffffff))!=1)) {
			printf("ERR: Scope data doesn't increment!\n");
			printf("\tIn other words--its not matching the test signal\n");
			goto test_failure;
		}
	}
 
	trigpt = (1<<ln)-v&(0x0fffff)-1;
	if ((trigpt >= 0)&&(trigpt < (1<<ln))) {
		printf("Trigger value = %08x\n", buf[trigpt]);
		if (((0x80000000 & buf[trigpt])==0)&&(trigpt>0)) {
			printf("Pre-Trigger value = %08x\n", buf[trigpt-1]);
			if ((buf[trigpt-1]&0x80000000)==0) {
				printf("TRIGGER NOT FOUND\n");
				goto test_failure;
			}
		}
	}
 
	expected_first_value = trigger_time + (v&0x0fffff) - (1<<ln);
	if (buf[0] != expected_first_value) {
		printf("Initial value = %08x\n", buf[0]);
		printf("Expected:     %08x\n", expected_first_value);
		printf("ERR: WRONG STARTING-VALUE\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);
}