Subversion Repositories edge

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

//                                                              //

//  EX/MEM pipeline register                                    //

//                                                              //

//  This file is part of the Edge project                       //

//  http://www.opencores.org/project,edge                       //

//                                                              //

//  Description                                                 //

//  Pipeline register lies between execute and memory stages    //

//                                                              //

//  Author(s):                                                  //

//      - Hesham AL-Matary, heshamelmatary@gmail.com            //

//                                                              //

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

//                                                              //

// Copyright (C) 2014 Authors and OPENCORES.ORG                 //

//                                                              //

// This source file may be used and distributed without         //

// restriction provided that this copyright statement is not    //

// removed from the file and that any derivative work contains  //

// the original copyright notice and the associated disclaimer. //

//                                                              //

// This source file is free software; you can redistribute it   //

// and/or modify it under the terms of the GNU Lesser General   //

// Public License as published by the Free Software Foundation; //

// either version 2.1 of the License, or (at your option) any   //

// later version.                                               //

//                                                              //

// This source is distributed in the hope that it will be       //

// useful, but WITHOUT ANY WARRANTY; without even the implied   //

// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      //

// PURPOSE.  See the GNU Lesser General Public License for more //

// details.                                                     //

//                                                              //

// You should have received a copy of the GNU Lesser General    //

// Public License along with this source; if not, download it   //

// from http://www.opencores.org/lgpl.shtml                     //

//                                                              //

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

module ex_mem_pipereg

#

( parameter N=32,

  parameter M=5

)

(

  input clk,

  input reset,

  input en,

  input zero_in,

  input sign_in,

  input[N-1:0] ALUout_in,

  input[N-1:0] WriteData_in,

  input[N-1:0] PCBranch_in,

  input[N-1:0] PCJump_in,

  input[M-1:0] WriteReg_in,

  input RegWrite_in,

  input[1:0] WBResultSelect_in,

  input[5:0] opcode_in,

  input MemWrite_in,

  input Branch_in,

  input Jump_in,

  input JumpR_in,

  input[2:0] BHW_in, /* byte or halfword or word ? */

  input[N-1:0] lo_in,

  input[N-1:0] hi_in,

  input loEN,

  input hiEN,

  input[N-1:0] pcplus4_in,

  input link_in,

  /* Coprocessor0 and exceptions signals */

  input undefinedEx_in,

  input breakEx_in,

  input divbyZero_in,

  input syscallEx_in,

  input[M-1:0] CP0_wa_in,

  input[M-1:0] CP0_ra_in,

  input[1:0] CP0_Inst_in,

  input[N-1:0] CP0_dout_in,

  input[N-1:0] CP0_din_in,

  input[1:0] MemRefSize_in,

  output zero_out,

  output sign_out,

  output[N-1:0] ALUout_out,

  output[N-1:0] WriteData_out,

  output[N-1:0] PCBranch_out,

  output[N-1:0] PCJump_out,

  output[M-1:0] WriteReg_out,

  output RegWrite_out,

  output[1:0] WBResultSelect_out,

  output MemWrite_out,

  output Branch_out,

  output Jump_out,

  output JumpR_out,

  output[2:0] BHW_out, /* byte or halfword or word ? */

  output[N-1:0] lo_out,

  output[N-1:0] hi_out,

  output[5:0] opcode_out,

  output[N-1:0] pcplus4_out,

  output link_out,

  /* Coprocessor0 and exceptions signals */

  output undefinedEx_out,

  output breakEx_out,

  output divbyZero_out,

  output syscallEx_out,

  output[M-1:0] CP0_wa_out,

  output[M-1:0] CP0_ra_out,

  output[1:0] CP0_Inst_out,

  output[N-1:0] CP0_dout_out,

  output[N-1:0] CP0_din_out,

  output[1:0] MemRefSize_out

);

/* Opcode */

register #(6)

opcode

(

  .clk(clk), .reset(reset), .en(en),

  .d(opcode_in),

  .q(opcode_out)

);

/* Zero flag */

register #(1)

zero

(

  .clk(clk), .reset(reset), .en(en),

  .d(zero_in),

  .q(zero_out)

);

/* Sign Flag */

register #(1)

sign

(

  .clk(clk), .reset(reset), .en(en),

  .d(sign_in),

  .q(sign_out)

);

