axi_pkg.sv

Go to the documentation of this file.

//
// Copyright (C) 2017, Matt Dew @ Dew Technologies, LLC
//
// This program is free software (logic verification): you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public License (LGPL)
// as published by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
// for more details.
//
// License: LGPL, v3, as defined and found on www.gnu.org,
//      http://www.gnu.org/licenses/lgpl.html
//
//
// Author's intent:  If you use this AXI verification code and find or fix bugs
//                   or make improvements, then share those fixes or improvements.
//                   If you use this in a bigger project, I don't care about,
//                   or want, any changes or code outside this block.
//                   Example: If you use this in an SoC simulation/testbench
//                            I don't want, or care about, your SoC or other blocks.
//                            I just care about the enhancements to these AXI files.
//                   That's why I have choosen the LGPL instead of the GPL.

// Ugh, we now have a dependency on uvm in the RTL.
// @Todo: check if abstract class can be a simple class and not a component or object

#include "uvm_macros.svh"




parameter C_AXI_ID_WIDTH = params_pkg::AXI_ID_WIDTH;   
parameter C_AXI_DATA_WIDTH = params_pkg::AXI_DATA_WIDTH; 
parameter C_AXI_ADDR_WIDTH = params_pkg::AXI_ADDR_WIDTH; 
parameter C_AXI_LEN_WIDTH = params_pkg::AXI_LEN_WIDTH; 
typedef enum {e_1BYTE    = 0b000, 
                          e_2BYTES   = 0b001, 
                          e_4BYTES   = 0b010, 
                          e_8BYTES   = 0b011, 
                          e_16BYTES  = 0b100, 
                          e_32BYTES  = 0b101, 
                          e_64BYTES  = 0b110, 
                          e_128BYTES = 0b111 
                         } burst_size_t;

typedef enum {e_FIXED    = 0b00, 
                          e_INCR     = 0b01, 
                          e_WRAP     = 0b10, 
                          e_RESERVED = 0b11
                         } burst_type_t;

typedef enum {e_OKAY    = 0b00, 
                          e_EXOKAY  = 0b01, 
                          e_SLVERR  = 0b10, 
                          e_DECERR  = 0b11  
                         } response_type_t;





typedef struct {
  logic <C_AXI_ID_WIDTH-1:0>     awid;  
  logic <C_AXI_ADDR_WIDTH-1:0>    awaddr; 
  logic                          awvalid; 
  logic                          awready; 
  logic <C_AXI_LEN_WIDTH-1:0>     awlen;   
  logic <2:0>                     awsize;  
  logic <1:0>                     awburst; 
  logic <0:0>                     awlock; 
  logic <3:0>                     awcache; 
  logic <2:0>                     awprot; 
  logic <3:0>                     awqos; 
} axi_seq_item_aw_vector_s;

localparam int AXI_SEQ_ITEM_AW_NUM_BITS = $bits(axi_seq_item_aw_vector_s); 
typedef bit <AXI_SEQ_ITEM_AW_NUM_BITS-1:0>  axi_seq_item_aw_vector_t;



typedef struct {
  logic <C_AXI_DATA_WIDTH-1:0>    wdata; 
  logic <C_AXI_DATA_WIDTH/8-1:0>  wstrb;  
  logic                          wlast;
  logic                          wvalid;
  logic <C_AXI_ID_WIDTH-1:0>      wid;
} axi_seq_item_w_vector_s;

localparam int AXI_SEQ_ITEM_W_NUM_BITS = $bits(axi_seq_item_w_vector_s);  
typedef bit <AXI_SEQ_ITEM_W_NUM_BITS-1:0>  axi_seq_item_w_vector_t;


typedef struct {
  logic <C_AXI_ID_WIDTH-1:0>      bid; 
  logic <1:0>                     bresp; 
} axi_seq_item_b_vector_s;

localparam int AXI_SEQ_ITEM_B_NUM_BITS = $bits(axi_seq_item_b_vector_s); 
typedef bit <AXI_SEQ_ITEM_B_NUM_BITS-1:0>  axi_seq_item_b_vector_t;

typedef struct {
  logic <C_AXI_ID_WIDTH-1:0>     arid; 
  logic <C_AXI_ADDR_WIDTH-1:0>    araddr; 
  logic                          arvalid;
  logic                          arready;
  logic <C_AXI_LEN_WIDTH-1:0>     arlen;
  logic <2:0>   arsize;
  logic <1:0>   arburst;
  logic <0:0>                     arlock; 
  logic <3:0>                     arcache;
  logic <2:0>                     arprot;
  logic <3:0>                     arqos;
} axi_seq_item_ar_vector_s;

