Subversion Repositories tv80

#include "systemc.h"
#include "systemperl.h"
//#include "env_memory.h"
 
//#include "SpTraceVcd.h"
#include "verilated_vcd_sc.h"
#include <unistd.h>
#include "it_cfg_driver.h"
#include "it_cfg_monitor.h"
#include "Vlcfg.h"
#include "load_ihex.h"
 
extern char *optarg;
extern int optind, opterr, optopt;
 
#define FILENAME_SZ 80
#define MAX_MEM_SIZE 8192
 
int sc_main(int argc, char *argv[])
{
  bool dumping = false;
  bool memfile = false;
  int index;
  char dumpfile_name[FILENAME_SZ];
  char mem_src_name[FILENAME_SZ];
  uint8_t memory[MAX_MEM_SIZE];
  VerilatedVcdSc *tfp;
  //z80_decoder dec0 ("dec0");
 
  sc_clock clk("clk125", 8, SC_NS, 0.5);
 
  sc_signal<bool> reset_n;
  sc_signal<bool>  lcfg_init;
  sc_signal<bool>  lcfg_proc_reset;
 
  sc_signal<bool>      cfgi_irdy;
  sc_signal<bool>      cfgi_trdy;
  sc_signal<uint32_t>  cfgi_addr;
  sc_signal<bool>      cfgi_write;
  sc_signal<uint32_t>  cfgi_wr_data;
  sc_signal<uint32_t>  cfgi_rd_data;
 
  // outgoing config interface to system
  // configuration bus
  sc_signal<bool>      cfgo_irdy;
  sc_signal<bool>      cfgo_trdy;
  sc_signal<uint32_t>  cfgo_addr;
  sc_signal<bool>      cfgo_write;
  sc_signal<uint32_t>  cfgo_wr_data;
  sc_signal<uint32_t>  cfgo_rd_data;
 
  // clear program memory
  for (int i=0; i<MAX_MEM_SIZE; i++) memory[i] = 0;
 
  while ( (index = getopt(argc, argv, "d:i:k")) != -1) {
    printf ("DEBUG: getopt optind=%d index=%d char=%c\n", optind, index, (char) index);
    if  (index == 'd') {
      strncpy (dumpfile_name, optarg, FILENAME_SZ);
      dumping = true;
      printf ("VCD dump enabled to %s\n", dumpfile_name);
    } else if (index == 'i') {
      strncpy (mem_src_name, optarg, FILENAME_SZ);
      memfile = true;
    }
  }
 
  Vlcfg lcfg ("lcfg");
  lcfg.clk (clk);
  lcfg.reset_n(reset_n);
  lcfg.lcfg_init (lcfg_init);
  lcfg.lcfg_proc_reset (lcfg_proc_reset);
 
  lcfg.cfgi_irdy(cfgi_irdy);
  lcfg.cfgi_trdy(cfgi_trdy);
  lcfg.cfgi_addr(cfgi_addr);
  lcfg.cfgi_write(cfgi_write);
  lcfg.cfgi_rd_data(cfgi_rd_data);
  lcfg.cfgi_wr_data(cfgi_wr_data);
 
  lcfg.cfgo_irdy(cfgo_irdy);
  lcfg.cfgo_trdy(cfgo_trdy);
  lcfg.cfgo_addr(cfgo_addr);
  lcfg.cfgo_write(cfgo_write);
  lcfg.cfgo_rd_data(cfgo_rd_data);
  lcfg.cfgo_wr_data(cfgo_wr_data);
 
  it_cfg_driver driver ("driver");
  driver.clk (clk);
  driver.reset_n(reset_n);
 
  driver.cfgi_irdy(cfgi_irdy);
  driver.cfgi_trdy(cfgi_trdy);
  driver.cfgi_addr(cfgi_addr);
  driver.cfgi_write(cfgi_write);
  driver.cfgi_rd_data(cfgi_rd_data);
  driver.cfgi_wr_data(cfgi_wr_data);
 
  it_cfg_monitor monitor ("monitor");
  monitor.clk (clk);
  monitor.reset_n(reset_n);
 
  monitor.cfgo_irdy(cfgo_irdy);
  monitor.cfgo_trdy(cfgo_trdy);
  monitor.cfgo_addr(cfgo_addr);
  monitor.cfgo_write(cfgo_write);
  monitor.cfgo_rd_data(cfgo_rd_data);
  monitor.cfgo_wr_data(cfgo_wr_data);
 
 
  //env_memory env_memory0("env_memory0");
 
  // Start Verilator traces
  if (dumping) {
    Verilated::traceEverOn(true);
    tfp = new VerilatedVcdSc;
    lcfg.trace (tfp, 99);
    tfp->open (dumpfile_name);
  }
 
  // check for command line argument
  if (memfile) {
    int max, bused = 0;
    uint32_t cword;
    max = load_ihex (mem_src_name, memory, MAX_MEM_SIZE);
    printf ("Loading IHEX file %s, max addr=%d\n", mem_src_name, max);
    while (bused <= max) {
      cword = 0;
      for (int i=0; i<4; i++) cword |= (memory[bused++] << (i*8));
      printf ("Queueing %x\n", cword);
      driver.add_queue (cword);
    }
  }
 
  // set reset to 0 before sim start
  reset_n.write (0);
  lcfg_proc_reset.write(1);
 
  //sc_time *runtime = new sc_time(100, SC_NS);
  sc_time time100(100, SC_NS);
  sc_start(time100);
 
  reset_n.write (1);
 
  //delete runtime; runtime = new sc_time (1000, SC_NS);
  sc_start (sc_time(2500,SC_NS));
  lcfg_proc_reset.write(0);
 
  sc_start (sc_time(5000, SC_NS));
 
  /*
  sc_close_vcd_trace_file (trace_file);
  */
  if (dumping)
    tfp->close();
 
  return 0;
}