/* ALU output */

register ALUout

(

  .clk(clk), .reset(reset), .en(en),

  .d(ALUout_in),

  .q(ALUout_out)

);

/* PC plus 4 */

register pcplus4

(

  .clk(clk), .reset(reset), .en(en),

  .d(pcplus4_in),

  .q(pcplus4_out)

);

/* hi, lo special purpose registers */

register lo

(

  .clk(clk), .reset(0), .en(loEN),

  .d(lo_in),

  .q(lo_out)

);

register hi

(

  .clk(clk), .reset(0), .en(hiEN),

  .d(hi_in),

  .q(hi_out)

);

/* Write data in case of store instruction */

register WriteData

(

  .clk(clk), .reset(reset), .en(en),

  .d(WriteData_in),

  .q(WriteData_out)

);

/* Calcualted branch address */

register PCBranch

(

  .clk(clk), .reset(reset), .en(en),

  .d(PCBranch_in),

  .q(PCBranch_out)

);

/* Caluculated jump address */

register PCJump

(

  .clk(clk), .reset(reset), .en(en),

  .d(PCJump_in),

  .q(PCJump_out)

);

/* Write Register address */

register #(5)

WriteReg

(

  .clk(clk), .reset(reset), .en(en),

  .d(WriteReg_in),

  .q(WriteReg_out)

);

/* Control Signal */

register #(1)

RegWrite

(

  .clk(clk), .reset(reset), .en(en),

  .d(RegWrite_in),

  .q(RegWrite_out)

);

register #(1)

link

(

  .clk(clk), .reset(reset), .en(en),

  .d(link_in),

  .q(link_out)

);

register #(2)

WBResultSelect

(

  .clk(clk), .reset(reset), .en(en),

  .d(WBResultSelect_in),

  .q(WBResultSelect_out)

);

register #(1)

MemWrite

(

  .clk(clk), .reset(reset), .en(en),

  .d(MemWrite_in),

  .q(MemWrite_out)

);

register #(1)

Branch

(

  .clk(clk), .reset(reset), .en(en),

  .d(Branch_in),

  .q(Branch_out)

);

register #(1)

Jump

(

  .clk(clk),

  .reset(reset),

  .en(en),

  .d(Jump_in),

  .q(Jump_out)

);

register #(1)

JumpR

(

  .clk(clk), .reset(reset), .en(en),

  .d(JumpR_in),

  .q(JumpR_out)

);

register #(3)

BHW

(

  .clk(clk), .reset(reset), .en(en),

  .d(BHW_in),

  .q(BHW_out)

);

/* Coprocessor zero related */

register #(1)

undefinedEx

(

  .clk(clk), .reset(reset), .en(en),

  .d(undefinedEx_in),

  .q(undefinedEx_out)

);

register #(1)

breakEx

(

  .clk(clk),

  .reset(reset),

  .en(en),

  .d(breakEx_in),

  .q(breakEx_out)

);

register #(1)

divbyZero

(

  .clk(clk),

  .reset(reset),

  .en(en),

  .d(divbyZero_in),

  .q(divbyZero_out)

);

register #(1)

syscallEx

(

  .clk(clk), .reset(reset), .en(en),

  .d(syscallEx_in),

  .q(syscallEx_out)

);

register #(5)

CP0_wa

(

  .clk(clk), .reset(reset), .en(en),

  .d(CP0_wa_in),

  .q(CP0_wa_out)

);

register #(5)

CP0_ra

(

  .clk(clk), .reset(reset), .en(en),

  .d(CP0_ra_in),

  .q(CP0_ra_out)

);

register #(2)

CP0_Inst

(

  .clk(clk), .reset(reset), .en(en),

  .d(CP0_Inst_in),

  .q(CP0_Inst_out)

);

register CP0_dout

(

  .clk(clk), .reset(reset), .en(en),

  .d(CP0_dout_in),

  .q(CP0_dout_out)

);

register CP0_din

(

  .clk(clk),

  .reset(reset),

  .en(en),

  .d(CP0_din_in),

  .q(CP0_din_out)

);

/* Memory referece sizes */

register #(2)

MemRefSize

(

  .clk(clk), .reset(reset), .en(en),

  .d(MemRefSize_in),

  .q(MemRefSize_out)

);

endmodule