www.pudn.com > noc.rar > brom4k.h

/*
 *  TU Eindhoven
 *  Eindhoven, The Netherlands
 *
 *  Name            :   brom4k.h
 *
 *  Author          :   A.S.Slusarczyk@tue.nl
 *
 *  Date            :   
 *
 *  Function        :   Xilinx-Block-RAM-based ROM
 *
 *
 */
 
#ifndef BROM4K_H_INCLUDED
#define BROM4K_H_INCLUDED

#include "mips.h"
#include "xlxram.h"

// wrapper around BlockRAM memory
SC_MODULE(ROM4KCONV) {
	sc_in <	sc_bv > addr;
	sc_out< sc_bv > dout;
	sc_out< bool > memwait;
	sc_in<	bool		 > memclk;
	sc_in<	sc_bv<1>	 > en;

	sc_in > DO;
	sc_in > DOP;
	sc_out > ADDR;
	sc_out > DI;
	sc_out > DIP;
	sc_out EN;
	sc_out CLK;
	sc_out WE;
	sc_out SSR;

	void clock();
	void in();
	void out();
	
	SC_CTOR(ROM4KCONV) {
	  
	  SC_METHOD(in);
	  sensitive << addr << en;
	  
	  SC_METHOD(out);
	  sensitive << DO << DOP;

	  SC_METHOD(clock);
	  sensitive << memclk;
	};
	
};

// Converter for the debugging access
SC_MODULE(DBGBROM4KCONV) {

  sc_out > DO;
  sc_in > ADDR;
  sc_in > DI;
  sc_in EN;
  sc_in CLK;
  sc_in WE;
  sc_in RST;

  sc_in > mDO;
  sc_in > mDOP;
  sc_out > mADDR;
  sc_out > mDI;
  sc_out > mDIP;
  sc_out mEN;
  sc_out mCLK;
  sc_out mWE;
  sc_out mSSR;

  void in();
  void out();
	
  SC_CTOR(DBGBROM4KCONV) {  
	SC_METHOD(in);
	sensitive << ADDR << DI << EN << WE << RST << CLK;
	  
	SC_METHOD(out);
	sensitive << mDO << mDOP;
  };
	
};

SC_MODULE(ROM4K) {
	sc_in <	sc_bv > addr;
	sc_out< sc_bv > dout;
	sc_in<	bool		 > clk;
	sc_out< bool > memwait;

	sc_in<	sc_bv<1>	 > en;
	
	RAMB16_S36_S36 *bram;
	ROM4KCONV *conv;
	
	sc_signal > DO;
	sc_signal > DOP, DIP;
	sc_signal > ADDR;
	sc_signal > DI;
	sc_signal EN;
	sc_signal CLK;
	sc_signal WE;
	sc_signal SSR;

	DBGBROM4KCONV *dbgconv;
	
	sc_out > dbgDO;
	sc_in > dbgADDR;
	sc_in > dbgDI;
	sc_in dbgEN;
	sc_in dbgCLK;
	sc_in dbgWE;
	sc_in dbgRST;

	sc_signal > dDO;
	sc_signal > dDOP, dDIP;
	sc_signal > dADDR;
	sc_signal > dDI;
	sc_signal dEN;
	sc_signal dCLK;
	sc_signal dWE;
	sc_signal dSSR;

#ifndef VERILOG
	void mem_init(const char *filename);
	void mem_dump(const char *filename);
#endif
	
	SC_CTOR(ROM4K) {
	  bram = new RAMB16_S36_S36("bram");
	  conv = new ROM4KCONV("conv");
	  
	  
	  bram->DOA(DO);
	  conv->DO(DO);
	  bram->DOPA(DOP);
	  conv->DOP(DOP);
	  bram->ADDRA(ADDR);
	  conv->ADDR(ADDR);
	  bram->DIA(DI);
	  conv->DI(DI);
	  bram->DIPA(DIP);
	  conv->DIP(DIP);
	  bram->ENA(EN);
	  conv->EN(EN);
	  bram->CLKA(CLK);
	  conv->CLK(CLK);
	  bram->WEA(WE);
	  conv->WE(WE);
	  bram->SSRA(SSR);
	  conv->SSR(SSR);
	  
	  conv->addr(addr);
	  conv->dout(dout);
	  conv->memwait(memwait);
	  conv->memclk(clk);	  
	  conv->en(en);

	  dbgconv = new DBGBROM4KCONV("dbgconv");

	  dbgconv->DO(dbgDO);
	  dbgconv->ADDR(dbgADDR);
	  dbgconv->DI(dbgDI);
	  dbgconv->EN(dbgEN);
	  dbgconv->CLK(dbgCLK);
	  dbgconv->WE(dbgWE);
	  dbgconv->RST(dbgRST);
	  
	  bram->DOB(dDO);	  dbgconv->mDO(dDO);
	  bram->DOPB(dDOP);	  dbgconv->mDOP(dDOP);
	  bram->ADDRB(dADDR);	  dbgconv->mADDR(dADDR);
	  bram->DIB(dDI);	  dbgconv->mDI(dDI);
	  bram->DIPB(dDIP);	  dbgconv->mDIP(dDIP);
	  bram->ENB(dEN);	  dbgconv->mEN(dEN);
	  bram->CLKB(dCLK);	  dbgconv->mCLK(dCLK);
	  bram->WEB(dWE);	  dbgconv->mWE(dWE);
	  bram->SSRB(dSSR);	  dbgconv->mSSR(dSSR);

	};
};

#endif