Subversion Repositories qspiflash

////////////////////////////////////////////////////////////////////////////////
//
// Filename: 	qspiflash_tb.cpp
//
// Project:	Wishbone Controlled Quad SPI Flash Controller
//
// Purpose:	To determine whether or not the qspiflash module works.  Run
//		this with no arguments, and check whether or not the last line
//	contains "SUCCESS" or not.  If it does contain "SUCCESS", then the
//	module passes all tests found within here.
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015-2016, 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 "verilated.h"
#include "Vwbqspiflash.h"
#include "qspiflashsim.h"
#include "wbflash_tb.h"
 
#define	QSPIFLASH	0x0400000
#define	PARENT	WBFLASH_TB<Vwbqspiflash>
 
class	QSPIFLASH_TB : public PARENT {
	QSPIFLASHSIM	*m_flash;
	bool		m_bomb;
public:
 
	QSPIFLASH_TB(void) {
		m_core = new Vwbqspiflash;
		m_flash= new QSPIFLASHSIM;
		m_flash->debug(true);
	}
 
	unsigned operator[](const int index) { return (*m_flash)[index]; }
	void	setflash(unsigned addr, unsigned v) {
		m_flash->set(addr, v);
	}
	void	load(const char *fname) {
		m_flash->load(0,fname);
	}
 
	void	set(const unsigned addr, const unsigned val) {
		m_flash->set(addr, val);
	}
 
	void	tick(void) {
		bool	writeout = false;
		m_core->i_qspi_dat = (*m_flash)(m_core->o_qspi_cs_n,
			m_core->o_qspi_sck, m_core->o_qspi_dat);
 
 
		if (writeout) {
			printf("%08lx-WB: %s %s/%s %s %s",
				m_tickcount,
				(m_core->i_wb_cyc)?"CYC":"   ",
				(m_core->i_wb_data_stb)?"DSTB":"    ",
				(m_core->i_wb_ctrl_stb)?"CSTB":"    ",
				(m_core->o_wb_stall)?"STALL":"     ",
				(m_core->o_wb_ack)?"ACK":"   ");
			printf(" %s@0x%08x[%08x/%08x]",
				(m_core->i_wb_we)?"W":"R",
				(m_core->i_wb_addr), (m_core->i_wb_data),
				(m_core->o_wb_data));
			printf(" QSPI:%x:%x/%02x/%02x/%2d",
				m_core->i_qspi_dat, m_core->o_qspi_mod,
				m_core->v__DOT__state,
				m_core->v__DOT__lldriver__DOT__state,
				m_core->v__DOT__lldriver__DOT__spi_len);
			printf(" %08x/%08x", m_core->v__DOT__spi_in,
				m_core->v__DOT__lldriver__DOT__r_input);
			printf(" %d,%d,%d/%d,%08x%c", 
				m_core->v__DOT__spi_busy,
				m_core->v__DOT__spi_valid,
				m_core->v__DOT__spi_wr,
				m_core->v__DOT__spi_len,
				m_core->v__DOT__spi_out,
				(m_core->v__DOT__write_in_progress)?'W':' ');
 
			printf("\n");
		}
 
		PARENT::tick();
	}
 
	bool	bombed(void) const { return m_bomb; }
 
};
 
#define ERASEFLAG	0x80000000
#define DISABLEWP	0x10000000
#define ENABLEWP	0x00000000
#define NPAGES		256
#define SZPAGEB		256
#define SZPAGEW		(SZPAGEB>>2)
#define SECTORSZW	(NPAGES * SZPAGEW)
#define SECTORSZB	(NPAGES * SZPAGEB)
#define	RDBUFSZ		(NPAGES * SZPAGEW)
 
