package rocket

import Chisel._
import scala.math._

object Constants
{
  val HAVE_RVC = false
  val HAVE_FPU = true
  val HAVE_VEC = false

  val BR_N    = UFix(0, 4);
  val BR_EQ   = UFix(1, 4);
  val BR_NE   = UFix(2, 4);
  val BR_LT   = UFix(3, 4);
  val BR_LTU  = UFix(4, 4);
  val BR_GE   = UFix(5, 4);
  val BR_GEU  = UFix(6, 4);
  val BR_J    = UFix(7, 4);
  val BR_JR   = UFix(8, 4);

  val PC_4    = UFix(0, 3);
  val PC_BTB  = UFix(1, 3);
  val PC_EX4  = UFix(2, 3);
  val PC_BR   = UFix(3, 3);
  val PC_PCR  = UFix(4, 3);
  val PC_WB   = UFix(5, 3);
  val PC_EVEC = UFix(6, 3);
  val PC_JR   = UFix(7, 3);

  val REN_Y = UFix(1, 1);
  val REN_N = UFix(0, 1);

  val A2_X     = UFix(0, 3);
  val A2_BTYPE = UFix(0, 3);
  val A2_LTYPE = UFix(1, 3);
  val A2_ITYPE = UFix(2, 3);
  val A2_ZERO  = UFix(4, 3);
  val A2_JTYPE = UFix(5, 3);
  val A2_RTYPE = UFix(6, 3);

  val MUL_X   = UFix(0, 2);
  val MUL_LO  = UFix(0, 2);
  val MUL_H   = UFix(1, 2);
  val MUL_HSU = UFix(2, 2);
  val MUL_HU  = UFix(3, 2);

  val DIV_X  = UFix(0, 2);
  val DIV_D  = UFix(0, 2);
  val DIV_DU = UFix(1, 2);
  val DIV_R  = UFix(2, 2);
  val DIV_RU = UFix(3, 2);

  val M_N = UFix(0, 1);
  val M_Y = UFix(1, 1);

  val WEN_N = UFix(0, 1);
  val WEN_Y = UFix(1, 1);

  val WA_X  = UFix(0, 1);
  val WA_RD = UFix(0, 1);
  val WA_RA = UFix(1, 1);

  val WB_X   = UFix(0, 3);
  val WB_PC  = UFix(0, 3);
  val WB_PCR = UFix(1, 3);
  val WB_ALU = UFix(2, 3);
  val WB_TSC = UFix(4, 3);
  val WB_IRT = UFix(5, 3);

  val N = UFix(0, 1);
  val Y = UFix(1, 1);

  val FN_X     = UFix(0, 4);
  val FN_ADD   = UFix(0, 4);
  val FN_SUB   = UFix(1, 4);
  val FN_SLT   = UFix(2, 4);
  val FN_SLTU  = UFix(3, 4);
  val FN_AND   = UFix(4, 4);
  val FN_OR    = UFix(5, 4);
  val FN_XOR   = UFix(6, 4);
  val FN_SL    = UFix(7, 4);
  val FN_SR    = UFix(8, 4);
  val FN_SRA   = UFix(9, 4);
  val FN_OP2   = UFix(10, 4);

  val DW_X  = UFix(0, 1);
  val DW_32 = UFix(0, 1);
  val DW_64 = UFix(1, 1);
  val DW_XPR = UFix(1, 1);

  val RA = UFix(1, 5);

  val MT_X  = Bits("b000", 3);
  val MT_B  = Bits("b000", 3);
  val MT_H  = Bits("b001", 3);
  val MT_W  = Bits("b010", 3);
  val MT_D  = Bits("b011", 3);
  val MT_BU = Bits("b100", 3);
  val MT_HU = Bits("b101", 3);
  val MT_WU = Bits("b110", 3);

