axi_if_abstract.svh

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.

class axi_if_abstract : public uvm_object { public: 
  uvm_object_utils(axi_if_abstract)

     new (string name="axi_if_abstract");

    virtual  int get_data_bus_width();

    virtual task wait_for_clks(int cnt=1);
    virtual task wait_for_not_in_reset();

    virtual task wait_for_awready_awvalid();
    virtual task wait_for_awvalid();
    virtual task wait_for_wready();
    virtual task wait_for_bvalid();

    virtual task wait_for_write_address  (output axi_seq_item_aw_vector_s s);
    virtual task wait_for_write_data     (output axi_seq_item_w_vector_s  s);
    virtual task wait_for_write_response (output axi_seq_item_b_vector_s  s);
    virtual task wait_for_read_address   (output axi_seq_item_ar_vector_s s);
    virtual task wait_for_read_data      (output axi_seq_item_r_vector_s  s);

    virtual  bit get_awready_awvalid();
    virtual  bit get_awready();
    virtual  bit get_wready_wvalid();
    virtual  bit get_wvalid();
    virtual  bit get_wready();
    virtual  bit get_bready_bvalid();
    virtual  bit get_bvalid();
    virtual  bit get_bready();
    virtual  bit get_arready_arvalid();
    virtual  bit get_arready();
    virtual  bit get_rready_rvalid();
    virtual  bit get_rvalid();
    virtual  bit get_rready();

    virtual task set_awvalid(bit state);
    virtual task set_awready(bit state);
    virtual task set_wvalid(bit state);
    virtual task set_wready(bit state);
    virtual task set_bvalid(bit state);
    virtual task set_bready(bit state);
    virtual task set_arvalid(bit state);
    virtual task set_rvalid(bit state);
    virtual task set_rready(bit state);


    virtual  void enable_awready_toggle_pattern(bit <31:0>  pattern);
    virtual  void disable_awready_toggle_pattern();
    virtual  void enable_wready_toggle_pattern( bit <31:0>  pattern);
    virtual  void disable_wready_toggle_pattern();
    virtual  void enable_bready_toggle_pattern( bit <31:0>  pattern);
    virtual  void disable_bready_toggle_pattern();
    virtual  void enable_arready_toggle_pattern(bit <31:0>  pattern);
    virtual  void disable_arready_toggle_pattern();
    virtual  void enable_rready_toggle_pattern( bit <31:0>  pattern);
    virtual  void disable_rready_toggle_pattern();

    virtual  void write_aw(axi_seq_item_aw_vector_s s, bit valid=0b1);
    virtual  void write_w (axi_seq_item_w_vector_s  s);
    virtual  void write_b (axi_seq_item_b_vector_s s,  bit valid=0b1);
    virtual  void read_aw (output axi_seq_item_aw_vector_s s);
    virtual  void read_w  (output axi_seq_item_w_vector_s  s);
    virtual  void read_b  (output axi_seq_item_b_vector_s  s);


    virtual  void write_ar(axi_seq_item_ar_vector_s s, bit valid=0b1);
    virtual  void write_r (axi_seq_item_r_vector_s  s);
    virtual  void read_ar (output axi_seq_item_ar_vector_s s);
    virtual  void read_r  (output axi_seq_item_r_vector_s  s);


};

 axi_if_abstract::new (string name="axi_if_abstract") {
  super.new(name);
}


 int axi_if_abstract::get_data_bus_width() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function get_data_bus_width() not defined.")
  return -1;
}


task axi_if_abstract::wait_for_clks(int cnt=1) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_clks() not defined.")
}

task axi_if_abstract::wait_for_not_in_reset() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_not_in_reset() not defined.")
}


task axi_if_abstract::wait_for_awready_awvalid() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_awready_awvalid() not defined.")
}


task axi_if_abstract::wait_for_awvalid() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_awvalid() not defined.")
}


task axi_if_abstract::wait_for_wready() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_wready() not defined.")
}


task axi_if_abstract::wait_for_bvalid() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_bvalid() not defined.")
}


task axi_if_abstract::wait_for_write_address(output axi_seq_item_aw_vector_s s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_write_address() not defined.")
}


task axi_if_abstract::wait_for_write_data(output axi_seq_item_w_vector_s s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_write_data() not defined.")
}


task axi_if_abstract::wait_for_write_response(output axi_seq_item_b_vector_s s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_write_response() not defined.")
}


task axi_if_abstract::wait_for_read_address(output axi_seq_item_ar_vector_s s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_read_address() not defined.")
}


