Subversion Repositories s1_core

// ========== Copyright Header Begin ==========================================

// 

// OpenSPARC T1 Processor File: sparc_exu_ecl_mdqctl.v

// Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.

// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.

// 

// The above named program is free software; you can redistribute it and/or

// modify it under the terms of the GNU General Public

// License version 2 as published by the Free Software Foundation.

// 

// The above named program 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

// General Public License for more details.

// 

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

// License along with this work; if not, write to the Free Software

// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.

// 

// ========== Copyright Header End ============================================

`ifdef SIMPLY_RISC_TWEAKS

`define SIMPLY_RISC_SCANIN .si(0)

`else

`define SIMPLY_RISC_SCANIN .si()

`endif

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

/*

//  Module Name: sparc_exu_ecl_mdqctl

//      Description:  This block is the control logic for the multiply/divide

//      input buffer.  It generates the select lines for both the output

//      to mul and div, as well as for moving the data within the buffer.

//      There are 4 slots in the buffer, which is a modified FIFO.

//      It will output 1 MUL and 1 DIV every cycle, as well as whether those

//      outputs are valid.  If none of the slots contain a valid entry, it

//      will pass through the input to the output.  If a kill comes through

//      and invalidates an entry, it will show up on the valid bit coming out

//      of the mdq, but may cause a lost cycle as the kill won't affect the logic

//      which chooses the output until the next cycle.  The block also

//      stores the thr, rd, setcc and other control bits for each entry.

*/

`define MULS 10

`define IS64 9

`define SIGNED 8

