| module ibex_multdiv_fast ( |
| clk_i, |
| rst_ni, |
| mult_en_i, |
| div_en_i, |
| mult_sel_i, |
| div_sel_i, |
| operator_i, |
| signed_mode_i, |
| op_a_i, |
| op_b_i, |
| alu_adder_ext_i, |
| alu_adder_i, |
| equal_to_zero_i, |
| data_ind_timing_i, |
| alu_operand_a_o, |
| alu_operand_b_o, |
| imd_val_q_i, |
| imd_val_d_o, |
| imd_val_we_o, |
| multdiv_ready_id_i, |
| multdiv_result_o, |
| valid_o |
| ); |
| parameter integer RV32M = 32'sd2; |
| input wire clk_i; |
| input wire rst_ni; |
| input wire mult_en_i; |
| input wire div_en_i; |
| input wire mult_sel_i; |
| input wire div_sel_i; |
| input wire [1:0] operator_i; |
| input wire [1:0] signed_mode_i; |
| input wire [31:0] op_a_i; |
| input wire [31:0] op_b_i; |
| input wire [33:0] alu_adder_ext_i; |
| input wire [31:0] alu_adder_i; |
| input wire equal_to_zero_i; |
| input wire data_ind_timing_i; |
| output reg [32:0] alu_operand_a_o; |
| output reg [32:0] alu_operand_b_o; |
| input wire [67:0] imd_val_q_i; |
| output wire [67:0] imd_val_d_o; |
| output wire [1:0] imd_val_we_o; |
| input wire multdiv_ready_id_i; |
| output wire [31:0] multdiv_result_o; |
| output wire valid_o; |
| wire signed [34:0] mac_res_signed; |
| wire [34:0] mac_res_ext; |
| reg [33:0] accum; |
| reg sign_a; |
| reg sign_b; |
| reg mult_valid; |
| wire signed_mult; |
| reg [33:0] mac_res_d; |
| reg [33:0] op_remainder_d; |
| wire [33:0] mac_res; |
| wire div_sign_a; |
| wire div_sign_b; |
| reg is_greater_equal; |
| wire div_change_sign; |
| wire rem_change_sign; |
| wire [31:0] one_shift; |
| wire [31:0] op_denominator_q; |
| reg [31:0] op_numerator_q; |
| reg [31:0] op_quotient_q; |
| reg [31:0] op_denominator_d; |
| reg [31:0] op_numerator_d; |
| reg [31:0] op_quotient_d; |
| wire [31:0] next_remainder; |
| wire [32:0] next_quotient; |
| wire [31:0] res_adder_h; |
| reg div_valid; |
| reg [4:0] div_counter_q; |
| reg [4:0] div_counter_d; |
| wire multdiv_en; |
| reg mult_hold; |
| reg div_hold; |
| reg div_by_zero_d; |
| reg div_by_zero_q; |
| wire mult_en_internal; |
| wire div_en_internal; |
| reg [2:0] md_state_q; |
| reg [2:0] md_state_d; |
| wire unused_mult_sel_i; |
| assign unused_mult_sel_i = mult_sel_i; |
| assign mult_en_internal = mult_en_i & ~mult_hold; |
| assign div_en_internal = div_en_i & ~div_hold; |
| always @(posedge clk_i or negedge rst_ni) |
| if (!rst_ni) begin |
| div_counter_q <= 1'sb0; |
| md_state_q <= 3'd0; |
| op_numerator_q <= 1'sb0; |
| op_quotient_q <= 1'sb0; |
| div_by_zero_q <= 1'sb0; |
| end |
| else if (div_en_internal) begin |
| div_counter_q <= div_counter_d; |
| op_numerator_q <= op_numerator_d; |
| op_quotient_q <= op_quotient_d; |
| md_state_q <= md_state_d; |
| div_by_zero_q <= div_by_zero_d; |
| end |
| assign multdiv_en = mult_en_internal | div_en_internal; |
| assign imd_val_d_o[34+:34] = (div_sel_i ? op_remainder_d : mac_res_d); |
| assign imd_val_we_o[0] = multdiv_en; |
| assign imd_val_d_o[0+:34] = {2'b00, op_denominator_d}; |
| assign imd_val_we_o[1] = div_en_internal; |
| assign op_denominator_q = imd_val_q_i[31-:32]; |
| wire [1:0] unused_imd_val; |
| assign unused_imd_val = imd_val_q_i[33-:2]; |
| wire unused_mac_res_ext; |
| assign unused_mac_res_ext = mac_res_ext[34]; |
| assign signed_mult = signed_mode_i != 2'b00; |
| assign multdiv_result_o = (div_sel_i ? imd_val_q_i[65-:32] : mac_res_d[31:0]); |
| generate |
| if (RV32M == 32'sd3) begin : gen_mult_single_cycle |
| reg mult_state_q; |
| reg mult_state_d; |
| wire signed [33:0] mult1_res; |
| wire signed [33:0] mult2_res; |
| wire signed [33:0] mult3_res; |
| wire [33:0] mult1_res_uns; |
| wire [33:32] unused_mult1_res_uns; |
| wire [15:0] mult1_op_a; |
| wire [15:0] mult1_op_b; |
| wire [15:0] mult2_op_a; |
| wire [15:0] mult2_op_b; |
| reg [15:0] mult3_op_a; |
| reg [15:0] mult3_op_b; |
| wire mult1_sign_a; |
| wire mult1_sign_b; |
| wire mult2_sign_a; |
| wire mult2_sign_b; |
| reg mult3_sign_a; |
| reg mult3_sign_b; |
| reg [33:0] summand1; |
| reg [33:0] summand2; |
| reg [33:0] summand3; |
| assign mult1_res = $signed({mult1_sign_a, mult1_op_a}) * $signed({mult1_sign_b, mult1_op_b}); |
| assign mult2_res = $signed({mult2_sign_a, mult2_op_a}) * $signed({mult2_sign_b, mult2_op_b}); |
| assign mult3_res = $signed({mult3_sign_a, mult3_op_a}) * $signed({mult3_sign_b, mult3_op_b}); |
| assign mac_res_signed = ($signed(summand1) + $signed(summand2)) + $signed(summand3); |
| assign mult1_res_uns = $unsigned(mult1_res); |
| assign mac_res_ext = $unsigned(mac_res_signed); |
| assign mac_res = mac_res_ext[33:0]; |
| wire [1:1] sv2v_tmp_822BD; |
| assign sv2v_tmp_822BD = signed_mode_i[0] & op_a_i[31]; |
| always @(*) sign_a = sv2v_tmp_822BD; |
| wire [1:1] sv2v_tmp_4DE54; |
| assign sv2v_tmp_4DE54 = signed_mode_i[1] & op_b_i[31]; |
| always @(*) sign_b = sv2v_tmp_4DE54; |
| assign mult1_sign_a = 1'b0; |
| assign mult1_sign_b = 1'b0; |
| assign mult1_op_a = op_a_i[15:0]; |
| assign mult1_op_b = op_b_i[15:0]; |
| assign mult2_sign_a = 1'b0; |
| assign mult2_sign_b = sign_b; |
| assign mult2_op_a = op_a_i[15:0]; |
| assign mult2_op_b = op_b_i[31:16]; |
| wire [18:1] sv2v_tmp_915C6; |
| assign sv2v_tmp_915C6 = imd_val_q_i[67-:18]; |
| always @(*) accum[17:0] = sv2v_tmp_915C6; |
| wire [16:1] sv2v_tmp_2094F; |
| assign sv2v_tmp_2094F = {16 {signed_mult & imd_val_q_i[67]}}; |
| always @(*) accum[33:18] = sv2v_tmp_2094F; |
| always @(*) begin |
| mult3_sign_a = sign_a; |
| mult3_sign_b = 1'b0; |
| mult3_op_a = op_a_i[31:16]; |
| mult3_op_b = op_b_i[15:0]; |
| summand1 = {18'h00000, mult1_res_uns[31:16]}; |
| summand2 = $unsigned(mult2_res); |
| summand3 = $unsigned(mult3_res); |
| mac_res_d = {2'b00, mac_res[15:0], mult1_res_uns[15:0]}; |
| mult_valid = mult_en_i; |
| mult_state_d = 1'd0; |
| mult_hold = 1'b0; |
| case (mult_state_q) |
| 1'd0: |
| if (operator_i != 2'd0) begin |
| mac_res_d = mac_res; |
| mult_valid = 1'b0; |
| mult_state_d = 1'd1; |
| end |
| else |
| mult_hold = ~multdiv_ready_id_i; |
| 1'd1: begin |
| mult3_sign_a = sign_a; |
| mult3_sign_b = sign_b; |
| mult3_op_a = op_a_i[31:16]; |
| mult3_op_b = op_b_i[31:16]; |
| mac_res_d = mac_res; |
| summand1 = 1'sb0; |
| summand2 = accum; |
| summand3 = $unsigned(mult3_res); |
| mult_state_d = 1'd0; |
| mult_valid = 1'b1; |
| mult_hold = ~multdiv_ready_id_i; |
| end |
| default: mult_state_d = 1'd0; |
| endcase |
| end |
| always @(posedge clk_i or negedge rst_ni) |
| if (!rst_ni) |
| mult_state_q <= 1'd0; |
| else if (mult_en_internal) |
| mult_state_q <= mult_state_d; |
| assign unused_mult1_res_uns = mult1_res_uns[33:32]; |
| end |
| else begin : gen_mult_fast |
| reg [15:0] mult_op_a; |
| reg [15:0] mult_op_b; |
| reg [1:0] mult_state_q; |
| reg [1:0] mult_state_d; |
| assign mac_res_signed = ($signed({sign_a, mult_op_a}) * $signed({sign_b, mult_op_b})) + $signed(accum); |
| assign mac_res_ext = $unsigned(mac_res_signed); |
| assign mac_res = mac_res_ext[33:0]; |
| always @(*) begin |
| mult_op_a = op_a_i[15:0]; |
| mult_op_b = op_b_i[15:0]; |
| sign_a = 1'b0; |
| sign_b = 1'b0; |
| accum = imd_val_q_i[34+:34]; |
| mac_res_d = mac_res; |
| mult_state_d = mult_state_q; |
| mult_valid = 1'b0; |
| mult_hold = 1'b0; |
| case (mult_state_q) |
| 2'd0: begin |
| mult_op_a = op_a_i[15:0]; |
| mult_op_b = op_b_i[15:0]; |
| sign_a = 1'b0; |
| sign_b = 1'b0; |
| accum = 1'sb0; |
| mac_res_d = mac_res; |
| mult_state_d = 2'd1; |
| end |
| 2'd1: begin |
| mult_op_a = op_a_i[15:0]; |
| mult_op_b = op_b_i[31:16]; |
| sign_a = 1'b0; |
| sign_b = signed_mode_i[1] & op_b_i[31]; |
| accum = {18'b000000000000000000, imd_val_q_i[65-:16]}; |
| if (operator_i == 2'd0) |
| mac_res_d = {2'b00, mac_res[15:0], imd_val_q_i[49-:16]}; |
| else |
| mac_res_d = mac_res; |
| mult_state_d = 2'd2; |
| end |
| 2'd2: begin |
| mult_op_a = op_a_i[31:16]; |
| mult_op_b = op_b_i[15:0]; |
| sign_a = signed_mode_i[0] & op_a_i[31]; |
| sign_b = 1'b0; |
| if (operator_i == 2'd0) begin |
| accum = {18'b000000000000000000, imd_val_q_i[65-:16]}; |
| mac_res_d = {2'b00, mac_res[15:0], imd_val_q_i[49-:16]}; |
| mult_valid = 1'b1; |
| mult_state_d = 2'd0; |
| mult_hold = ~multdiv_ready_id_i; |
| end |
| else begin |
| accum = imd_val_q_i[34+:34]; |
| mac_res_d = mac_res; |
| mult_state_d = 2'd3; |
| end |
| end |
| 2'd3: begin |
| mult_op_a = op_a_i[31:16]; |
| mult_op_b = op_b_i[31:16]; |
| sign_a = signed_mode_i[0] & op_a_i[31]; |
| sign_b = signed_mode_i[1] & op_b_i[31]; |
| accum[17:0] = imd_val_q_i[67-:18]; |
| accum[33:18] = {16 {signed_mult & imd_val_q_i[67]}}; |
| mac_res_d = mac_res; |
| mult_valid = 1'b1; |
| mult_state_d = 2'd0; |
| mult_hold = ~multdiv_ready_id_i; |
| end |
| default: mult_state_d = 2'd0; |
| endcase |
| end |
| always @(posedge clk_i or negedge rst_ni) |
| if (!rst_ni) |
| mult_state_q <= 2'd0; |
| else if (mult_en_internal) |
| mult_state_q <= mult_state_d; |
| end |
| endgenerate |
| assign res_adder_h = alu_adder_ext_i[32:1]; |
| wire [1:0] unused_alu_adder_ext; |
| assign unused_alu_adder_ext = {alu_adder_ext_i[33], alu_adder_ext_i[0]}; |
| assign next_remainder = (is_greater_equal ? res_adder_h[31:0] : imd_val_q_i[65-:32]); |
| assign next_quotient = (is_greater_equal ? {1'b0, op_quotient_q} | {1'b0, one_shift} : {1'b0, op_quotient_q}); |
| assign one_shift = 32'b00000000000000000000000000000001 << div_counter_q; |
| always @(*) |
| if ((imd_val_q_i[65] ^ op_denominator_q[31]) == 1'b0) |
| is_greater_equal = res_adder_h[31] == 1'b0; |
| else |
| is_greater_equal = imd_val_q_i[65]; |
| assign div_sign_a = op_a_i[31] & signed_mode_i[0]; |
| assign div_sign_b = op_b_i[31] & signed_mode_i[1]; |
| assign div_change_sign = (div_sign_a ^ div_sign_b) & ~div_by_zero_q; |
| assign rem_change_sign = div_sign_a; |
| always @(*) begin |
| div_counter_d = div_counter_q - 5'h01; |
| op_remainder_d = imd_val_q_i[34+:34]; |
| op_quotient_d = op_quotient_q; |
| md_state_d = md_state_q; |
| op_numerator_d = op_numerator_q; |
| op_denominator_d = op_denominator_q; |
| alu_operand_a_o = 33'b000000000000000000000000000000001; |
| alu_operand_b_o = {~op_b_i, 1'b1}; |
| div_valid = 1'b0; |
| div_hold = 1'b0; |
| div_by_zero_d = div_by_zero_q; |
| case (md_state_q) |
| 3'd0: begin |
| if (operator_i == 2'd2) begin |
| op_remainder_d = 1'sb1; |
| md_state_d = (!data_ind_timing_i && equal_to_zero_i ? 3'd6 : 3'd1); |
| div_by_zero_d = equal_to_zero_i; |
| end |
| else begin |
| op_remainder_d = {2'b00, op_a_i}; |
| md_state_d = (!data_ind_timing_i && equal_to_zero_i ? 3'd6 : 3'd1); |
| end |
| alu_operand_a_o = 33'b000000000000000000000000000000001; |
| alu_operand_b_o = {~op_b_i, 1'b1}; |
| div_counter_d = 5'd31; |
| end |
| 3'd1: begin |
| op_quotient_d = 1'sb0; |
| op_numerator_d = (div_sign_a ? alu_adder_i : op_a_i); |
| md_state_d = 3'd2; |
| div_counter_d = 5'd31; |
| alu_operand_a_o = 33'b000000000000000000000000000000001; |
| alu_operand_b_o = {~op_a_i, 1'b1}; |
| end |
| 3'd2: begin |
| op_remainder_d = {33'h000000000, op_numerator_q[31]}; |
| op_denominator_d = (div_sign_b ? alu_adder_i : op_b_i); |
| md_state_d = 3'd3; |
| div_counter_d = 5'd31; |
| alu_operand_a_o = 33'b000000000000000000000000000000001; |
| alu_operand_b_o = {~op_b_i, 1'b1}; |
| end |
| 3'd3: begin |
| op_remainder_d = {1'b0, next_remainder[31:0], op_numerator_q[div_counter_d]}; |
| op_quotient_d = next_quotient[31:0]; |
| md_state_d = (div_counter_q == 5'd1 ? 3'd4 : 3'd3); |
| alu_operand_a_o = {imd_val_q_i[65-:32], 1'b1}; |
| alu_operand_b_o = {~op_denominator_q[31:0], 1'b1}; |
| end |
| 3'd4: begin |
| if (operator_i == 2'd2) |
| op_remainder_d = {1'b0, next_quotient}; |
| else |
| op_remainder_d = {2'b00, next_remainder[31:0]}; |
| alu_operand_a_o = {imd_val_q_i[65-:32], 1'b1}; |
| alu_operand_b_o = {~op_denominator_q[31:0], 1'b1}; |
| md_state_d = 3'd5; |
| end |
| 3'd5: begin |
| md_state_d = 3'd6; |
| if (operator_i == 2'd2) |
| op_remainder_d = (div_change_sign ? {2'h0, alu_adder_i} : imd_val_q_i[34+:34]); |
| else |
| op_remainder_d = (rem_change_sign ? {2'h0, alu_adder_i} : imd_val_q_i[34+:34]); |
| alu_operand_a_o = 33'b000000000000000000000000000000001; |
| alu_operand_b_o = {~imd_val_q_i[65-:32], 1'b1}; |
| end |
| 3'd6: begin |
| md_state_d = 3'd0; |
| div_hold = ~multdiv_ready_id_i; |
| div_valid = 1'b1; |
| end |
| default: md_state_d = 3'd0; |
| endcase |
| end |
| assign valid_o = mult_valid | div_valid; |
| endmodule |