// ***************************************************************************
// ***************************************************************************
// Copyright 2014 - 2018 (c) Analog Devices, Inc. All rights reserved.
//
// In this HDL repository, there are many different and unique modules, consisting
// of various HDL (Verilog or VHDL) components. The individual modules are
// developed independently, and may be accompanied by separate and unique license
// terms.
//
// The user should read each of these license terms, and understand the
// freedoms and responsabilities that he or she has by using this source/core.
//
// This core 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.
//
// Redistribution and use of source or resulting binaries, with or without modification
// of this file, are permitted under one of the following two license terms:
//
//   1. The GNU General Public License version 2 as published by the
//      Free Software Foundation, which can be found in the top level directory
//      of this repository (LICENSE_GPL2), and also online at:
//      <https://www.gnu.org/licenses/old-licenses/gpl-2.0.html>
//
// OR
//
//   2. An ADI specific BSD license, which can be found in the top level directory
//      of this repository (LICENSE_ADIBSD), and also on-line at:
//      https://github.com/analogdevicesinc/hdl/blob/master/LICENSE_ADIBSD
//      This will allow to generate bit files and not release the source code,
//      as long as it attaches to an ADI device.
//
// ***************************************************************************
// ***************************************************************************

`timescale 1ns/100ps

module axi_dmac_transfer #(
  parameter DMA_DATA_WIDTH_SRC = 64,
  parameter DMA_DATA_WIDTH_DEST = 64,
  parameter DMA_LENGTH_WIDTH = 24,
  parameter DMA_LENGTH_ALIGN = 3,
  parameter BYTES_PER_BEAT_WIDTH_DEST = $clog2(DMA_DATA_WIDTH_DEST/8),
  parameter BYTES_PER_BEAT_WIDTH_SRC = $clog2(DMA_DATA_WIDTH_SRC/8),
  parameter DMA_TYPE_DEST = 0,
  parameter DMA_TYPE_SRC = 2,
  parameter DMA_AXI_ADDR_WIDTH = 32,
  parameter DMA_2D_TRANSFER = 1,
  parameter ASYNC_CLK_REQ_SRC = 1,
  parameter ASYNC_CLK_SRC_DEST = 1,
  parameter ASYNC_CLK_DEST_REQ = 1,
  parameter AXI_SLICE_DEST = 0,
  parameter AXI_SLICE_SRC = 0,
  parameter MAX_BYTES_PER_BURST = 128,
  parameter BYTES_PER_BURST_WIDTH = 7,
  parameter FIFO_SIZE = 8,
  parameter ID_WIDTH = $clog2(FIFO_SIZE*2),
  parameter AXI_LENGTH_WIDTH_SRC = 8,
  parameter AXI_LENGTH_WIDTH_DEST = 8,
  parameter ENABLE_DIAGNOSTICS_IF = 0,
  parameter ALLOW_ASYM_MEM = 0,
  parameter CACHE_COHERENT_DEST = 0
) (
  input ctrl_clk,
  input ctrl_resetn,

  input ctrl_enable,
  input ctrl_pause,

  input req_valid,
  output req_ready,

  input [DMA_AXI_ADDR_WIDTH-1:BYTES_PER_BEAT_WIDTH_DEST] req_dest_address,
  input [DMA_AXI_ADDR_WIDTH-1:BYTES_PER_BEAT_WIDTH_SRC] req_src_address,
  input [DMA_LENGTH_WIDTH-1:0] req_x_length,
  input [DMA_LENGTH_WIDTH-1:0] req_y_length,
  input [DMA_LENGTH_WIDTH-1:0] req_dest_stride,
  input [DMA_LENGTH_WIDTH-1:0] req_src_stride,
  input req_sync_transfer_start,
  input req_last,

  output req_eot,
  output [BYTES_PER_BURST_WIDTH-1:0] req_measured_burst_length,
  output req_response_partial,
  output req_response_valid,
  input req_response_ready,

  // Master AXI interface
  input m_dest_axi_aclk,
  input m_dest_axi_aresetn,
  input m_src_axi_aclk,
  input m_src_axi_aresetn,

  // Write address
  output [DMA_AXI_ADDR_WIDTH-1:0] m_axi_awaddr,
  output [AXI_LENGTH_WIDTH_DEST-1:0] m_axi_awlen,
  output [2:0] m_axi_awsize,
  output [1:0] m_axi_awburst,
  output [2:0] m_axi_awprot,
  output [3:0] m_axi_awcache,
  output m_axi_awvalid,
  input m_axi_awready,

  // Write data
  output [DMA_DATA_WIDTH_DEST-1:0] m_axi_wdata,
  output [(DMA_DATA_WIDTH_DEST/8)-1:0] m_axi_wstrb,
  input m_axi_wready,
  output m_axi_wvalid,
  output m_axi_wlast,

  // Write response
  input m_axi_bvalid,
  input [1:0] m_axi_bresp,
  output m_axi_bready,

  // Read address
  input m_axi_arready,
  output m_axi_arvalid,
  output [DMA_AXI_ADDR_WIDTH-1:0] m_axi_araddr,
  output [AXI_LENGTH_WIDTH_SRC-1:0] m_axi_arlen,
  output [2:0] m_axi_arsize,
  output [1:0] m_axi_arburst,
  output [2:0] m_axi_arprot,
  output [3:0] m_axi_arcache,

  // Read data and response
  input [DMA_DATA_WIDTH_SRC-1:0] m_axi_rdata,
  input m_axi_rlast,
  output m_axi_rready,
  input m_axi_rvalid,
  input [1:0] m_axi_rresp,

  // Slave streaming AXI interface
  input s_axis_aclk,
  output s_axis_ready,
  input s_axis_valid,
  input [DMA_DATA_WIDTH_SRC-1:0] s_axis_data,
  input [0:0] s_axis_user,
  input s_axis_last,
  output s_axis_xfer_req,

  // Master streaming AXI interface
  input m_axis_aclk,
  input m_axis_ready,
  output m_axis_valid,
  output [DMA_DATA_WIDTH_DEST-1:0] m_axis_data,
  output m_axis_last,
  output m_axis_xfer_req,

  // Input FIFO interface
  input fifo_wr_clk,
  input fifo_wr_en,
  input [DMA_DATA_WIDTH_SRC-1:0] fifo_wr_din,
  output fifo_wr_overflow,
  input fifo_wr_sync,
  output fifo_wr_xfer_req,

  // Input FIFO interface
  input fifo_rd_clk,
  input fifo_rd_en,
  output fifo_rd_valid,
  output [DMA_DATA_WIDTH_DEST-1:0] fifo_rd_dout,
  output fifo_rd_underflow,
  output fifo_rd_xfer_req,

  output [ID_WIDTH-1:0] dbg_dest_request_id,
  output [ID_WIDTH-1:0] dbg_dest_address_id,
  output [ID_WIDTH-1:0] dbg_dest_data_id,
  output [ID_WIDTH-1:0] dbg_dest_response_id,
  output [ID_WIDTH-1:0] dbg_src_request_id,
  output [ID_WIDTH-1:0] dbg_src_address_id,
  output [ID_WIDTH-1:0] dbg_src_data_id,
  output [ID_WIDTH-1:0] dbg_src_response_id,
  output [11:0] dbg_status,

  // Diagnostics interface
  output [7:0] dest_diag_level_bursts
);

  wire dma_req_valid;
  wire dma_req_ready;
  wire [DMA_AXI_ADDR_WIDTH-1:BYTES_PER_BEAT_WIDTH_DEST] dma_req_dest_address;
  wire [DMA_AXI_ADDR_WIDTH-1:BYTES_PER_BEAT_WIDTH_SRC] dma_req_src_address;
  wire [DMA_LENGTH_WIDTH-1:0] dma_req_length;
  wire [BYTES_PER_BURST_WIDTH-1:0] dma_req_measured_burst_length;
  wire dma_req_eot;
  wire dma_response_valid;
  wire dma_response_ready;
  wire dma_response_partial;
  wire dma_req_sync_transfer_start;
  wire dma_req_last;

  wire req_clk = ctrl_clk;
  wire req_resetn;

  wire req_enable;

  wire dest_clk;
  wire dest_ext_resetn;
  wire dest_resetn;
  wire dest_enable;
  wire dest_enabled;

  wire src_clk;
  wire src_ext_resetn;
  wire src_resetn;
  wire src_enable;
  wire src_enabled;

  wire req_valid_gated;
  wire req_ready_gated;

  wire abort_req;

  axi_dmac_reset_manager #(
    .ASYNC_CLK_REQ_SRC (ASYNC_CLK_REQ_SRC),
    .ASYNC_CLK_SRC_DEST (ASYNC_CLK_SRC_DEST),
    .ASYNC_CLK_DEST_REQ (ASYNC_CLK_DEST_REQ)
  ) i_reset_manager (
    .clk (ctrl_clk),
    .resetn (ctrl_resetn),

    .ctrl_enable (ctrl_enable),
    .ctrl_pause (ctrl_pause),

    .req_resetn (req_resetn),
    .req_enable (req_enable),
    .req_enabled (req_enable),

    .dest_clk (dest_clk),
    .dest_ext_resetn (dest_ext_resetn),
    .dest_resetn (dest_resetn),
    .dest_enable (dest_enable),
    .dest_enabled (dest_enabled),

    .src_clk (src_clk),
    .src_ext_resetn (src_ext_resetn),
    .src_resetn (src_resetn),
    .src_enable (src_enable),
    .src_enabled (src_enabled),

    .dbg_status (dbg_status));

  /*
   * Things become a lot easier if we gate incoming requests in a central place
   * before they are propagated downstream. Otherwise we'd need to take special
   * care to not accidentally accept requests while the DMA is going through a
   * shutdown and reset phase.
   */
  assign req_valid_gated = req_enable & req_valid;
  assign req_ready = req_enable & req_ready_gated;

  generate if (DMA_2D_TRANSFER == 1) begin

  dmac_2d_transfer #(
    .DMA_AXI_ADDR_WIDTH(DMA_AXI_ADDR_WIDTH),
    .DMA_LENGTH_WIDTH (DMA_LENGTH_WIDTH),
    .BYTES_PER_BURST_WIDTH (BYTES_PER_BURST_WIDTH),
    .BYTES_PER_BEAT_WIDTH_DEST (BYTES_PER_BEAT_WIDTH_DEST),
    .BYTES_PER_BEAT_WIDTH_SRC (BYTES_PER_BEAT_WIDTH_SRC)
  ) i_2d_transfer (
    .req_aclk (req_clk),
    .req_aresetn (req_resetn),

    .req_eot (req_eot),
    .req_measured_burst_length (req_measured_burst_length),
    .req_response_partial (req_response_partial),
    .req_response_valid (req_response_valid),
    .req_response_ready (req_response_ready),

    .req_valid (req_valid_gated),
    .req_ready (req_ready_gated),
    .req_dest_address (req_dest_address),
    .req_src_address (req_src_address),
    .req_x_length (req_x_length),
    .req_y_length (req_y_length),
    .req_dest_stride (req_dest_stride),
    .req_src_stride (req_src_stride),
    .req_sync_transfer_start (req_sync_transfer_start),
    .req_last (req_last),

    .out_abort_req (abort_req),
    .out_req_valid (dma_req_valid),
    .out_req_ready (dma_req_ready),
    .out_req_dest_address (dma_req_dest_address),
    .out_req_src_address (dma_req_src_address),
    .out_req_length (dma_req_length),
    .out_req_sync_transfer_start (dma_req_sync_transfer_start),
    .out_req_last (dma_req_last),
    .out_eot (dma_req_eot),
    .out_measured_burst_length (dma_req_measured_burst_length),
    .out_response_partial (dma_response_partial),
    .out_response_valid (dma_response_valid),
    .out_response_ready (dma_response_ready));

  end else begin

  /* Request */
  assign dma_req_valid = req_valid_gated;
  assign req_ready_gated = dma_req_ready;

  assign dma_req_dest_address = req_dest_address;
  assign dma_req_src_address = req_src_address;
  assign dma_req_length = req_x_length;
  assign dma_req_sync_transfer_start = req_sync_transfer_start;
  assign dma_req_last = req_last;

  /* Response */
  assign req_eot = dma_req_eot;
  assign req_measured_burst_length = dma_req_measured_burst_length;
  assign req_response_partial = dma_response_partial;
  assign req_response_valid = dma_response_valid;
  assign dma_response_ready = req_response_ready;

  end endgenerate

  request_arb #(
    .DMA_DATA_WIDTH_SRC (DMA_DATA_WIDTH_SRC),
    .DMA_DATA_WIDTH_DEST (DMA_DATA_WIDTH_DEST),
    .DMA_LENGTH_WIDTH (DMA_LENGTH_WIDTH),
    .DMA_LENGTH_ALIGN (DMA_LENGTH_ALIGN),
    .BYTES_PER_BEAT_WIDTH_DEST (BYTES_PER_BEAT_WIDTH_DEST),
    .BYTES_PER_BEAT_WIDTH_SRC (BYTES_PER_BEAT_WIDTH_SRC),
    .DMA_TYPE_DEST (DMA_TYPE_DEST),
    .DMA_TYPE_SRC (DMA_TYPE_SRC),
    .DMA_AXI_ADDR_WIDTH (DMA_AXI_ADDR_WIDTH),
    .ASYNC_CLK_REQ_SRC (ASYNC_CLK_REQ_SRC),
    .ASYNC_CLK_SRC_DEST (ASYNC_CLK_SRC_DEST),
    .ASYNC_CLK_DEST_REQ (ASYNC_CLK_DEST_REQ),
    .AXI_SLICE_DEST (AXI_SLICE_DEST),
    .AXI_SLICE_SRC (AXI_SLICE_SRC),
    .MAX_BYTES_PER_BURST (MAX_BYTES_PER_BURST),
    .BYTES_PER_BURST_WIDTH (BYTES_PER_BURST_WIDTH),
    .FIFO_SIZE (FIFO_SIZE),
    .ID_WIDTH (ID_WIDTH),
    .AXI_LENGTH_WIDTH_DEST (AXI_LENGTH_WIDTH_DEST),
    .AXI_LENGTH_WIDTH_SRC (AXI_LENGTH_WIDTH_SRC),
    .ENABLE_DIAGNOSTICS_IF(ENABLE_DIAGNOSTICS_IF),
    .ALLOW_ASYM_MEM (ALLOW_ASYM_MEM),
    .CACHE_COHERENT_DEST(CACHE_COHERENT_DEST)
  ) i_request_arb (
    .req_clk (req_clk),
    .req_resetn (req_resetn),

    .req_valid (dma_req_valid),
    .req_ready (dma_req_ready),
    .req_dest_address (dma_req_dest_address),
    .req_src_address (dma_req_src_address),
    .req_length (dma_req_length),
    .req_xlast (dma_req_last),
    .req_sync_transfer_start (dma_req_sync_transfer_start),

    .eot (dma_req_eot),
    .measured_burst_length(dma_req_measured_burst_length),
    .response_partial (dma_response_partial),
    .response_valid (dma_response_valid),
    .response_ready (dma_response_ready),

    .abort_req (abort_req),

    .req_enable (req_enable),

    .dest_clk (dest_clk),
    .dest_ext_resetn (dest_ext_resetn),
    .dest_resetn (dest_resetn),
    .dest_enable (dest_enable),
    .dest_enabled (dest_enabled),

    .src_clk (src_clk),
    .src_ext_resetn (src_ext_resetn),
    .src_resetn (src_resetn),
    .src_enable (src_enable),
    .src_enabled (src_enabled),

    .m_dest_axi_aclk (m_dest_axi_aclk),
    .m_dest_axi_aresetn (m_dest_axi_aresetn),
    .m_src_axi_aclk (m_src_axi_aclk),
    .m_src_axi_aresetn (m_src_axi_aresetn),

    .m_axi_awvalid (m_axi_awvalid),
    .m_axi_awready (m_axi_awready),
    .m_axi_awaddr (m_axi_awaddr),
    .m_axi_awlen (m_axi_awlen),
    .m_axi_awsize (m_axi_awsize),
    .m_axi_awburst (m_axi_awburst),
    .m_axi_awprot (m_axi_awprot),
    .m_axi_awcache (m_axi_awcache),

    .m_axi_wvalid (m_axi_wvalid),
    .m_axi_wready (m_axi_wready),
    .m_axi_wdata (m_axi_wdata),
    .m_axi_wstrb (m_axi_wstrb),
    .m_axi_wlast (m_axi_wlast),

    .m_axi_bvalid (m_axi_bvalid),
    .m_axi_bready (m_axi_bready),
    .m_axi_bresp (m_axi_bresp),

    .m_axi_arvalid (m_axi_arvalid),
    .m_axi_arready (m_axi_arready),
    .m_axi_araddr (m_axi_araddr),
    .m_axi_arlen (m_axi_arlen),
    .m_axi_arsize (m_axi_arsize),
    .m_axi_arburst (m_axi_arburst),
    .m_axi_arprot (m_axi_arprot),
    .m_axi_arcache (m_axi_arcache),

    .m_axi_rready (m_axi_rready),
    .m_axi_rvalid (m_axi_rvalid),
    .m_axi_rdata (m_axi_rdata),
    .m_axi_rlast (m_axi_rlast),
    .m_axi_rresp (m_axi_rresp),

    .s_axis_aclk (s_axis_aclk),
    .s_axis_ready (s_axis_ready),
    .s_axis_valid (s_axis_valid),
    .s_axis_data (s_axis_data),
    .s_axis_user (s_axis_user),
    .s_axis_last (s_axis_last),
    .s_axis_xfer_req (s_axis_xfer_req),

    .m_axis_aclk (m_axis_aclk),
    .m_axis_ready (m_axis_ready),
    .m_axis_valid (m_axis_valid),
    .m_axis_data (m_axis_data),
    .m_axis_last (m_axis_last),
    .m_axis_xfer_req (m_axis_xfer_req),

    .fifo_wr_clk (fifo_wr_clk),
    .fifo_wr_en (fifo_wr_en),
    .fifo_wr_din (fifo_wr_din),
    .fifo_wr_overflow (fifo_wr_overflow),
    .fifo_wr_sync (fifo_wr_sync),
    .fifo_wr_xfer_req (fifo_wr_xfer_req),

    .fifo_rd_clk (fifo_rd_clk),
    .fifo_rd_en (fifo_rd_en),
    .fifo_rd_valid (fifo_rd_valid),
    .fifo_rd_dout (fifo_rd_dout),
    .fifo_rd_underflow (fifo_rd_underflow),
    .fifo_rd_xfer_req (fifo_rd_xfer_req),

    .dbg_dest_request_id (dbg_dest_request_id),
    .dbg_dest_address_id (dbg_dest_address_id),
    .dbg_dest_data_id (dbg_dest_data_id),
    .dbg_dest_response_id (dbg_dest_response_id),
    .dbg_src_request_id (dbg_src_request_id),
    .dbg_src_address_id (dbg_src_address_id),
    .dbg_src_data_id (dbg_src_data_id),
    .dbg_src_response_id (dbg_src_response_id),

    .dest_diag_level_bursts(dest_diag_level_bursts));

endmodule