Subversion Repositories qaz_libs

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

////                                                              ////

//// Copyright (C) 2019 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

  avf_line_buffer #(N, U, L, AW)

  (

    axis_if axis_in,

    axis_if axis_out,

    input   aclk,

    input   aresetn

  );

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

  localparam W = (N*8) + U + 1; // tdata + tuser + tlast

  localparam F = 2; // fanout for the buffer row output

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

  axis_if #(.N(N), .U(U)) row_out[L][F](.*);

  axis_if #(.N(N), .U(U)) buffer_out[L-1](.*);

  wire [L-2:0] zero_pad;

  wire [L-2:0] initialized;

  wire all_initialized = &initialized;

  wire enable;

  wire eof_trailing = row_out[0][0].tready & row_out[0][0].tvalid & row_out[0][0].tuser[2];

  wire eof_leading = row_out[L-1][0].tready & row_out[L-1][0].tvalid & row_out[L-1][0].tuser[2];

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

  generate

    for(genvar j = 0; j < L-1; j++)

    begin: buffer_gen

      avf_line_buffer_row #(N, W, AW, j)

        row_i

        (

          .axis_in(row_out[j+1][1]),

          .axis_out(buffer_out[j]),

          .zero_pad(zero_pad[j]),

          .initialized(initialized[j]),

          .*

        );

    end

  endgenerate

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

  generate

    for(genvar j = 1; j < L-1; j++)

    begin: middle_fanout_gen

      axis_fanout #(F)

        fanout_i(.axis_in(buffer_out[j]), .axis_out(row_out[j]), .*);

    end

  endgenerate

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

  axis_fanout #(F) trailing_row_i(.axis_out(row_out[L-1]), .*);

  axis_alias leading_row_i(buffer_out[0], row_out[0][0]);

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

  enum reg [3:0]

    {

      INITIALIZE = 4'b0001,

      ACTIVE = 4'b0010,

      // READY       = 4'b0100,

      FLUSH       = 4'b1000

    } state, next_state;

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

  always_ff @(posedge aclk)

    if(~aresetn)

      state <= INITIALIZE;

    else

      state <= next_state;

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

  always_comb

    case(state)

      INITIALIZE: if(all_initialized)

                    next_state = ACTIVE;

                  else

                    next_state = INITIALIZE;

      ACTIVE:     if(eof_leading)

                    next_state = FLUSH;

                  else

                    next_state = ACTIVE;

      FLUSH:      if(eof_trailing)

                    next_state = INITIALIZE;

                  else

                    next_state = FLUSH;

      default:      next_state = INITIALIZE;

    endcase

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

  assign enable = (state == ACTIVE);

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

  wire init = ((state == INITIALIZE) & (next_state == INITIALIZE));

  wire flush = ((state == FLUSH) & (next_state == FLUSH));

  axis_if #(.N(N), .U(U)) merge_in[L](.*);

  generate

    for(genvar j = 0; j < L; j++)

    begin: merge_gen

      axis_alias row_i(row_out[j][0], merge_in[j]);

    end

  endgenerate

  avf_line_buffer_merge #(N, U, L) merge_i(.*);

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

endmodule