task axi_if_abstract::wait_for_read_data(output axi_seq_item_r_vector_s s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual task wait_for_read_address() not defined.")
}


 bit axi_if_abstract::get_awready_awvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_awready_awvalid() not defined.")
  return 0;
}



 bit axi_if_abstract::get_awready() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_awready() not defined.")
  return 0;
}


 bit axi_if_abstract::get_wready_wvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_wready_wvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_wvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_wvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_wready() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_wready() not defined.")
  return 0;
}


 bit axi_if_abstract::get_bready_bvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_bready_bvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_bvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_bvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_bready() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_bready() not defined.")
  return 0;
}


 bit axi_if_abstract::get_arready_arvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_arready_arvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_arready() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_arready() not defined.")
  return 0;
}


 bit axi_if_abstract::get_rready_rvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_rready_rvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_rvalid() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_rvalid() not defined.")
  return 0;
}


 bit axi_if_abstract::get_rready() {
   uvm_error(this.get_type_name(),
              "WARNING. Virtual function get_rready() not defined.")
  return 0;
}


task axi_if_abstract::set_awvalid(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_awvalid() not defined.")
}


task axi_if_abstract::set_awready(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_awready() not defined.")
}


task axi_if_abstract::set_wvalid(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_wvalid() not defined.")
}


task axi_if_abstract::set_wready(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_wready() not defined.")
}


task axi_if_abstract::set_bvalid(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_bvalid() not defined.")
}


task axi_if_abstract::set_bready(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_bready() not defined.")
}


task axi_if_abstract::set_arvalid(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_arvalid() not defined.")
}


task axi_if_abstract::set_rvalid(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_rvalid() not defined.")
}


task axi_if_abstract::set_rready(bit state) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task set_rready() not defined.")
}


 void axi_if_abstract::enable_awready_toggle_pattern(bit <31:0>  pattern) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function enable_awready_toggle_pattern() not defined.")
}


 void axi_if_abstract::disable_awready_toggle_pattern() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task disable_awready_toggle_pattern() not defined.")
}


 void axi_if_abstract::enable_wready_toggle_pattern(bit <31:0>  pattern) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function enable_wready_toggle_pattern() not defined.")
}


 void axi_if_abstract::disable_wready_toggle_pattern() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task disable_wready_toggle_pattern() not defined.")
}


 void axi_if_abstract::enable_bready_toggle_pattern(bit <31:0>  pattern) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function enable_bready_toggle_pattern() not defined.")
}


 void axi_if_abstract::disable_bready_toggle_pattern() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task disable_bready_toggle_pattern() not defined.")
}


 void axi_if_abstract::enable_arready_toggle_pattern(bit <31:0>  pattern) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function enable_arready_toggle_pattern() not defined.")
}


 void axi_if_abstract::disable_arready_toggle_pattern() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task disable_arready_toggle_pattern() not defined.")
}


 void axi_if_abstract::enable_rready_toggle_pattern(bit <31:0>  pattern) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function enable_rready_toggle_pattern() not defined.")
}


 void axi_if_abstract::disable_rready_toggle_pattern() {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual task disable_rready_toggle_pattern() not defined.")
}


 void axi_if_abstract::write_aw(axi_seq_item_aw_vector_s s, bit valid=0b1) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function write_aw() not defined.")
}


 void axi_if_abstract::write_w(axi_seq_item_w_vector_s  s) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function write_w() not defined.")
}


 void axi_if_abstract::write_b(axi_seq_item_b_vector_s s, bit valid=0b1) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function write_b() not defined.")
}


 void axi_if_abstract::read_aw(output axi_seq_item_aw_vector_s s) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function read_aw() not defined.")
}


 void axi_if_abstract::read_w(output axi_seq_item_w_vector_s  s) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function read_w() not defined.")
}


 void axi_if_abstract::read_b(output axi_seq_item_b_vector_s  s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual function read_b() not defined.")
}


 void axi_if_abstract::write_ar(axi_seq_item_ar_vector_s s, bit valid=0b1) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function write_ar() not defined.")
}


 void axi_if_abstract::read_ar(output axi_seq_item_ar_vector_s s) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function read_ar() not defined.")
}


 void axi_if_abstract::write_r(axi_seq_item_r_vector_s  s) {
  uvm_error(this.get_type_name(),
             "WARNING. Virtual function write_r() not defined.")
}


 void axi_if_abstract::read_r(output axi_seq_item_r_vector_s  s) {
    uvm_error(this.get_type_name(),
             "WARNING. Virtual function read_r() not defined.")
}


      /*
      3. what does disabling toggle patterns do?
      */