  val M_X       = UFix(0, 4);
  val M_XRD     = Bits("b0000", 4); // int load
  val M_XWR     = Bits("b0001", 4); // int store
  val M_PFR     = Bits("b0010", 4); // prefetch with intent to read
  val M_PFW     = Bits("b0011", 4); // prefetch with intent to write
  val M_FLA     = Bits("b0100", 4); // write back and invlaidate all lines
  val M_FENCE   = Bits("b0101", 4); // memory fence
  val M_INV     = Bits("b0110", 4); // write back and invalidate line
  val M_CLN     = Bits("b0111", 4); // write back line
  val M_XA_ADD  = Bits("b1000", 4);
  val M_XA_SWAP = Bits("b1001", 4);
  val M_XA_AND  = Bits("b1010", 4);
  val M_XA_OR   = Bits("b1011", 4);
  val M_XA_MIN  = Bits("b1100", 4);
  val M_XA_MAX  = Bits("b1101", 4);
  val M_XA_MINU = Bits("b1110", 4);
  val M_XA_MAXU = Bits("b1111", 4);
  
  val I_X  = Bits(0,2);
  val I_DI = Bits(1,2);
  val I_EI = Bits(2,2);
  
  val SYNC_N    = Bits(0,2);
  val SYNC_D    = Bits(1,2);
  val SYNC_I    = Bits(2,2);

  val PCR_STATUS   = UFix( 0, 5);
  val PCR_EPC      = UFix( 1, 5);
  val PCR_BADVADDR = UFix( 2, 5);
  val PCR_EVEC     = UFix( 3, 5);
  val PCR_COUNT    = UFix( 4, 5);
  val PCR_COMPARE  = UFix( 5, 5);
  val PCR_CAUSE    = UFix( 6, 5);
  val PCR_PTBR     = UFix( 7, 5);
  val PCR_SEND_IPI = UFix( 8, 5);
  val PCR_CLR_IPI  = UFix( 9, 5);
  val PCR_COREID   = UFix(10, 5);
  val PCR_K0       = UFix(12, 5);
  val PCR_K1       = UFix(13, 5);
  val PCR_TOHOST   = UFix(16, 5);
  val PCR_FROMHOST = UFix(17, 5);
  val PCR_VECBANK  = UFix(18, 5);
  val PCR_VECCFG   = UFix(19, 5);
  val PCR_VECIRQAUX= UFix(20, 5)

  // definition of bits in PCR status reg
  val SR_ET   = 0;  // enable traps
  val SR_EF   = 1;  // enable floating point
  val SR_EV   = 2;  // enable vector unit
  val SR_EC   = 3;  // enable compressed instruction encoding
  val SR_PS   = 4;  // mode stack bit
  val SR_S    = 5;  // user/supervisor mode
  val SR_UX   = 6;  // 64 bit user mode
  val SR_SX   = 7;  // 64 bit supervisor mode
  val SR_VM   = 16; // VM enable
  
  val COREID = 0;
  val PADDR_BITS = 40;
  val VADDR_BITS = 43;
  val PGIDX_BITS = 13;
  val PPN_BITS = PADDR_BITS-PGIDX_BITS;
  val VPN_BITS = VADDR_BITS-PGIDX_BITS;
  val ASID_BITS = 7;
  val PERM_BITS = 6;

  // rocketNBDCache parameters
  val DCACHE_PORTS = 3
  val CPU_DATA_BITS = 64;
  val CPU_TAG_BITS = 9;
  val DCACHE_TAG_BITS = log2up(DCACHE_PORTS) + CPU_TAG_BITS
  val OFFSET_BITS = 6; // log2(cache line size in bytes)
  val NMSHR = if (HAVE_VEC) 4 else 2 // number of primary misses
  val NRPQ = 16; // number of secondary misses
  val NSDQ = 17; // number of secondary stores/AMOs
  val LG_REFILL_WIDTH = 4; // log2(cache bus width in bytes)
  val IDX_BITS = 7;
  val TAG_BITS = PADDR_BITS - OFFSET_BITS - IDX_BITS;
  val NWAYS = 4
  require(IDX_BITS+OFFSET_BITS <= PGIDX_BITS);

  // coherence parameters
  val COHERENCE_DATA_BITS = (1 << OFFSET_BITS)*8 
  val TILE_ID_BITS = 1
  val TILE_XACT_ID_BITS = log2up(NMSHR)+3
  val GLOBAL_XACT_ID_BITS = 2
  val NGLOBAL_XACTS = 1 << GLOBAL_XACT_ID_BITS