int main(int  argc, char **argv) {
	Verilated::commandArgs(argc, argv);
	QSPIFLASH_TB	*tb = new QSPIFLASH_TB;
	const char	*DEV_RANDOM = "/dev/urandom";
	unsigned	rdv;
	unsigned	*rdbuf;
 
	// tb->opentrace("qspi.vcd");
 
	tb->load(DEV_RANDOM);
	rdbuf = new unsigned[RDBUFSZ];
	tb->setflash(0,0);
 
	tb->tick();
	rdv = tb->wb_read(0);
	printf("READ[0] = %04x\n", rdv);
	if (rdv != 0)
		goto test_failure;
 
	tb->tick();
	if (tb->bombed())
		goto test_failure;
 
	for(int i=0; (i<1000)&&(!tb->bombed()); i++) {
		unsigned	tblv;
		tblv = (*tb)[(i<<2)];
		rdv = tb->wb_read(i<<2);
 
		if(tblv != rdv) {
			printf("BOMB(INITIAL/SINGLE-READ): READ[%08x] %08x, EXPECTED %08x\n",
				(i<<2), rdv, tblv);
			goto test_failure;
			break;
		} else printf("MATCH: %08x == %08x\n", rdv, tblv);
	}
 
	printf("SINGLE-READ TEST PASSES\n");
 
	for(int i=0; i<1000; i++)
		rdbuf[i] = -1;
	tb->wb_read(1000, 1000, rdbuf);
	if (tb->bombed())
		goto	test_failure;
	for(int i=0; i<1000; i++) {
		if ((*tb)[(i<<2)+1000] != rdbuf[i]) {
			printf("BOMB: V-READ[%08x] %08x, EXPECTED %08x\n", 1000+i, rdv, (*tb)[i+1000]);
			goto	test_failure;
		}
	} if (tb->bombed())
		goto test_failure;
	printf("VECTOR TEST PASSES!\n");
 
	// Read the status register
/*
	printf("ID[%2d]-RG = %08x\n", 0, rdv = tb->wb_read(8+0));
	if (rdv != 0x20ba1810) {
		printf("BOMB: ID[%2d]-RG = %08x != %08x\n", 0, rdv,
			0x20ba1810);
		goto test_failure;
	}
 
	for(int i=1; i<5; i++)
		printf("ID[%2d]-RG = %02x\n", i, tb->wb_read(8+i));
	if (tb->bombed())
		goto test_failure;
*/
 
 
	printf("Attempting to switch in Quad mode\n");
	// tb->wb_write(4, (tb->wb_read(4)&0x07f)); // Adjust EVconfig
 
	for(int i=0; (i<1000)&&(!tb->bombed()); i++) {
		unsigned	tblv;
		tblv = (*tb)[(i<<2)];
		rdv = tb->wb_read((i<<2));
 
		if(tblv != rdv) {
			printf("BOMB: Q-READ/SINGLE %08x, EXPECTED %08x\n", rdv, tblv);
			goto test_failure;
			break;
		} else printf("MATCH: %08x == %08x\n", rdv, tblv);
	} tb->wb_read(1000, 1000, rdbuf);
	if (tb->bombed())
		goto	test_failure;
	for(int i=0; i<1000; i++) {
		if ((*tb)[(i<<2)+1000] != rdbuf[i]) {
			printf("BOMB: Q-READ/VECTOR %08x, EXPECTED %08x\n", rdv, (*tb)[i+1000]);
			goto	test_failure;
		}
	} printf("VECTOR TEST PASSES! (QUAD)\n");
 
	printf("Attempting to switch to Quad mode with XIP\n");
	tb->wb_write(3, tb->wb_read(3)|0x08);
	// tb->wb_write(0, 0x22000000);
 
	printf("Attempting to read in Quad mode, using XIP mode\n");
	for(int i=0; (i<1000)&&(!tb->bombed()); i++) {
		unsigned	tblv;
		tblv = (*tb)[(i<<2)];
		rdv = tb->wb_read((i<<2));
 
		if(tblv != rdv) {
			printf("BOMB: Q-READ/XIP %08x, EXPECTED %08x\n", rdv, tblv);
			goto test_failure;
			break;
		} else printf("MATCH: %08x == %08x\n", rdv, tblv);
	}
 
	// Try a vector read
	tb->wb_read(1000, 1000, rdbuf);
	if (tb->bombed())
		goto	test_failure;
	for(int i=0; i<1000; i++) {
		if ((*tb)[(i<<2)+1000] != rdbuf[i]) {
			printf("BOMB: Q-READ/XIP/VECTOR %08x, EXPECTED %08x\n", rdv, (*tb)[i+1000]);
			goto	test_failure;
		}
	} printf("VECTOR TEST PASSES! (QUAD+XIP)\n");
 
	rdbuf[0] = tb->wb_read(1023);
	rdbuf[1] = tb->wb_read(2048);
 
 
	// Make sure, for testing purposes, that the words preceeding the
	// sector we are going to erase and following it don't look like they've
	// already been erased.
	if ((*tb)[SECTORSZW-1] == 0xffffffff)
		tb->set(SECTORSZW, 0);
	if ((*tb)[2*SECTORSZW] == 0xffffffff)
		tb->set(2*SECTORSZW, 0);
 
	printf("Turning off write-protect, calling WEL\n");
	tb->wb_ctrl_write(0, DISABLEWP);
 
	/*
	if (tb->write_protect()) {
		printf("WRITE PROTECT ISN\'T OFF YET, EVEN THOUGH WEL ISSUED\n");
		goto test_failure;
	} */
 
	printf("Attempting to erase subsector 1\n");
	tb->wb_ctrl_write(0, ERASEFLAG | (1*SECTORSZW));
 
	/*
	if (!tb->write_in_progress()) {
		printf("BOMB: Write in progress is false!\n");
		goto test_failure;
	}
	*/
 
	while (tb->wb_ctrl_read(0)&ERASEFLAG)
		;
 
	/*
	if (tb->write_in_progress()) {
		printf("BOMB: No write in progress\n");
		goto test_failure;
	}
	*/
 
	printf("Checking that the erase was successful\n");
	for(int i=SECTORSZB; i<SECTORSZB*2; i+=4) {
		if ((*tb)[i] != 0xffffffff) {
			printf("BOMB: Erase of [%08x] was unsuccessful, FLASH[%08x] = %08x\n", i, i, (*tb)[i]);
			goto test_failure;
		}
	}
 
	// Make sure we didn't erase anything else
	if ((*tb)[SECTORSZB-4] == 0xffffffff) {
		printf("BOMB: Post write check #2, the prior address changed\n");
		goto test_failure;
	} if ((*tb)[2*SECTORSZB] == 0xffffffff) {
		printf("BOMB: Post write check #2, the next address changed\n");
		goto test_failure;
	}
 
	if (tb->wb_read(SECTORSZB-4) != (*tb)[SECTORSZB-4]) {
		printf("BOMB: Post write check #2, the prior address changed\n");
		goto test_failure;
	} if (tb->wb_read(2*SECTORSZB) != (*tb)[2*SECTORSZB]) {
		printf("BOMB: Post write check #2, the next address changed\n");
		goto test_failure;
	}
 
 
 
	printf("Test: Trying a single word write\n");
 
	// Try to execute a single write
	tb->wb_ctrl_write(0,DISABLEWP);
	tb->wb_write(SECTORSZB, 0x12345678);
 
	while (tb->wb_ctrl_read(0)&ERASEFLAG)
		;
 
	if (tb->wb_read(SECTORSZB) != 0x12345678) {
		printf("BOMB: Single (not page) write result incorrect: %08x != 0x12345678\n", tb->wb_read(SECTORSZB));
		goto test_failure;
	}
 
 
	// Let's load up a sectors worth of random data into our buffer
	{
		FILE	*fp;
		fp = fopen(DEV_RANDOM, "r");
		assert(RDBUFSZ == fread(rdbuf, sizeof(unsigned), RDBUFSZ, fp));
		fclose(fp);
		rdbuf[0] = 0x12345678;
	}
 
	// Now, let's try writing this sector ... one page at a time.
	for(int p=0; p<NPAGES; p++) {
 
		printf("Writing page %d\n", p);
		tb->wb_ctrl_write(0, DISABLEWP);
		// if (tb->write_protect()) goto	test_failure;
		tb->wb_write(SECTORSZB+p*SZPAGEB, SZPAGEW, &rdbuf[p*SZPAGEW]);
 
		while (tb->wb_ctrl_read(0)&ERASEFLAG)
			;
 
		printf("Checking page %d\n", p);
		for(int i=0; i<SZPAGEW; i++) {
			if (rdbuf[p*SZPAGEW+i] != (*tb)[SECTORSZB+p*SZPAGEB+(i<<2)]) {
				printf("BOMB: Write check, Addr[%08x]\n", SECTORSZB+p*SZPAGEB+(i<<2));
				goto test_failure;
			}
		}
	}
 
	printf("SUCCESS!!\n");
	exit(EXIT_SUCCESS);
test_failure:
	printf("FAIL-HERE\n");
	for(int i=0; i<8; i++)
		tb->tick();
	printf("TEST FAILED\n");
	exit(EXIT_FAILURE);
}