Subversion Repositories openarty

////////////////////////////////////////////////////////////////////////////////

//

// Filename:    enetctrl_tb.cpp

//

// Project:     OpenArty, an entirely open SoC based upon the Arty platform

//

// Purpose:     To determine whether or not the enetctrl Verilog module works.

//              Run this program with no arguments.  If the last line output

//      from it is "SUCCESS", you will know it works.  Alternatively you can

//      look at the return code.  If the return code is 0 (EXIT_SUCCESS), then

//      the test passed, ,otherrwise it failed.

//

// 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 "verilated_vcd_c.h"

#include "Venetctrl.h"

#include "enetctrlsim.h"

const int       BOMBCOUNT = 2048;

class   ENETCTRL_TB {

        unsigned long   m_tickcount;

        Venetctrl       *m_core;

        ENETCTRLSIM     *m_sim;

        bool            m_bomb;

        VerilatedVcdC   *m_trace;

public:

        ENETCTRL_TB(void) {

                m_core = new Venetctrl;

                m_sim  = new ENETCTRLSIM;

                Verilated::traceEverOn(true);

                m_trace = NULL;

                m_tickcount = 0;

        }

        ~ENETCTRL_TB(void) {

                if (m_trace) {

                        m_trace->close();

                        delete  m_trace;

                }

        }

        int     operator[](const int index) { return (*m_sim)[index]; }

        void    trace(const char *fname) {

                if (!m_trace) {

                        m_trace = new VerilatedVcdC;

                        m_core->trace(m_trace, 99);

                        m_trace->open(fname);

                }

        }

        void    tick(void) {

                m_core->i_mdio = (*m_sim)(0, m_core->o_mdclk,

                        ((m_core->o_mdwe)&(m_core->o_mdio))

                                |((m_core->o_mdwe)?0:1));

#ifdef  DEBUGGING_OUTPUT

                printf("%08lx-WB: %s %s %s%s %s@0x%02x[%04x/%04x] -- %d[%d->(%d)->%d]",

                        m_tickcount,

                        (m_core->i_wb_cyc)?"CYC":"   ",

                        (m_core->i_wb_stb)?"STB":"   ",

                        (m_core->o_wb_stall)?"STALL":"     ",

                        (m_core->o_wb_ack)?"ACK":"   ",

                        (m_core->i_wb_we)?"W":"R",

                        (m_core->i_wb_addr)&0x01f, (m_core->i_wb_data)&0x0ffff,

                        (m_core->o_wb_data)&0x0ffff,

                        (m_core->o_mdclk), (m_core->o_mdio),

                        (m_core->o_mdwe), (m_core->i_mdio));

                printf(" [%02x,%d%d%d,%x] ",

                        m_core->v__DOT__reg_pos,

                        0, // m_core->v__DOT__rclk,

                        m_core->v__DOT__zclk,

                        m_core->v__DOT__zreg_pos,

                        m_core->v__DOT__ctrl_state);

                printf(" 0x%04x/0x%04x ", m_core->v__DOT__write_reg,

                                m_core->v__DOT__read_reg);

                printf(" %s%s ",

                        (m_core->v__DOT__read_pending)?"R":" ",

                        (m_core->v__DOT__write_pending)?"W":" ");

                printf(" %s:%08x,%2d,%08x ",

                        (m_sim->m_synched)?"S":" ",

                        m_sim->m_datareg, m_sim->m_halfword,

                        m_sim->m_outreg);

                printf("\n");

#endif

                if ((m_trace)&&(m_tickcount>0)) m_trace->dump(10*m_tickcount-2);

                m_core->eval();

                m_core->i_clk = 1;

                m_core->eval();

                if (m_trace) m_trace->dump(10*m_tickcount);

                m_core->i_clk = 0;

                m_core->eval();

                if (m_trace) m_trace->dump(10*m_tickcount+5);

                m_tickcount++;

                if ((m_core->o_wb_ack)&&(!m_core->i_wb_cyc)) {

                        printf("SETTING ERR TO TRUE!!!!!  ACK w/ no CYC\n");

                        // m_bomb = true;

                }

        }

        void wb_tick(void) {

                // printf("WB-TICK()\n");

                m_core->i_wb_cyc   = 0;

                m_core->i_wb_stb = 0;

                tick();

        }

