Subversion Repositories s6soc

//

//

// Filename:    busmaster_tb.cpp

//

// Project:     FPGA library development (S6 development board)

//

// Purpose:     

//

// Creator:     Dan Gisselquist

//              Gisselquist Tecnology, LLC

//

// Copyright:   2015

//

//

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <signal.h>

#include <time.h>

#include <unistd.h>

#include "verilated.h"

#include "Vbusmaster.h"

#include "testb.h"

// #include "twoc.h"

#include "qspiflashsim.h"

#include "uartsim.h"

class   GPIOSIM {

public:

        unsigned operator()(const unsigned o_gpio) { return 0; }

};

class   KEYPADSIM {

public:

        unsigned operator()(const unsigned o_kpd) { return 0; }

};

// Add a reset line, since Vbusmaster doesn't have one

class   Vbusmasterr : public Vbusmaster {

public:

        int     i_rst;

};

// No particular "parameters" need definition or redefinition here.

class   ZIPSIM_TB : public TESTB<Vbusmasterr> {

public:

        QSPIFLASHSIM    m_flash;

        UARTSIM         m_uart;

        GPIOSIM         m_gpio;

        KEYPADSIM       m_keypad;

        unsigned        m_last_led;

        time_t          m_start_time;

        ZIPSIM_TB(void) : m_uart(0x2b6) {

                m_start_time = time(NULL);

        }

        void    reset(void) {

                m_flash.debug(false);

        }

        void    tick(void) {

                if ((m_tickcount & ((1<<28)-1))==0) {

                        double  ticks_per_second = m_tickcount;

                        time_t  nsecs = (time(NULL)-m_start_time);

                        if (nsecs > 0) {

                                ticks_per_second /= (double)nsecs;

                                printf(" ********   %.6f TICKS PER SECOND\n",

                                        ticks_per_second);

                        }

                }

                // Set up the bus before any clock tick

                // We've got the flash to deal with ...

                m_core->i_qspi_dat = m_flash(m_core->o_qspi_cs_n,

                                                m_core->o_qspi_sck,

                                                m_core->o_qspi_dat);

                // And the GPIO lines

                m_core->i_gpio = m_gpio(m_core->o_gpio);

                m_core->i_btn = 0; // 2'b0

                // o_led, o_pwm, o_pwm_aux

                // And the keypad

                m_core->i_kp_row = m_keypad(m_core->o_kp_col);

                // And the UART

                m_core->i_rx_stb  = m_uart.rx(m_core->i_rx_data);

                m_core->i_tx_busy = m_uart.tx(m_core->o_tx_stb, m_core->o_tx_data);

                TESTB<Vbusmasterr>::tick();

                if (m_core->o_led != m_last_led) {

                        printf("LED: %08x\n", m_core->o_led);

                }

                /*

                printf("PC: %08x:%08x [%08x:%08x:%08x:%08x:%08x],%08x,%08x,%d,%08x,%08x\n",

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__ipc,

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__upc,

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__regset[0],

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__regset[1],

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__regset[2],

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__regset[3],

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__regset[15],

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__instruction_decoder__DOT__r_I,

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__r_opB,

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__instruction_decoder__DOT__w_dcdR_pc,

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__r_opA,

                        m_core->v__DOT__thecpu__DOT__thecpu__DOT__wr_reg_vl);

                */

                /*

                if (m_core->v__DOT__thecpu__DOT__thecpu__DOT__pf_valid)

                        printf("PC: %08x - %08x, uart=%d,%d, pic = %d,%04x,%0d,%04x\n",

                                m_core->v__DOT__thecpu__DOT__thecpu__DOT__instruction_pc,

                                m_core->v__DOT__thecpu__DOT__thecpu__DOT__instruction,

                                m_core->i_rx_stb, m_core->i_tx_busy,

                                m_core->v__DOT__pic__DOT__r_gie,

                                m_core->v__DOT__pic__DOT__r_int_enable,

                                m_core->v__DOT__pic__DOT__r_any,

                                m_core->v__DOT__pic__DOT__r_int_state);

                */

        }

};

ZIPSIM_TB       *tb;

bool    iself(const char *fname) {

        FILE    *fp;

        bool    ret = true;

        fp = fopen(fname, "rb");

        if (!fp)

                return false;

        if (0x7f != fgetc(fp))

                ret = false;

        if ('E' != fgetc(fp))

                ret = false;

        if ('L' != fgetc(fp))

                ret = false;

        if ('F' != fgetc(fp))

                ret = false;

        fclose(fp);

        return ret;

}

void    usage(void) {

        fprintf(stderr, "Usage: zip_sim flash_program\n");

}

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

        Verilated::commandArgs(argc, argv);

        tb = new ZIPSIM_TB;

        const char      *codef = NULL;

        for(int argn=1; argn<argc; argn++) {

                if (argv[argn][0] == '-') {

                        usage();

                        exit(-1);

                } else

                        codef = argv[argn];

        }

        if ((!codef)||(!codef[0]))

                fprintf(stderr, "No executable code filename found!\n");

        if (access(codef, R_OK)!=0)

                fprintf(stderr, "Cannot read code filename, %s\n", codef);

        if (iself(codef)) {

                char    tmpbuf[TMP_MAX], cmdbuf[256];

                int     unused_fd;

                strcpy(tmpbuf, "/var/tmp/zipsimXXXX");

                // Make a temporary file

                unused_fd = mkostemp(tmpbuf, O_CREAT|O_TRUNC|O_RDWR);

                // Close it, though, since we don't want to write to it here

                close(unused_fd);

                // Now we right to it, as part of calling objcopy       

                sprintf(cmdbuf, "zip-objcopy -S -O binary --reverse-bytes=4 %s %s\n",

                        codef, tmpbuf);

                if (system(cmdbuf) != 0) {

                        unlink(tmpbuf);

                        fprintf(stderr, "ZIP_SIM::Could not convert ELF binary to a raw file\n");

                        exit(-2);

                }

                tb->m_flash.load(0x0400, tmpbuf);

                unlink(tmpbuf);

        } else {

                tb->m_flash.load(0x0400, codef);

        }

        tb->reset();

        while(1)

                tb->tick();

        printf("SUCCESS!\n");

        exit(0);

}