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                     ////

////                                                              ////

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

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

//

package axis_pkg;

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

  //

  import uvm_pkg::*;

  `include "uvm_macros.svh"

  import bfm_pkg::*;

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

  //

  typedef struct

  {

    int unsigned N; // data bus width in bytes

    int unsigned I; // TID width

    int unsigned D; // TDEST width

    int unsigned U; // TUSER width

    bit USE_TSTRB; // set to 1 to enable, 0 to disable

    bit USE_TKEEP; // set to 1 to enable, 0 to disable

    bit USE_ROUTING; // set to 1 to enable, 0 to disable

  } axis_config_t;

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

  //

  class axis_sequence_item #(axis_config_t cfg)

    extends uvm_sequence_item;

    `uvm_object_param_utils(axis_sequence_item #(cfg))

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

    //

    localparam N = cfg.N;

    localparam I = cfg.I;

    localparam D = cfg.D;

    localparam U = cfg.U;

    localparam USE_TSTRB = cfg.USE_TSTRB;

    localparam USE_TKEEP = cfg.USE_TKEEP;

    localparam USE_ROUTING = cfg.USE_ROUTING;

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

    //

    delay_class delay_h;

    rand logic [(8*N)-1:0]  tdata;

    rand logic [N-1:0]      tstrb;

    rand logic [N-1:0]      tkeep;

    rand logic              tlast;

    rand logic [I-1:0]      tid;

    rand logic [D-1:0]      tdest;

    rand logic [U-1:0]      tuser;

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

    //

    function new(string name = "");

      super.new(name);

      delay_h = new;

    endfunction : new

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

    //

    function bit do_compare(uvm_object rhs, uvm_comparer comparer);

      axis_sequence_item #(cfg) tested;

      bit same;

      if (rhs==null)

        `uvm_fatal(get_type_name(), "| %m | comparison to a null pointer");

      if (!$cast(tested,rhs))

        same = 0;

      else

        same  = super.do_compare(rhs, comparer)

              & (tested.tdata == tdata)

              & (USE_TSTRB ? (tested.tstrb == tstrb) : 1)

              & (USE_TKEEP ? (tested.tkeep == tkeep) : 1)

              & (tested.tlast == tlast)

              & (USE_ROUTING ? (tested.tid == tid) : 1)

              & (USE_ROUTING ? (tested.tdest == tdest) : 1)

              & (tested.tuser == tuser);

      return same;

    endfunction : do_compare

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

    //

    function void do_copy(uvm_object rhs);

      axis_sequence_item #(cfg) item;

      assert(rhs != null) else

        `uvm_fatal(get_type_name(), "| %m | copy null transaction");

      super.do_copy(rhs);

      assert($cast(item,rhs)) else

        `uvm_fatal(get_type_name(), "| %m | failed cast");

      tdata = item.tdata;

      tstrb = item.tstrb;

      tkeep = item.tkeep;

      tlast = item.tlast;

      tid   = item.tid;

      tdest = item.tdest;

      tuser = item.tuser;

    endfunction : do_copy

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

    //

    function string convert2string();

      string s0, s1;

      s0 = $sformatf("| tdata: %h\n" ,tdata);

      s1 = $sformatf("| tlast: %1h | tuser: %h" , tlast, tuser);

      return {s1, s0};

    endfunction : convert2string

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

  //

  endclass : axis_sequence_item

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

  //

  class axis_driver #(parameter axis_config_t cfg)

    extends uvm_driver #(axis_sequence_item #(cfg));

     `uvm_component_param_utils(axis_driver#(cfg))

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

    //

    localparam N = cfg.N;

    localparam I = cfg.I;

    localparam D = cfg.D;

    localparam U = cfg.U;

    localparam USE_TSTRB = cfg.USE_TSTRB;

    localparam USE_TKEEP = cfg.USE_TKEEP;

    localparam USE_ROUTING = cfg.USE_ROUTING;

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

    //

    virtual axis_if #(.N(N), .I(I), .D(D), .U(U)) axis_bus;

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

    //

    function void set_default;

      axis_bus.cb_m.tvalid  <= 0;

      axis_bus.cb_m.tdata   <= 'bx;

      axis_bus.cb_m.tstrb   <= 'bx;

      axis_bus.cb_m.tkeep   <= 'bx;

      axis_bus.cb_m.tlast   <= 'bx;

      axis_bus.cb_m.tid     <= 'bx;

      axis_bus.cb_m.tdest   <= 'bx;

      axis_bus.cb_m.tuser   <= 'bx;

    endfunction: set_default

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

    //

    virtual task run_phase(uvm_phase phase);

      axis_sequence_item #(cfg) item;

      super.run_phase(phase);

      set_default();

      wait(~axis_bus.aresetn);

      @(axis_bus.cb_m);

      forever

      begin

        // seq_item_port.try_next_item(item);

        seq_item_port.get_next_item(item);

        axis_bus.cb_m.tvalid  <= 1;

        axis_bus.cb_m.tdata   <= item.tdata;

        axis_bus.cb_m.tstrb   <= 0;

        axis_bus.cb_m.tkeep   <= 0;

        axis_bus.cb_m.tlast   <= item.tlast;

        axis_bus.cb_m.tid     <= 0;

        axis_bus.cb_m.tdest   <= 0;

        axis_bus.cb_m.tuser   <= item.tuser;

        @(axis_bus.cb_m);

        wait(axis_bus.cb_m.tready);

        // @(axis_bus.cb_m iff axis_bus.cb_m.tready);

        set_default();

        repeat(item.delay_h.next()) @(axis_bus.cb_m);

        seq_item_port.item_done();

      end

    endtask : run_phase

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

    //

    function new(string name, uvm_component parent);

      super.new(name, parent);

    endfunction

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

  //

  endclass : axis_driver

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

  //

  class axis_sequencer #(axis_config_t cfg)

    extends uvm_sequencer #(axis_sequence_item #(cfg));

    `uvm_component_param_utils(axis_sequencer #(cfg))

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

    //

    function new(string name, uvm_component parent);

      super.new(name, parent);

    endfunction

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

  //

  endclass : axis_sequencer

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

  //

  class axis_counting_sequence #(axis_config_t cfg)

    extends uvm_sequence #(axis_sequence_item #(cfg));

    `uvm_object_param_utils(axis_counting_sequence #(cfg))

    rand int length = 16;

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

    //

    virtual task body();

      axis_sequence_item #(cfg) item;

      for(int i = 0; i < length; i++)

      begin

        item = axis_sequence_item #(cfg)::type_id::create("axis_sequence_item");

        item.tdata = i;

        item.tlast = (i == length - 1);

        start_item (item);

        finish_item(item);

      end

    endtask

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

    //

    function new(string name = "axis_counting_sequence");

      super.new(name);

    endfunction

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

  //

  endclass : axis_counting_sequence

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

  //

  class axis_agent #(axis_config_t cfg)

    extends uvm_agent;

     `uvm_component_param_utils(axis_agent #(cfg))

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

    //

    localparam N = cfg.N;

    localparam I = cfg.I;

    localparam D = cfg.D;

    localparam U = cfg.U;

    localparam USE_TSTRB = cfg.USE_TSTRB;

    localparam USE_TKEEP = cfg.USE_TKEEP;

    localparam USE_ROUTING = cfg.USE_ROUTING;

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

    //

    virtual axis_if #(.N(N), .I(I), .D(D), .U(U)) axis_bus;

     axis_driver #(cfg) driver;

     // my_monitor    #(cfg) monitor;

     axis_sequencer #(cfg) sequencer;

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

    //

    virtual function void build_phase(uvm_phase phase);

      super.build_phase(phase);

      if(!uvm_config_db #(virtual axis_if #(.N(N), .I(I), .D(D), .U(U)))::get(this, "", "axis_bus", axis_bus))

         `uvm_fatal(get_name(), "Couldn't get virtual interface!")

      driver = axis_driver #(cfg)::type_id::create("driver", this);

      // monitor   = my_monitor  #(cfg)::type_id::create("monitor"  , this);

      sequencer = axis_sequencer #(cfg)::type_id::create("sequencer", this);

    endfunction

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

    //

    virtual function void connect_phase(uvm_phase phase);

      super.connect_phase(phase);

      driver.axis_bus = axis_bus;

      // monitor.vif = vif;

      driver.seq_item_port.connect(sequencer.seq_item_export);

    endfunction

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

    //

     function new(string name, uvm_component parent);

        super.new(name, parent);

     endfunction

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

  //

  endclass : axis_agent

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

//

endpackage: axis_pkg