Subversion Repositories qaz_libs

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

////                                                              ////

//// Copyright (C) 2015 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 axi4_models_pkg;

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

  //

  virtual class axi4_channel_if_class #(A, N, I);

    virtual axi4_if  #(A, N, I) axi4_bus;

    event valid;

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

    //

    pure virtual function void set_master_default;

    pure virtual function void set_slave_default;

    pure virtual function void copy(axi4_channel_if_class #(A, N, I) from);

    pure virtual function void copy_if;

    pure virtual function void drive_if;

    pure virtual function void set_ready(bit value);

    pure virtual function bit is_valid;

    pure virtual function void set_valid(bit value);

    pure virtual function bit is_ready;

    pure virtual function bit is_transfer;

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

    function new(virtual axi4_if  #(A, N, I) axi4_bus);

      this.axi4_bus = axi4_bus;

    endfunction: new

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

  //

  endclass: axi4_channel_if_class

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

  //

  class axi4_channel_sink_q_class  #(A, N, I, type T = logic);

    virtual axi4_if #(A, N, I) axi4_bus;

    T c_if_h;

    int q_size;

    mailbox #(T) q;

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

    //

    function automatic void run_q;

      int result;

      c_if_h.set_ready(1'b1);

      fork

        forever

          @(axi4_bus.cb_s)

          begin

            if(c_if_h.is_transfer)

            begin

              result = q.try_put(c_if_h);

              if(result == 0)

                $error;

              c_if_h.copy_if();

              c_if_h = new(axi4_bus);

            end

            if(q.num >= q_size)

              c_if_h.set_ready(1'b0);

            else

              c_if_h.set_ready(1'b1);

          end

      join_none

    endfunction: run_q

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

    function new( virtual axi4_if #(A, N, I) axi4_bus, int q_size);

      this.axi4_bus = axi4_bus;

      this.q_size   = q_size;

      this.q        = new(q_size);

      this.c_if_h   = new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_channel_sink_q_class

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

  //

  class axi4_channel_source_q_class  #(A, N, I, type T = logic);

    virtual axi4_if #(A, N, I) axi4_bus;

    T c_if_h;

    int q_size;

    mailbox #(T) q;

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

    //

    function automatic void run_q;

      int result;

      c_if_h.set_valid(1'b0);

      fork

        forever

          @(axi4_bus.cb_s)

          begin

            if(c_if_h.is_transfer)

            begin

              result = q.try_get(c_if_h);

              if(result == 0)

                $stop;

            end

            result = q.try_peek(c_if_h);

            if(result == 0)

              c_if_h.set_valid(1'b0);

            else

            begin

              c_if_h.set_valid(1'b1);

              c_if_h.drive_if();

            end

          end

      join_none

    endfunction: run_q

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

    function new(virtual axi4_if #(A, N, I) axi4_bus, int q_size);

      this.axi4_bus = axi4_bus;

      this.q_size   = q_size;

      this.q        = new(q_size);

      this.c_if_h   = new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_channel_source_q_class

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

  //

  class axi4_aw_if_class #(A, N, I)

    extends axi4_channel_if_class #(A, N, I);

    logic [(A-1):0]    awaddr;

    logic [1:0]        awburst;

    logic [(I-1):0]    awid;

    logic [7:0]        awlen;

    logic [2:0]        awsize;

    logic [3:0]        awcache;

    logic              awlock;

    logic [2:0]        awprot;

    logic [3:0]        awqos;

    logic [3:0]        awregion;

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

    //

    function void set_master_default;

      axi4_bus.cb_m.awvalid <= 0;

    endfunction: set_master_default

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

    //

    function void set_slave_default;

      axi4_bus.cb_s.awready <= 0;

    endfunction: set_slave_default

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

    //

    function void copy(axi4_channel_if_class #(A, N, I) from);

      axi4_aw_if_class #(A, N, I) child;

      $cast(child, from);

      awaddr    = child.awaddr;

      awburst   = child.awburst;

      awid      = child.awid;

      awlen     = child.awlen;

      awsize    = child.awsize;

      awcache   = child.awcache;

      awlock    = child.awlock;

      awprot    = child.awprot;

      awqos     = child.awqos;

      awregion  = child.awregion;

    endfunction: copy

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

    //

    function void copy_if;

      awaddr    = axi4_bus.cb_s.awaddr;

      awburst   = axi4_bus.cb_s.awburst;

      awid      = axi4_bus.cb_s.awid;

      awlen     = axi4_bus.cb_s.awlen;

      awsize    = axi4_bus.cb_s.awsize;

      awcache   = axi4_bus.cb_s.awcache;

      awlock    = axi4_bus.cb_s.awlock;

      awprot    = axi4_bus.cb_s.awprot;

      awqos     = axi4_bus.cb_s.awqos;

      awregion  = axi4_bus.cb_s.awregion;

    endfunction: copy_if

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

    //

    function void drive_if;

      axi4_bus.cb_m.awaddr    <= awaddr;

      axi4_bus.cb_m.awburst   <= awburst;

      axi4_bus.cb_m.awid      <= awid;

      axi4_bus.cb_m.awlen     <= awlen;

      axi4_bus.cb_m.awsize    <= awsize;

      axi4_bus.cb_m.awcache   <= awcache;

      axi4_bus.cb_m.awlock    <= awlock;

      axi4_bus.cb_m.awprot    <= awprot;

      axi4_bus.cb_m.awqos     <= awqos;

      axi4_bus.cb_m.awregion  <= awregion;

    endfunction: drive_if

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

    //

    function void set_ready(bit value);

      axi4_bus.cb_s.awready <= value;

    endfunction: set_ready

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

    //

    function bit is_valid;

      return(axi4_bus.cb_s.awvalid);

    endfunction: is_valid

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

    //

    function void set_valid(bit value);

      axi4_bus.cb_m.awvalid <= value;

    endfunction: set_valid

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

    //

    function bit is_ready;

      return(axi4_bus.cb_m.awready);

    endfunction: is_ready

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

    //

    function bit is_transfer;

      return(axi4_bus.cb_m.awready & axi4_bus.cb_s.awvalid);

    endfunction: is_transfer

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

    function new(virtual axi4_if  #(A, N, I) axi4_bus);

      super.new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_aw_if_class

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

  //

  class axi4_ar_if_class #(A, N, I)

    extends axi4_channel_if_class #(A, N, I);

    logic [(A-1):0]    araddr;

    logic [1:0]        arburst;

    logic [(I-1):0]    arid;

    logic [7:0]        arlen;

    logic [2:0]        arsize;

    logic [3:0]        arcache;

    logic              arlock;

    logic [2:0]        arprot;

    logic [3:0]        arqos;

    logic [3:0]        arregion;

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

    //

    virtual function void set_master_default;

      axi4_bus.cb_m.arvalid <= 0;

    endfunction: set_master_default

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

    //

    virtual function void set_slave_default;

      axi4_bus.cb_s.arready <= 0;

    endfunction: set_slave_default

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

    //

    virtual function void copy(axi4_channel_if_class #(A, N, I) from);

      axi4_ar_if_class #(A, N, I) child;

      $cast(child, from);

      araddr    = child.araddr;

      arburst   = child.arburst;

      arid      = child.arid;

      arlen     = child.arlen;

      arsize    = child.arsize;

      arcache   = child.arcache;

      arlock    = child.arlock;

      arprot    = child.arprot;

      arqos     = child.arqos;

      arregion  = child.arregion;

    endfunction: copy

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

    //

    virtual function void copy_if;

      araddr    = axi4_bus.cb_s.araddr;

      arburst   = axi4_bus.cb_s.arburst;

      arid      = axi4_bus.cb_s.arid;

      arlen     = axi4_bus.cb_s.arlen;

      arsize    = axi4_bus.cb_s.arsize;

      arcache   = axi4_bus.cb_s.arcache;

      arlock    = axi4_bus.cb_s.arlock;

      arprot    = axi4_bus.cb_s.arprot;

      arqos     = axi4_bus.cb_s.arqos;

      arregion  = axi4_bus.cb_s.arregion;

    endfunction: copy_if

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

    //

    virtual function void drive_if;

      axi4_bus.cb_m.araddr    <= araddr;

      axi4_bus.cb_m.arburst   <= arburst;

      axi4_bus.cb_m.arid      <= arid;

      axi4_bus.cb_m.arlen     <= arlen;

      axi4_bus.cb_m.arsize    <= arsize;

      axi4_bus.cb_m.arcache   <= arcache;

      axi4_bus.cb_m.arlock    <= arlock;

      axi4_bus.cb_m.arprot    <= arprot;

      axi4_bus.cb_m.arqos     <= arqos;

      axi4_bus.cb_m.arregion  <= arregion;

    endfunction: drive_if

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

    //

    virtual function void set_ready(bit value);

      axi4_bus.cb_s.arready <= value;

    endfunction: set_ready

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

    //

    virtual function bit is_valid;

      return(axi4_bus.cb_s.arvalid);

    endfunction: is_valid

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

    //

    function void set_valid(bit value);

      axi4_bus.cb_m.arvalid <= value;

    endfunction: set_valid

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

    //

    function bit is_ready;

      return(axi4_bus.cb_m.arready);

    endfunction: is_ready

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

    //

    function bit is_transfer;

      return(axi4_bus.cb_m.arready & axi4_bus.cb_s.arvalid);

    endfunction: is_transfer

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

    function new(virtual axi4_if  #(A, N, I) axi4_bus);

      super.new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_ar_if_class

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

  //

  class axi4_w_if_class #(A, N, I)

    extends axi4_channel_if_class #(A, N, I);

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

    logic [(I-1):0]    wid;

    logic              wlast;

    logic [N-1:0]      wstrb;

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

    //

    function void set_master_default;

      axi4_bus.cb_m.wvalid <= 0;

    endfunction: set_master_default

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

    //

    function void set_slave_default;

      axi4_bus.cb_s.wready <= 0;

    endfunction: set_slave_default

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

    //

    function void copy(axi4_channel_if_class #(A, N, I) from);

      axi4_w_if_class #(A, N, I) child;

      $cast(child, from);

      wdata = child.wdata;

      wid   = child.wid;

      wlast = child.wlast;

      wstrb = child.wstrb;

    endfunction: copy

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

    //

    function void copy_if;

      wdata = axi4_bus.cb_s.wdata;

      wid   = axi4_bus.cb_s.wid;

      wlast = axi4_bus.cb_s.wlast;

      wstrb = axi4_bus.cb_s.wstrb;

    endfunction: copy_if

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

    //

    function void drive_if;

      axi4_bus.cb_m.wdata <= wdata;

      axi4_bus.cb_m.wid   <= wid;

      axi4_bus.cb_m.wlast <= wlast;

      axi4_bus.cb_m.wstrb <= wstrb;

    endfunction: drive_if

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

    //

    function void set_ready(bit value);

        axi4_bus.cb_s.wready <= value;

    endfunction: set_ready

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

    //

    function bit is_valid;

      return(axi4_bus.cb_s.wvalid);

    endfunction: is_valid

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

    //

    function void set_valid(bit value);

      axi4_bus.cb_m.wvalid <= value;

    endfunction: set_valid

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

    //

    function bit is_ready;

      return(axi4_bus.cb_m.wready);

    endfunction: is_ready

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

    //

    function bit is_transfer;

      return(axi4_bus.cb_m.wready & axi4_bus.cb_s.wvalid);

    endfunction: is_transfer

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

    function new(virtual axi4_if  #(A, N, I) axi4_bus);

      super.new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_w_if_class

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

  //

  class axi4_b_if_class #(A, N, I)

    extends axi4_channel_if_class #(A, N, I);

    logic [(I-1):0] bid;

    logic [1:0]     bresp;

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

    //

    function void set_master_default;

      axi4_bus.cb_m.bready <= 0;

    endfunction: set_master_default

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

    //

    function void set_slave_default;

      axi4_bus.cb_s.bvalid <= 0;

    endfunction: set_slave_default

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

    //

    function void copy(axi4_channel_if_class #(A, N, I) from);

      axi4_b_if_class #(A, N, I) child;

      $cast(child, from);

      bid   = child.bid;

      bresp = child.bresp;

    endfunction: copy

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

    //

    function void copy_if;

      bid   = axi4_bus.cb_m.bid;

      bresp = axi4_bus.cb_m.bresp;

    endfunction: copy_if

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

    //

    function void drive_if;

      axi4_bus.cb_s.bid   <= bid;

      axi4_bus.cb_s.bresp <= bresp;

    endfunction: drive_if

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

    //

    function void set_ready(bit value);

      axi4_bus.cb_m.bready <= value;

    endfunction: set_ready

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

    //

    function bit is_valid;

      return(axi4_bus.cb_m.bvalid);

    endfunction: is_valid

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

    //

    function void set_valid(bit value);

      axi4_bus.cb_s.bvalid <= value;

    endfunction: set_valid

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

    //

    function bit is_ready;

      return(axi4_bus.cb_s.bready);

    endfunction: is_ready

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

    //

    function bit is_transfer;

      return(axi4_bus.cb_s.bready & axi4_bus.cb_m.bvalid);

    endfunction: is_transfer

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

    function new(virtual axi4_if  #(A, N, I) axi4_bus);

      super.new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_b_if_class

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

  //

  class axi4_r_if_class #(A, N, I)

    extends axi4_channel_if_class #(A, N, I);

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

    logic [(I-1):0]   rid;

    logic             rlast;

    logic [1:0]       rresp;

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

    //

    function void set_master_default;

      axi4_bus.cb_m.rready <= 0;

    endfunction: set_master_default

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

    //

    function void set_slave_default;

      axi4_bus.cb_s.rvalid <= 0;

    endfunction: set_slave_default

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

    //

    function void copy(axi4_channel_if_class #(A, N, I) from);

      axi4_r_if_class #(A, N, I) child;

      $cast(child, from);

      rdata = child.rdata;

      rid   = child.rid;

      rlast = child.rlast;

      rresp = child.rresp;

    endfunction: copy

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

    //

    function void copy_if;

      rdata = axi4_bus.cb_m.rdata;

      rid   = axi4_bus.cb_m.rid;

      rlast = axi4_bus.cb_m.rlast;

      rresp = axi4_bus.cb_m.rresp;

    endfunction: copy_if

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

    //

    function void drive_if;

      axi4_bus.cb_s.rdata <= rdata;

      axi4_bus.cb_s.rid   <= rid;

      axi4_bus.cb_s.rlast <= rlast;

      axi4_bus.cb_s.rresp <= rresp;

    endfunction: drive_if

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

    //

    function void set_ready(bit value);

      axi4_bus.cb_m.rready <= value;

    endfunction: set_ready

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

    //

    function bit is_valid;

      return(axi4_bus.cb_m.rvalid);

    endfunction: is_valid

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

    //

    function void set_valid(bit value);

      axi4_bus.cb_s.rvalid <= value;

    endfunction: set_valid

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

    //

    function bit is_ready;

      return(axi4_bus.cb_s.rready);

    endfunction: is_ready

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

    //

    function bit is_transfer;

      return(axi4_bus.cb_s.rready & axi4_bus.cb_m.rvalid);

    endfunction: is_transfer

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

    function new(virtual axi4_if  #(A, N, I) axi4_bus);

      super.new(axi4_bus);

    endfunction: new

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

  //

  endclass: axi4_r_if_class

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

  //

  virtual class axi4_master_model_class #(A, N, I);

    virtual axi4_if #(A, N, I) axi4_m;

    axi4_aw_if_class #(A, N, I) aw_if_h;

    axi4_channel_source_q_class #(A, N, I, axi4_aw_if_class #(A, N, I)) aw_q_h;

    axi4_w_if_class #(A, N, I) w_if_h;

    axi4_channel_source_q_class #(A, N, I, axi4_w_if_class #(A, N, I)) w_q_h;

    axi4_b_if_class #(A, N, I) b_if_h;

    axi4_channel_sink_q_class #(A, N, I, axi4_b_if_class #(A, N, I)) b_q_h;

    axi4_ar_if_class #(A, N, I) ar_if_h;

    axi4_channel_source_q_class #(A, N, I, axi4_ar_if_class #(A, N, I)) ar_q_h;

    axi4_r_if_class #(A, N, I) r_if_h;

    axi4_channel_sink_q_class #(A, N, I, axi4_r_if_class #(A, N, I)) r_q_h;

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

    //

    pure virtual task run_model;

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

    function new(virtual axi4_if  #(A, N, I) axi4_m);

      this.axi4_m = axi4_m;

      this.aw_if_h = new(axi4_m);

      aw_if_h.set_master_default();

      this.w_if_h = new(axi4_m);

      w_if_h.set_master_default();

      this.b_if_h = new(axi4_m);

      b_if_h.set_master_default();

      this.ar_if_h = new(axi4_m);

      ar_if_h.set_master_default();

      this.r_if_h = new(axi4_m);

      r_if_h.set_master_default();

      fork

        run_model();

      join_none

    endfunction: new

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

  //

  endclass: axi4_master_model_class

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

  //

  virtual class axi4_slave_model_class #(A, N, I);

    virtual axi4_if #(A, N, I) axi4_s;

    axi4_aw_if_class #(A, N, I) aw_if_h;

    axi4_channel_sink_q_class #(A, N, I, axi4_aw_if_class #(A, N, I)) aw_q_h;

    axi4_w_if_class #(A, N, I) w_if_h;

    axi4_channel_sink_q_class #(A, N, I, axi4_w_if_class #(A, N, I)) w_q_h;

    axi4_b_if_class #(A, N, I) b_if_h;

    axi4_channel_source_q_class #(A, N, I, axi4_b_if_class #(A, N, I)) b_q_h;

    axi4_ar_if_class #(A, N, I) ar_if_h;

    axi4_channel_sink_q_class #(A, N, I, axi4_ar_if_class #(A, N, I)) ar_q_h;

    axi4_r_if_class #(A, N, I) r_if_h;

    axi4_channel_source_q_class #(A, N, I, axi4_r_if_class #(A, N, I)) r_q_h;

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

    //

    pure virtual task run_model;

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

    function new(virtual axi4_if  #(A, N, I) axi4_s);

      this.axi4_s = axi4_s;

      this.aw_if_h = new(axi4_s);

      aw_if_h.set_slave_default();

      this.w_if_h = new(axi4_s);

      w_if_h.set_slave_default();

      this.b_if_h = new(axi4_s);

      b_if_h.set_slave_default();

      this.ar_if_h = new(axi4_s);

      ar_if_h.set_slave_default();

      this.r_if_h = new(axi4_s);

      r_if_h.set_slave_default();

      fork

        run_model();

      join_none

    endfunction: new

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

  //

  endclass: axi4_slave_model_class

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

//

endpackage: axi4_models_pkg