localparam int AXI_SEQ_ITEM_AR_NUM_BITS = $bits(axi_seq_item_ar_vector_s);    
typedef bit <AXI_SEQ_ITEM_AR_NUM_BITS-1:0>  axi_seq_item_ar_vector_t;


typedef struct {
  logic <C_AXI_DATA_WIDTH-1:0>    rdata; 
  logic <1:0>                     rresp; 
  logic                          rlast; 
  logic                          rvalid; 
  logic <C_AXI_ID_WIDTH-1:0>      rid; 
} axi_seq_item_r_vector_s;

localparam int AXI_SEQ_ITEM_R_NUM_BITS = $bits(axi_seq_item_r_vector_s);     
typedef bit <AXI_SEQ_ITEM_R_NUM_BITS-1:0>  axi_seq_item_r_vector_t;

 bit <C_AXI_ADDR_WIDTH-1:0>  calculate_burst_aligned_address(
  input bit <C_AXI_ADDR_WIDTH-1:0>  address,
  input bit <2:0>                   burst_size) {


  bit <C_AXI_ADDR_WIDTH-1:0>  aligned_address;

  // This can be done in a nice function, but this case
  // is immediatly understandable.
  aligned_address = address;
  case  (burst_size) { 
    e_1BYTE    : aligned_address      = address;
    e_2BYTES   : aligned_address[0]   = 0b0;
    e_4BYTES   : aligned_address[2] = 0b00;
    e_8BYTES   : aligned_address[3] = 0b000;
    e_16BYTES  : aligned_address[4] = 0b0000;
    e_32BYTES  : aligned_address[5] = 0b0_0000;
    e_64BYTES  : aligned_address[6] = 0b00_0000;
    e_128BYTES : aligned_address[7] = 0b000_0000;
  }

  uvm_info("axi_pkg::calculatate-aligned_adress",
            $sformatf("address: 0x%0x burst_size:%0d alignedaddress: 0x%0x",
                      address, burst_size, aligned_address),
            UVM_HIGH)

  return aligned_address;

}


 bit <C_AXI_ADDR_WIDTH-1:0>  calculate_bus_aligned_address(
  input bit <C_AXI_ADDR_WIDTH-1:0>  addr,
  input int                       bus_size) {

  bit <C_AXI_ADDR_WIDTH-1:0>  aligned_address;

  string msg_s;

  aligned_address = addr;

  case  (bus_size) { 
    2**e_1BYTE    : aligned_address      = addr;
    2**e_2BYTES   : aligned_address[0]   = 0b0;
    2**e_4BYTES   : aligned_address[2] = 0b00;
    2**e_8BYTES   : aligned_address[3] = 0b000;
    2**e_16BYTES  : aligned_address[4] = 0b0000;
    2**e_32BYTES  : aligned_address[5] = 0b0_0000;
    2**e_64BYTES  : aligned_address[6] = 0b00_0000;
    2**e_128BYTES : aligned_address[7] = 0b000_0000;
  }


  msg_s="";
  $sformat(msg_s, "%s addr: 0x%0x", msg_s, addr);
  $sformat(msg_s, "%s aligned_address: 0x%0x", msg_s, aligned_address);
  $sformat(msg_s, "%s bus_size: 0x%0x", msg_s, bus_size);



  uvm_info("calculate_bus_aligned_address", msg_s,UVM_HIGH)

  return aligned_address;

}


 bit <C_AXI_LEN_WIDTH-1:0>  calculate_axlen(
  input bit <C_AXI_ADDR_WIDTH-1:0>  addr,
  input bit <2:0>                   burst_size,
  input shortint                   burst_length) {


  byte unalignment_offset;
  shortint total_length;
  shortint shifter;
  shortint ishifter;
  bit <C_AXI_LEN_WIDTH-1:0>  beats;

  string msg_s;

  unalignment_offset = calculate_unalignment_offset(
                            .addr(addr),
                            .burst_size(burst_size));

  total_length=burst_length + unalignment_offset;

  shifter = shortint(total_length/(2**burst_size));

  ishifter = shifter*(2**burst_size);

  if (ishifter != total_length) {
    shifter += 1;
  }

  beats = shifter - 1;


  msg_s="";
  $sformat(msg_s, "%s addr: 0x%0x",     msg_s, addr);
  $sformat(msg_s, "%s burst_size: %0d", msg_s, burst_size);
  $sformat(msg_s, "%s unalignment_offset: %0d", msg_s, unalignment_offset);
  $sformat(msg_s, "%s burst_length: %0d", msg_s, burst_length);
  $sformat(msg_s, "%s total_length: %0d", msg_s, total_length);
  $sformat(msg_s, "%s shifter: %0d", msg_s, shifter);
  $sformat(msg_s, "%s ishifter: %0d", msg_s, ishifter);

  uvm_info("axi_pkg::calculate_beats",
            msg_s,
            UVM_HIGH)

  return beats;

}

 byte calculate_unalignment_offset(
  input bit <C_AXI_ADDR_WIDTH-1:0>  addr,
  input byte                  burst_size) {

  byte unalignment_offset;

    case  (burst_size) { 
      e_1BYTE    : unalignment_offset = 0;
      e_2BYTES   : unalignment_offset = byte(addr[0]);
      e_4BYTES   : unalignment_offset = byte(addr[2]);
      e_8BYTES   : unalignment_offset = byte(addr[3]);
      e_16BYTES  : unalignment_offset = byte(addr[4]);
      e_32BYTES  : unalignment_offset = byte(addr[5]);
      e_64BYTES  : unalignment_offset = byte(addr[6]);
      e_128BYTES : unalignment_offset = byte(addr[7]);
  }

  return unalignment_offset;


}


 void calculate_wrap_boundary(
  input bit <C_AXI_ADDR_WIDTH-1:0>  addr,
  input bit <2:0>                   burst_size,
  input shortint                   burst_length,
  output bit <C_AXI_ADDR_WIDTH-1:0>  Lower_Wrap_Boundary,
  output bit <C_AXI_ADDR_WIDTH-1:0>  Upper_Wrap_Boundary) {


  int max_beat_cnt;
  int dtsize;
  bit <C_AXI_ADDR_WIDTH-1:0>  Aligned_Address;

  max_beat_cnt = calculate_axlen(.addr         (addr),
                                 .burst_size   (burst_size),
                                 .burst_length (burst_length)) + 1;

  Aligned_Address=calculate_burst_aligned_address(.address(addr),
                                            .burst_size(burst_size));


  dtsize = (2**burst_size) * max_beat_cnt;

  Lower_Wrap_Boundary = (int(Aligned_Address/dtsize) * dtsize);
  Upper_Wrap_Boundary = Lower_Wrap_Boundary + dtsize;

}


 bit <C_AXI_ADDR_WIDTH-1:0>  get_next_address(
  input bit <C_AXI_ADDR_WIDTH-1:0>  addr,
  input bit <2:0>                   burst_size,
  input shortint                   burst_length,
  input bit <1:0>                   burst_type,
  input int beat_cnt,
  input int lane,
  input int data_bus_bytes) {

  bit <C_AXI_ADDR_WIDTH-1:0>  tmp_addr;

  int Lower_Byte_Lane;
  int Upper_Byte_Lane;
  int data_offset;
  int Lower_Wrap_Boundary;
  int Upper_Wrap_Boundary;
  string s;
  string msg_s;


  calculate_wrap_boundary(.addr                (addr),
                          .burst_size          (burst_size),
                          .burst_length        (burst_length),
                          .Lower_Wrap_Boundary (Lower_Wrap_Boundary),
                          .Upper_Wrap_Boundary (Upper_Wrap_Boundary));

  get_beat_N_byte_lanes(.addr         (addr),
                        .burst_size   (burst_size),
                        .burst_length (burst_length),
                        .burst_type   (burst_type),
                        .beat_cnt     (beat_cnt),
                        .data_bus_bytes(data_bus_bytes),
                        .Lower_Byte_Lane(Lower_Byte_Lane),
                        .Upper_Byte_Lane(Upper_Byte_Lane),
                        .offset(data_offset));

  if (burst_type == e_FIXED) {
    tmp_addr=addr+(lane - Lower_Byte_Lane);
  } else if (burst_type == e_INCR) {
    tmp_addr=addr+data_offset+(lane - Lower_Byte_Lane);

  } else if (burst_type == e_WRAP) {

        tmp_addr=addr+data_offset+(lane - Lower_Byte_Lane);

    if (tmp_addr >= Upper_Wrap_Boundary) {
      tmp_addr = Lower_Wrap_Boundary+(tmp_addr-Upper_Wrap_Boundary);
    }
// \todo:do we have to worry about double-wrap?
  } else {
    uvm_error("AXI_PKG::get_next_address", $sformatf("Unknown burst_type: %0d", burst_type))
  }

  msg_s="";

  $sformat(msg_s, "%s beat_cnt:%0d",              msg_s, beat_cnt);
 // $sformat(msg_s, "%s max_beat_cnt:%0d",          msg_s, max_beat_cnt);
  $sformat(msg_s, "%s lane:%0d",                  msg_s, lane);
  $sformat(msg_s, "%s Lower_Byte_Lane:%0d",       msg_s, Lower_Byte_Lane);
  $sformat(msg_s, "%s Upper_Byte_Lane:%0d",       msg_s, Upper_Byte_Lane);
  $sformat(msg_s, "%s Lower_Wrap_Boundary:%0d(0x%0x)", msg_s, Lower_Wrap_Boundary, Lower_Wrap_Boundary);
  $sformat(msg_s, "%s Upper_Wrap_Boundary:%0d(0x%0x)", msg_s, Upper_Wrap_Boundary, Upper_Wrap_Boundary);
  $sformat(msg_s, "%s number_bytes:%0d",          msg_s, (2**burst_size));
  $sformat(msg_s, "%s data_offset:%0d",           msg_s, data_offset);
  $sformat(msg_s, "%s tmp_addr:%0d(0x%0x)",       msg_s, tmp_addr, tmp_addr);

  uvm_info("axi_seq_item::get_next_address", msg_s, UVM_HIGH)

  return tmp_addr;

}




 void get_beat_N_byte_lanes(
  input bit <C_AXI_ADDR_WIDTH-1:0>  addr,
  input bit <2:0>  burst_size,
  input shortint  burst_length,
  input bit <1:0>                   burst_type,
  input  int beat_cnt,
  input  int data_bus_bytes,
  output int Lower_Byte_Lane,
  output int Upper_Byte_Lane,
  output int offset) {



   bit <63:0>  Aligned_Start_Address;
  bit <63:0>  Address_N;
  bit <63:0>  Bus_Aligned_Address;
  bit <63:0>  Bus_Aligned_Address_N;

  string s;
  string msg_s;

  int a;
  int b;

  Aligned_Start_Address=calculate_burst_aligned_address(.address(addr),
                                                  .burst_size(burst_size));
  Address_N = Aligned_Start_Address+(beat_cnt*(2**burst_size));



  // **********************
 // a = int'(addr/data_bus_bytes) * data_bus_bytes;
  Bus_Aligned_Address = calculate_bus_aligned_address(.addr(addr),
                                                  .bus_size(data_bus_bytes));
  Bus_Aligned_Address_N = calculate_bus_aligned_address(.addr(Address_N),
                                                  .bus_size(data_bus_bytes));


    // Adjust Lower_Byte_lane up if unaligned.
      if (burst_type == e_FIXED) {
      //  if (beat_cnt==0) begin
           Lower_Byte_Lane = addr - Bus_Aligned_Address;
           Upper_Byte_Lane = Aligned_Start_Address + (2**burst_size) - 1 -
                             Bus_Aligned_Address;

           offset = beat_cnt*(2**burst_size);


      }  else {

        if (beat_cnt==0) {
           Lower_Byte_Lane = addr - Bus_Aligned_Address;
           Upper_Byte_Lane = Aligned_Start_Address + (2**burst_size) - 1 -
                             Bus_Aligned_Address;

           offset = 0;

        } else {
           Lower_Byte_Lane = Address_N - Bus_Aligned_Address_N;
           Upper_Byte_Lane = Lower_Byte_Lane + (2**burst_size) - 1;

           offset = Address_N - addr;
        }
      }

      msg_s="";
      $sformat(msg_s, "%s beat_cnt:%0d",        msg_s, beat_cnt);
      $sformat(msg_s, "%s data_bus_bytes:%0d",  msg_s, data_bus_bytes);
      $sformat(msg_s, "%s NumberBytes (2**burst_size):%0d",  msg_s, (2**burst_size));

      $sformat(msg_s, "%s addr:%0d",            msg_s, addr);
      $sformat(msg_s, "%s Aligned_Start_Address:%0d",  msg_s, Aligned_Start_Address);
      $sformat(msg_s, "%s Address_N:%0d",  msg_s, Address_N);
      $sformat(msg_s, "%s Lower_Byte_Lane:%0d", msg_s, Lower_Byte_Lane);
      $sformat(msg_s, "%s Upper_Byte_Lane:%0d", msg_s, Upper_Byte_Lane);
      $sformat(msg_s, "%s offset:%0d",          msg_s, offset);

  uvm_info("axi_seq_item::get_beat_N_byte_lanes", msg_s, UVM_HIGH)


}




#include "axi_if_abstract.svh"