        unsigned wb_read(unsigned a) {

                int             errcount = 0;

                unsigned        result;

                printf("WB-READ(%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 & 0x01f;

                if (m_core->o_wb_stall)

                        while((errcount++ < BOMBCOUNT)&&(m_core->o_wb_stall))

                                tick();

                tick();

                m_core->i_wb_stb = 0;

                while((errcount++ <  BOMBCOUNT)&&(!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;

                if(errcount >= BOMBCOUNT) {

                        printf("SETTING ERR TO TRUE!!!!!\n");

                        m_bomb = true;

                } else if (!m_core->o_wb_ack) {

                        printf("SETTING ERR TO TRUE--NO ACK, NO TIMEOUT\n");

                        m_bomb = true;

                }

                tick();

                return result;

        }

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

                int             errcount = 0;

                int             THISBOMBCOUNT = BOMBCOUNT * len;

                int             cnt, rdidx;

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

                while((errcount++ < BOMBCOUNT)&&(m_core->o_wb_stall))

                        wb_tick();

                if (errcount >= BOMBCOUNT) {

                        m_bomb = true;

                        return;

                }

                errcount = 0;

                m_core->i_wb_cyc = 1;

                m_core->i_wb_stb = 1;

                m_core->i_wb_we  = 0;

                m_core->i_wb_addr= a & 0x01f;

                rdidx =0; cnt = 0;

                do {

                        int     s;

                        s = (m_core->o_wb_stall==0)?0:1;

                        tick();

                        if (!s)

                                m_core->i_wb_addr = (m_core->i_wb_addr+1)&0x1f;

                        cnt += (s==0)?1:0;

                        if (m_core->o_wb_ack)

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

                } while((cnt < len)&&(errcount++ < THISBOMBCOUNT));

                m_core->i_wb_stb = 0;

                while((rdidx < len)&&(errcount++ < THISBOMBCOUNT)) {

                        tick();

                        if (m_core->o_wb_ack)

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

                }

                // Release the bus?

                m_core->i_wb_cyc = 0;

                if(errcount >= THISBOMBCOUNT) {

                        printf("SETTING ERR TO TRUE!!!!! (errcount=%08x, THISBOMBCOUNT=%08x)\n", errcount, THISBOMBCOUNT);

                        m_bomb = true;

                } else if (!m_core->o_wb_ack) {

                        printf("SETTING ERR TO TRUE--NO ACK, NO TIMEOUT\n");

                        m_bomb = true;

                }

                tick();

        }

        void    wb_write(unsigned a, unsigned int v) {

                int errcount = 0;

                printf("WB-WRITE(%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 & 0x01f;

                m_core->i_wb_data= v;

                if (m_core->o_wb_stall)

                        while((errcount++ < BOMBCOUNT)&&(m_core->o_wb_stall))

                                tick();

                tick();

                m_core->i_wb_stb = 0;

                while((errcount++ <  BOMBCOUNT)&&(!m_core->o_wb_ack))

                        tick();

                // Release the bus?

                m_core->i_wb_cyc = 0;

                m_core->i_wb_stb = 0;

                if(errcount >= BOMBCOUNT) {

                        printf("SETTING ERR TO TRUE!!!!!\n");

                        m_bomb = true;

                } tick();

        }

        void    wb_write(unsigned a, unsigned int ln, unsigned int *buf) {

                unsigned errcount = 0, nacks = 0;

                m_core->i_wb_cyc = 1;

                for(unsigned stbcnt=0; stbcnt<ln; stbcnt++) {

                        m_core->i_wb_stb = 1;

                        m_core->i_wb_we  = 1;

                        m_core->i_wb_addr= (a+stbcnt) & 0x01f;

                        m_core->i_wb_data= buf[stbcnt];

                        errcount = 0;

                        do {

                                tick(); if (m_core->o_wb_ack) nacks++;

                        } while((errcount++ < BOMBCOUNT)&&(m_core->o_wb_stall));

                }

                m_core->i_wb_stb = 0;

                errcount = 0;

                while((nacks < ln)&&(errcount++ < BOMBCOUNT)) {

                        tick();

                        if (m_core->o_wb_ack) {

                                nacks++;

                                errcount = 0;

                        }

                }

                // Release the bus

                m_core->i_wb_cyc = 0;

                m_core->i_wb_stb = 0;

                if(errcount >= BOMBCOUNT) {

                        printf("SETTING ERR TO TRUE!!!!!\n");

                        m_bomb = true;

                } tick();

        }

        bool    bombed(void) const { return m_bomb; }

};

int main(int  argc, char **argv) {

        Verilated::commandArgs(argc, argv);

        ENETCTRL_TB     *tb = new ENETCTRL_TB;

        unsigned        v;

        // unsigned     *rdbuf;

        tb->trace("enetctrl.vcd");

        tb->wb_tick();

        tb->wb_write(0, 0x7f82);

        if ((*tb)[0] != 0x7f82) {

                printf("Somehow wrote a %04x, rather than 0x7f82\n", (*tb)[0]);

                goto test_failure;

        }

        tb->wb_tick();

        if ((v=tb->wb_read(0))!=0x7f82) {

                printf("READ A %08x FROM THE CORE, NOT 0x7f82\n", v);

                goto test_failure;

        }

        // 

        tb->wb_tick();

        tb->wb_write(14, 0x5234);

        tb->wb_tick();

        if (tb->wb_read(14)!=0x5234)

                goto test_failure;

        printf("SUCCESS!!\n");

        exit(EXIT_SUCCESS);

test_failure:

        printf("FAIL-HERE\n");

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

                tb->tick();

        printf("TEST FAILED\n");

        exit(EXIT_FAILURE);

}