  val X_INIT_TYPE_BITS = 2
  val X_INIT_READ_SHARED    = UFix(0, X_INIT_TYPE_BITS)
  val X_INIT_READ_EXCLUSIVE = UFix(1, X_INIT_TYPE_BITS)
  val X_INIT_READ_UNCACHED  = UFix(2, X_INIT_TYPE_BITS)
  val X_INIT_WRITE_UNCACHED = UFix(3, X_INIT_TYPE_BITS)

  val X_REP_TYPE_BITS = 3
  val X_REP_READ_SHARED    = UFix(0, X_REP_TYPE_BITS)
  val X_REP_READ_EXCLUSIVE = UFix(1, X_REP_TYPE_BITS)
  val X_REP_READ_UNCACHED  = UFix(2, X_REP_TYPE_BITS)
  val X_REP_WRITE_UNCACHED = UFix(3, X_REP_TYPE_BITS)
  val X_REP_READ_EXCLUSIVE_ACK = UFix(4, X_REP_TYPE_BITS)

  val P_REQ_TYPE_BITS = 2
  val P_REQ_INVALIDATE = UFix(0, P_REQ_TYPE_BITS)
  val P_REQ_DOWNGRADE  = UFix(1, P_REQ_TYPE_BITS)
  val P_REQ_COPY       = UFix(2, P_REQ_TYPE_BITS)

  val P_REP_TYPE_BITS = 3
  val P_REP_INVALIDATE_DATA = UFix(0, P_REP_TYPE_BITS)
  val P_REP_DOWNGRADE_DATA  = UFix(1, P_REP_TYPE_BITS)
  val P_REP_COPY_DATA       = UFix(2, P_REP_TYPE_BITS)
  val P_REP_INVALIDATE_ACK  = UFix(3, P_REP_TYPE_BITS)
  val P_REP_DOWNGRADE_ACK   = UFix(4, P_REP_TYPE_BITS)
  val P_REP_COPY_ACK        = UFix(5, P_REP_TYPE_BITS)

  // external memory interface
  val MEM_TAG_BITS = max(TILE_XACT_ID_BITS, GLOBAL_XACT_ID_BITS)
  val MEM_DATA_BITS = 128
  val REFILL_CYCLES = (1 << OFFSET_BITS)*8/MEM_DATA_BITS
  
  val DTLB_ENTRIES = 16
  val ITLB_ENTRIES = 8;
  val VITLB_ENTRIES = 4
  
  val START_ADDR = 0x2000;

  val FPU_N = UFix(0, 1);
  val FPU_Y = if (HAVE_FPU) UFix(1, 1) else FPU_N;

  val VEC_N = UFix(0, 1);
  val VEC_Y = if (HAVE_VEC) UFix(1, 1) else VEC_N;

  val VEC_X = UFix(0, 2)
  val VEC_FN_N = UFix(0, 2)
  val VEC_VL = UFix(1, 2)
  val VEC_CFG = UFix(2, 2)
  val VEC_CFGVL = UFix(3, 2)

  val VCMD_I = UFix(0, 3)
  val VCMD_F = UFix(1, 3)
  val VCMD_TX = UFix(2, 3)
  val VCMD_TF = UFix(3, 3)
  val VCMD_MX = UFix(4, 3)
  val VCMD_MF = UFix(5, 3)
  val VCMD_A = UFix(6, 3)
  val VCMD_X = UFix(0, 3)

  val VIMM_VLEN = UFix(0, 1)
  val VIMM_ALU = UFix(1, 1)
  val VIMM_X = UFix(0, 1)

  val VIMM2_RS2 = UFix(0, 1)
  val VIMM2_ALU = UFix(1, 1)
  val VIMM2_X = UFix(0, 1)

  val DTLB_CPU = 0
  val DTLB_VEC = 1
  val DTLB_VPF = 2

  val DMEM_CPU = 0
  val DMEM_PTW = 1
  val DMEM_VU = 2
}