Subversion Repositories qaz_libs

//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2017 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
  recursive_axis_catenate
  #(
    N, // data bus width in bytes
    I = 1, // TID width
    D = 1, // TDEST width
    U = 1, // TUSER width
    U_IS_EOP = -1,
    MN // number of inputs to mux
  )
  (
    axis_if axis_in[MN-1:0],
    axis_if axis_out,
    input   aclk,
    input   aresetn
  );
// --------------------------------------------------------------------
// synthesis translate_off
  initial begin
    assert(MN > 0) else $fatal;
  end
// synthesis translate_on
// --------------------------------------------------------------------

  // --------------------------------------------------------------------
  localparam MA = $clog2(MN);    // mux select width
  localparam MH = 2 ** (MA - 1); // half of ceil(number of inputs)
  localparam MR = MN - MH;       // upper remainder

  // --------------------------------------------------------------------
  generate
    if(MN == 1) begin : one
      axis_alias axis_alias_i(axis_in[0], axis_out);
    end
    else if(MN == 2) begin : two
      axis_catenate #(.N(N), .I(I), .D(D), .U(U), .U_IS_EOP(U_IS_EOP))
        axis_catenate_i(.*);
    end
    else begin: recurse
      axis_if #(.N(N), .I(I), .D(D), .U(U)) axis_catenate_out[1:0](.*);

      recursive_axis_catenate
        #( .N(N)
        ,  .I(I)
        ,  .D(D)
        ,  .U(U)
        ,  .U_IS_EOP(U_IS_EOP)
        ,  .MN(MH)
        )
        catenate_lo
        ( .axis_in(axis_in[MH-1:0]),
          .axis_out(axis_catenate_out[0]),
          .* );

      if(MR == 1) begin : one
        axis_alias axis_alias_i(axis_in[MH], axis_catenate_out[1]);
      end
      else if(MR == 2) begin : two
        axis_catenate #(.N(N), .I(I), .D(D), .U(U), .U_IS_EOP(U_IS_EOP))
          axis_catenate_i
          ( .axis_in(axis_in[MH+1:MH]),
            .axis_out(axis_catenate_out[1]),
            .* );
      end
      else begin : more
        recursive_axis_catenate
          #( .N(N)
          ,  .I(I)
          ,  .D(D)
          ,  .U(U)
          ,  .U_IS_EOP(U_IS_EOP)
          ,  .MN(MR)
          )
          catenate_hi
          ( .axis_in(axis_in[MN-1:MN-MR]),
            .axis_out(axis_catenate_out[1]),
            .* );
      end

      axis_catenate #(.N(N), .I(I), .D(D), .U(U), .U_IS_EOP(U_IS_EOP))
        axis_catenate_i(.axis_in(axis_catenate_out), .*);
    end
  endgenerate

// --------------------------------------------------------------------
endmodule