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 "testb.h"

#include "Vwbscope_tb.h"

#define MMUFLAG_RONW    8 // Read only (not writeable)

#define MMUFLAG_ACCS    4 // Accessed

#define MMUFLAG_CCHE    2 // Cachable

#define MMUFLAG_THSP    1 // Page has this context

const int       BOMBCOUNT = 32,

                LGMEMSIZE = 15;

class   WBSCOPE_TB : public TESTB<Vwbscope_tb> {

        bool            m_bomb, m_miss, m_err, m_debug;

        int             m_last_tlb_index;

public:

        WBSCOPE_TB(void) {

                m_debug = true;

                m_last_tlb_index = 0;

        }

        void    tick(void) {

                TESTB<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;

        }

        void wb_tick(void) {

                m_core->i_wb_cyc  = 0;

                m_core->i_wb_stb  = 0;

                tick();

                assert(!m_core->o_wb_ack);

        }

        unsigned wb_read(unsigned a) {

                unsigned        result;

                printf("WB-READM(%08x)\n", a);

                m_core->i_wb_cyc = 1;

                m_core->i_wb_stb = 1;

                m_core->i_wb_we  = 0;

                m_core->i_wb_addr= (a>>2)&1;

                // Dont need to check for stalls, since the wbscope never stalls

                tick();

                m_core->i_wb_stb = 0;

                while(!m_core->o_wb_ack)

                        tick();

                result = m_core->o_wb_data;

                // Release the bus?

                m_core->i_wb_cyc = 0;

                m_core->i_wb_stb = 0;

                // Let the bus idle for one cycle

                tick();

                return result;

        }

        void    wb_read(unsigned a, int len, unsigned *buf) {

                int             cnt, rdidx;

                printf("WB-READM(%08x, %d)\n", a, len);

                m_core->i_wb_cyc = 1;

                m_core->i_wb_stb = 1;

                m_core->i_wb_we   = 0;

                m_core->i_wb_addr = (a>>2)&1;

                rdidx =0; cnt = 0;

                do {

                        tick();

                        // Normally, we'd increment the address here.  For the

                        // scope, multiple reads only make sense if they are 

                        // from the same address, hence we don't increment the

                        // address here

                        // m_core->i_wb_addr += inc;

                        cnt += 1;

                        if (m_core->o_wb_ack)

                                buf[rdidx++] = m_core->o_wb_data;

                } while(cnt < len);

                m_core->i_wb_stb = 0;

                while(rdidx < len) {

                        tick();

                        if (m_core->o_wb_ack)

                                buf[rdidx++] = m_core->o_wb_data;

                }

                // Release the bus?

                m_core->i_wb_cyc = 0;

                tick();

                assert(!m_core->o_wb_ack);

        }

        void    wb_write(unsigned a, unsigned v) {

                int errcount = 0;

                printf("WB-WRITEM(%08x) <= %08x\n", a, v);

                m_core->i_wb_cyc = 1;

                m_core->i_wb_stb = 1;

                m_core->i_wb_we  = 1;

                m_core->i_wb_addr= (a>>2)&1;

                m_core->i_wb_data= v;

                tick();

                m_core->i_wb_stb = 0;

                while(!m_core->o_wb_ack) {

                        tick();

                }

                tick();

                // Release the bus?

                m_core->i_wb_cyc = 0;

                m_core->i_wb_stb = 0;

                assert(!m_core->o_wb_ack);

        }

        unsigned        trigger(void) {

                m_core->i_trigger = 1;

                wb_tick();

                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);

        WBSCOPE_TB      *tb = new WBSCOPE_TB;

        unsigned        v;

        unsigned *buf;

        int     trigpt;

        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();

        for(int i=0; i<2; i++)

                tb->wb_tick();

#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->wb_read(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)];

        for(int i=0; i<(1<<ln); i++)

                tb->wb_tick();

        v = tb->wb_read(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->wb_read(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->wb_read(WBSCOPE_STATUS);

        printf("SCOPE has stopped, reading data\n");

        tb->wb_read(WBSCOPE_DATA, (1<<ln), buf);

        for(int i=0; i<(1<<ln); i++) {

                printf("%4d: %08x\n", i, buf[i]);

                if ((i>0)&&(((buf[i]&0x7fffffff)-(buf[i-1]&0x7fffffff))!=1))

                        goto test_failure;

        }

        trigpt = (1<<ln)-v&(0x0fffff);

        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;

                        }

                }

        }

        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);

}