/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

module VTAMemDPI #
  ( parameter LEN_BITS = 8,
    parameter ADDR_BITS = 64,
    parameter DATA_BITS = 64,
    parameter STRB_BITS = DATA_BITS/8
  )
  (
    input                        clock,
    input                        reset,
    input                        dpi_req_ar_valid,
    input [LEN_BITS-1:0]         dpi_req_ar_len,
    input [7:0]                  dpi_req_ar_id,
    input [ADDR_BITS-1:0]        dpi_req_ar_addr,
    input                        dpi_req_aw_valid,
    input [LEN_BITS-1:0]         dpi_req_aw_len,
    input [ADDR_BITS-1:0]        dpi_req_aw_addr,
    input                        dpi_wr_valid,
    input [DATA_BITS-1:0]        dpi_wr_bits_data,
    input [STRB_BITS-1:0]        dpi_wr_bits_strb,
    output logic                 dpi_rd_valid,
    output logic [7:0]           dpi_rd_bits_id,
    output logic [DATA_BITS-1:0] dpi_rd_bits_data,
    input                        dpi_rd_ready
  );

  import "DPI-C" function void VTAMemDPI
    (
      input byte     unsigned rd_req_valid,
      input byte     unsigned rd_req_len,
      input byte     unsigned rd_req_id,
      input longint  unsigned rd_req_addr,
      input byte     unsigned wr_req_valid,
      input byte     unsigned wr_req_len,
      input longint  unsigned wr_req_addr,
      input byte     unsigned wr_valid,
      input longint  unsigned wr_value[],
      input longint  unsigned wr_strb,
      output byte    unsigned rd_valid,
      output byte    unsigned rd_id,
      output longint unsigned rd_value[],
      input byte     unsigned rd_ready
    );
  parameter blockNb = DATA_BITS/64;

  generate
    if (blockNb*64 != DATA_BITS) begin
      $error("-F- 64 bit data blocks expected.");
    end
  endgenerate
  generate
    if (STRB_BITS > 64) begin
      $error("-F- Strb bits should not exceed 64. Fix strb transfer");
    end
  endgenerate

  typedef logic         dpi1_t;
  typedef logic [7:0]         dpi8_t;
  typedef logic [31:0]       dpi32_t;
  typedef logic [63:0]       dpi64_t;
  typedef longint        dpi_data_t [blockNb-1:0];

  dpi1_t  __reset;
  dpi8_t  __rd_req_valid;
  dpi8_t  __rd_req_len;
  dpi8_t  __rd_req_id;
  dpi64_t __rd_req_addr;
  dpi8_t  __wr_req_valid;
  dpi8_t  __wr_req_len;
  dpi64_t __wr_req_addr;
  dpi8_t  __wr_valid;
  dpi_data_t __wr_value;
  dpi64_t __wr_strb;
  dpi8_t  __rd_valid;
  dpi_data_t __rd_value;
  dpi8_t  __rd_id;
  dpi8_t  __rd_ready;

  always_ff @(posedge clock) begin
    __reset <= reset;
  end

  // delaying outputs by one-cycle
  // since verilator does not support delays
  integer i;
  always_ff @(posedge clock) begin
    dpi_rd_valid <= dpi1_t ' (__rd_valid);
    for (i = 0; i < blockNb; i = i +1) begin
      dpi_rd_bits_data[64 * i +: 64]  <= __rd_value[i];
    end
    dpi_rd_bits_id    <= __rd_id;
  end

  assign __rd_req_valid  = dpi8_t ' (dpi_req_ar_valid);
  assign __rd_req_len    = dpi8_t ' (dpi_req_ar_len);
  assign __rd_req_id     = dpi_req_ar_id;
  assign __rd_req_addr   = dpi64_t ' (dpi_req_ar_addr);
  assign __wr_req_valid  = dpi8_t ' (dpi_req_aw_valid);
  assign __wr_req_len    = dpi8_t ' (dpi_req_aw_len);
  assign __wr_req_addr   = dpi64_t ' (dpi_req_aw_addr);

  generate
    if (STRB_BITS != 64) begin
      localparam [63 - STRB_BITS:0] strbfill = 0;
      assign __wr_strb    = {strbfill, dpi_wr_bits_strb};
    end
    else begin
      assign __wr_strb    = dpi_wr_bits_strb;
    end
  endgenerate
  assign __wr_valid   = dpi8_t ' (dpi_wr_valid);
  genvar j;
  generate
  for (j = 0; j < blockNb; j = j +1) begin
    assign __wr_value[j] = dpi_wr_bits_data[64 * j +: 64];
  end
  endgenerate
  assign __rd_ready   = dpi8_t ' (dpi_rd_ready);

  // evaluate DPI function
  always_ff @(posedge clock) begin
    if(reset) begin
      dpi_rd_valid <= 0;
      dpi_rd_bits_data <= 0;
      dpi_rd_bits_id <= 0;
    end
    else begin
      VTAMemDPI(
        __rd_req_valid,
        __rd_req_len,
        __rd_req_id,           
        __rd_req_addr,
        __wr_req_valid,
        __wr_req_len,
        __wr_req_addr,
        __wr_valid,
        __wr_value,
        __wr_strb,
        __rd_valid,
        __rd_id,
        __rd_value,
        __rd_ready);
      dpi_rd_valid <= dpi1_t ' (__rd_valid);
      for (i = 0; i < blockNb; i = i +1) begin
        dpi_rd_bits_data[64 * i +: 64] <= __rd_value[i];
      end
      dpi_rd_bits_id <= __rd_id;
    end // else: !if(reset | __reset)
  end // always_ff @

endmodule