`define SET_CC 7

module sparc_exu_ecl_mdqctl (/*AUTOARG*/

   // Outputs

   mdqctl_divcntl_input_vld, mdqctl_divcntl_reset_div,

   mdqctl_divcntl_muldone, ecl_div_div64, ecl_div_signed_div,

   ecl_div_muls, mdqctl_wb_divthr_g, mdqctl_wb_divrd_g,

   mdqctl_wb_multhr_g, mdqctl_wb_mulrd_g, mdqctl_wb_divsetcc_g,

   mdqctl_wb_mulsetcc_g, mdqctl_wb_yreg_shift_g, exu_mul_input_vld,

   mdqctl_wb_yreg_wen_g, ecl_div_mul_sext_rs1_e,

   ecl_div_mul_sext_rs2_e, ecl_div_mul_get_new_data,

   ecl_div_mul_keep_data, ecl_div_mul_get_32bit_data,

   ecl_div_mul_wen, div_zero_m,

   // Inputs

   clk, se, reset, ifu_exu_muldivop_d, tid_d, ifu_exu_rd_d, tid_w1,

   flush_w1, ifu_exu_inst_vld_w, wb_divcntl_ack_g, divcntl_wb_req_g,

   byp_alu_rs1_data_31_e, byp_alu_rs2_data_31_e, mul_exu_ack,

   ecl_div_sel_div, ifu_exu_muls_d, div_ecl_detect_zero_high,

   div_ecl_detect_zero_low, ifu_tlu_flush_w, early_flush_w

   ) ;

   input clk;

   input se;

   input reset;

   input [4:0] ifu_exu_muldivop_d;

   input [1:0] tid_d;

   input [4:0] ifu_exu_rd_d;

   input [1:0] tid_w1;

   input       flush_w1;

   input       ifu_exu_inst_vld_w;

   input       wb_divcntl_ack_g;

   input       divcntl_wb_req_g;

   input       byp_alu_rs1_data_31_e;

   input       byp_alu_rs2_data_31_e;

   input       mul_exu_ack;

   input       ecl_div_sel_div;

   input       ifu_exu_muls_d;

   input       div_ecl_detect_zero_high;

   input       div_ecl_detect_zero_low;

   input       ifu_tlu_flush_w;

   input       early_flush_w;

   output      mdqctl_divcntl_input_vld;

   output      mdqctl_divcntl_reset_div;

   output      mdqctl_divcntl_muldone;

   output      ecl_div_div64;

   output      ecl_div_signed_div;

   output      ecl_div_muls;

   output [1:0] mdqctl_wb_divthr_g;

   output [4:0] mdqctl_wb_divrd_g;

   output [1:0] mdqctl_wb_multhr_g;

   output [4:0] mdqctl_wb_mulrd_g;

   output       mdqctl_wb_divsetcc_g;

   output       mdqctl_wb_mulsetcc_g;

   output       mdqctl_wb_yreg_shift_g;

   output       exu_mul_input_vld;

   output       mdqctl_wb_yreg_wen_g;

   output       ecl_div_mul_sext_rs1_e;

   output       ecl_div_mul_sext_rs2_e;

   output       ecl_div_mul_get_new_data;

   output       ecl_div_mul_keep_data;

   output       ecl_div_mul_get_32bit_data;

   output       ecl_div_mul_wen;

   output   div_zero_m;

   wire [11:0] div_data_next;

   wire [11:0] div_data;

   wire        new_div_vld;

   wire        curr_div_vld;

   wire [11:0] div_input_data_d;

   wire [9:0] mul_input_data_d;

   wire [9:0] mul_data;

   wire [9:0] mul_data_next;

   wire        new_mul_d;

   wire        kill_thr_mul;

   wire        mul_kill;

   wire        invalid_mul_w;

   wire        div_kill;

   wire        kill_thr_div;

   wire        mul_ready_next;

   wire        mul_ready;

   wire        mul_done_valid_c0;

   wire        mul_done_valid_c1;

   wire        mul_done_ack;

   wire        mul_done_c0;

   wire        mul_done_c1;

   wire        mul_done_c2;

   wire        mul_done_c3;

   wire        isdiv_e_valid;

   wire        isdiv_m_valid;

   wire        ismul_e_valid;

   wire        ismul_m_valid;

   wire        isdiv_e;

   wire        isdiv_m;

   wire        isdiv_w;

   wire        ismul_e;

   wire        ismul_m;

   wire        ismul_w;

   wire        div_used;

   wire        invalid_div_w;

   wire        div_zero_e;

   // Mul result state wires

   wire        go_mul_done;

   wire        stay_mul_done;

   wire        mul_done;

   wire        next_mul_done;

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

   // Divide  output DATAPATH

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

   // store control signals

   assign div_used = divcntl_wb_req_g & wb_divcntl_ack_g & ecl_div_sel_div;

   assign new_div_vld = ifu_exu_muls_d | ifu_exu_muldivop_d[3];

   assign div_input_data_d[11:0] = {1'b1, // isdiv

                                    ifu_exu_muls_d,

                                    ifu_exu_muldivop_d[2], // 64bit

                                    ifu_exu_muldivop_d[1], // signed

                                    ifu_exu_muldivop_d[0], // setcc

                                    ifu_exu_rd_d[4:0],

                                    tid_d[1:0]};

   mux2ds #(12) div_data_mux(.dout(div_data_next[11:0]),

                                .in0({curr_div_vld, div_data[10:0]}),

                                .in1(div_input_data_d[11:0]),

                                .sel0(~new_div_vld),

                                .sel1(new_div_vld));

   dffr_s #(12) div_data_dff(.din(div_data_next[11:0]), .clk(clk), .q(div_data[11:0]),

                          .se(se), `SIMPLY_RISC_SCANIN, .so(), .rst(reset));

   //div  kill logic (kills on div by zero exception or if there isn't an outstanding div)

   assign div_zero_e = isdiv_e & div_ecl_detect_zero_high & div_ecl_detect_zero_low & ~div_data[`MULS];

   assign invalid_div_w = isdiv_w & (~ifu_exu_inst_vld_w | ifu_tlu_flush_w | early_flush_w);

   assign kill_thr_div = ~(div_data[1] ^ tid_w1[1]) & ~(div_data[0] ^ tid_w1[0]);

   assign div_kill = (flush_w1 & kill_thr_div) | invalid_div_w | new_div_vld;

   assign curr_div_vld = div_data[11] & ~div_zero_m & ~div_kill & ~div_used;

   wire   div_zero_unqual_m;

   assign div_zero_m = div_zero_unqual_m & isdiv_m;

   dff_s div_zero_e2m(.din(div_zero_e), .clk(clk), .q(div_zero_unqual_m), .se(se), `SIMPLY_RISC_SCANIN, .so());

   // pipeling for divide valid signal (for inst_vld checking)

   dff_s isdiv_d2e(.din(new_div_vld), .clk(clk), .q(isdiv_e),

                 .se(se), `SIMPLY_RISC_SCANIN, .so());

   dff_s isdiv_e2m(.din(isdiv_e_valid), .clk(clk), .q(isdiv_m),

                 .se(se), `SIMPLY_RISC_SCANIN, .so());

   dff_s isdiv_m2w(.din(isdiv_m_valid), .clk(clk), .q(isdiv_w),

                 .se(se), `SIMPLY_RISC_SCANIN, .so());

   assign        isdiv_e_valid = isdiv_e & ~div_kill;

   assign        isdiv_m_valid = isdiv_m & ~div_kill;

   // control for div state machine

   assign mdqctl_divcntl_reset_div = (~div_data[11] | div_kill);

   assign mdqctl_divcntl_input_vld = isdiv_e;

   // control signals for div

   assign ecl_div_div64 = div_data[`IS64];

   assign ecl_div_signed_div = div_data[`SIGNED];

   assign ecl_div_muls = div_data[`MULS];

   // control for writeback on completion

   assign mdqctl_wb_divrd_g[4:0] = div_data[6:2];

   assign mdqctl_wb_divthr_g[1:0] = div_data[1:0];

   assign mdqctl_wb_divsetcc_g = div_data[`SET_CC] | div_data[`MULS];

   assign mdqctl_wb_yreg_shift_g = div_used & div_data[`MULS];

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

   // Multiply control

   //----------------------

   // The multiply will drop the current operation if a new request is issued.

   // This requires addition checking to make sure that the kills are for the

   // proper operation.

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

   dff_s ismul_d2e(.din(ifu_exu_muldivop_d[4]), .clk(clk), .q(ismul_e),

                 .se(se), `SIMPLY_RISC_SCANIN, .so());

   dff_s ismul_e2m(.din(ismul_e_valid), .clk(clk), .q(ismul_m),

                 .se(se), `SIMPLY_RISC_SCANIN, .so());

   dff_s ismul_m2w(.din(ismul_m_valid), .clk(clk), .q(ismul_w),

                 .se(se), `SIMPLY_RISC_SCANIN, .so());

   assign ismul_e_valid = ismul_e & ~mul_kill;

   assign        ismul_m_valid = ismul_m & ~mul_kill & ~ismul_e;

   // store control signals

  //   assign mul_used = divcntl_wb_req_g & wb_divcntl_ack_g & ~ecl_div_sel_div;

   assign new_mul_d = ifu_exu_muldivop_d[4];

   assign mul_input_data_d[9:0] = {ifu_exu_muldivop_d[2], // 64bit

                                    ifu_exu_muldivop_d[1], // signed

                                    ifu_exu_muldivop_d[0], // setcc

                                    ifu_exu_rd_d[4:0],

                                    tid_d[1:0]};

   assign mul_data_next[9:0] = (new_mul_d)? mul_input_data_d[9:0]: mul_data[9:0];

   dff_s #(10) mul_data_dff(.din(mul_data_next[9:0]), .clk(clk), .q(mul_data[9:0]),

                          .se(se), `SIMPLY_RISC_SCANIN, .so());

   // mul kill logic

   assign kill_thr_mul = ~(mul_data[1] ^ tid_w1[1]) & ~(mul_data[0] ^ tid_w1[0]);

   assign mul_kill = (flush_w1 & kill_thr_mul) | reset;

   assign invalid_mul_w = ismul_w & ~ifu_exu_inst_vld_w;

   // control signals for mul data in div unit

   assign      ecl_div_mul_keep_data = ~ismul_e;

   assign      ecl_div_mul_get_new_data = ismul_e & mul_data[`IS64];

   assign      ecl_div_mul_get_32bit_data = ismul_e & ~mul_data[`IS64];

   assign      ecl_div_mul_sext_rs1_e = byp_alu_rs1_data_31_e & mul_data[`SIGNED];

   assign      ecl_div_mul_sext_rs2_e = byp_alu_rs2_data_31_e & mul_data[`SIGNED];

   // control for writeback on completion

   assign      mdqctl_wb_yreg_wen_g = ~mul_data[`IS64] & ecl_div_mul_wen;

   assign      mdqctl_wb_multhr_g[1:0] = mul_data[1:0];

   assign      mdqctl_wb_mulsetcc_g = mul_data[`SET_CC];

   assign      mdqctl_wb_mulrd_g[4:0] = mul_data[6:2];

   // interface with mul and state of pending mul

   assign      mul_ready_next = ismul_e_valid | (mul_ready & ~mul_exu_ack & ~mul_kill & ~ismul_e & ~invalid_mul_w);

   dff_s mul_ready_dff(.din(mul_ready_next), .clk(clk), .q(mul_ready), .se(se), `SIMPLY_RISC_SCANIN, .so());

   assign      exu_mul_input_vld = mul_ready;

   // If there was a valid request and an ack then start passing down pipe

   assign      mul_done_ack = mul_ready & ~mul_kill & ~ismul_e & mul_exu_ack & ~invalid_mul_w;

   dff_s dff_done_ack2c0(.din(mul_done_ack), .clk(clk), .q(mul_done_c0),

                       .se(se), `SIMPLY_RISC_SCANIN, .so());

   // need to check here cause this could be w

   assign        mul_done_valid_c0 = mul_done_c0 & ~mul_kill & ~invalid_mul_w & ~ismul_e;

   dff_s dff_done_c02c1(.din(mul_done_valid_c0), .clk(clk), .q(mul_done_c1),

                       .se(se), `SIMPLY_RISC_SCANIN, .so());

   // need to check here cause this could be w1

   assign        mul_done_valid_c1 = mul_done_c1 & ~mul_kill & ~ismul_e;

   dff_s dff_done_c1c2(.din(mul_done_valid_c1), .clk(clk), .q(mul_done_c2),

                       .se(se), `SIMPLY_RISC_SCANIN, .so());

   dff_s dff_done_c22c3(.din(mul_done_c2), .clk(clk), .q(mul_done_c3),

                       .se(se), `SIMPLY_RISC_SCANIN, .so());

   dff_s dff_done_c32c4(.din(mul_done_c3), .clk(clk), .q(ecl_div_mul_wen),

                       .se(se), `SIMPLY_RISC_SCANIN, .so());

   // Mul result state machine

   assign        go_mul_done = ~mul_done & ecl_div_mul_wen;

   assign        stay_mul_done = mul_done & (~wb_divcntl_ack_g | ecl_div_sel_div);

   assign        next_mul_done = ~reset & (go_mul_done | stay_mul_done);

   assign        mdqctl_divcntl_muldone = mul_done;

   // mul state flop

   dff_s  mulstate_dff(.din(next_mul_done), .clk(clk), .q(mul_done), .se(se), `SIMPLY_RISC_SCANIN,

                     .so());

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

   // Pipeline registers for control signals

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

endmodule // sparc_exu_ecl_mdqctl