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 axis_bfm_pkg;


  // --------------------------------------------------------------------
  //
  import q_pkg::*;
  import bfm_pkg::*;


  // --------------------------------------------------------------------
  //
  class axis_tr_class #(N, I, D, U)
    extends transaction_class #(axis_tr_class #(N, I, D, U));

    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 void copy(TR_T from);
    // delay_class        delay_h;
      this.tdata  = from.tdata;
      this.tstrb  = from.tstrb;
      this.tkeep  = from.tkeep;
      this.tlast  = from.tlast;
      this.tid    = from.tid;
      this.tdest  = from.tdest;
      this.tuser  = from.tuser;
    endfunction: copy


  // --------------------------------------------------------------------
  //
  endclass: axis_tr_class


  // --------------------------------------------------------------------
  //
  class axis_tx_bfm_class  #(N, I, D, U)
    extends blocking_transmission_q_class #(axis_tr_class #(.N(N), .I(I), .D(D), .U(U)));

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


    //--------------------------------------------------------------------
    //
    function void set_default;
      axis_out.cb_m.tvalid  <= 0;
      axis_out.cb_m.tdata   <= 'bx;
      axis_out.cb_m.tstrb   <= 'bx;
      axis_out.cb_m.tkeep   <= 'bx;
      axis_out.cb_m.tlast   <= 'bx;
      axis_out.cb_m.tid     <= 'bx;
      axis_out.cb_m.tdest   <= 'bx;
      axis_out.cb_m.tuser   <= 'bx;
    endfunction: set_default


    //--------------------------------------------------------------------
    //
    task tx_transaction(axis_tr_class #(.N(N), .I(I), .D(D), .U(U)) tr_h);
      axis_out.zero_cycle_delay();
      repeat(tr_h.delay_h.delay) @(axis_out.cb_m);

      axis_out.cb_m.tvalid  <= 1;
      axis_out.cb_m.tdata   <= tr_h.tdata;
      axis_out.cb_m.tstrb   <= 0;
      axis_out.cb_m.tkeep   <= 0;
      axis_out.cb_m.tlast   <= tr_h.tlast;
      axis_out.cb_m.tid     <= 0;
      axis_out.cb_m.tdest   <= 0;
      axis_out.cb_m.tuser   <= tr_h.tuser;

      @(axis_out.cb_m);
      wait(axis_out.cb_m.tready);
      // @(axis_out.cb_m iff axis_out.cb_m.tready);

      set_default();
    endtask: tx_transaction


    // --------------------------------------------------------------------
    //
    event tx_done;

    task automatic transmit(ref Q_T tr_h);
      tx_transaction(tr_h);
      ->tx_done;
    endtask: transmit


    //--------------------------------------------------------------------
    //
    task init;
      set_default();
    endtask: init


    //--------------------------------------------------------------------
    //
    function new(virtual axis_if #(.N(N), .I(I), .D(D), .U(U)) axis_out);
      this.axis_out = axis_out;
      tr_h = new();
      fork
        init();
      join_none
      $display("^^^ %16.t | %m", $time);
    endfunction: new

  // --------------------------------------------------------------------
  //
  endclass: axis_tx_bfm_class


  // --------------------------------------------------------------------
  //
  class axis_rx_bfm_class  #(N, I, D, U)
    extends blocking_receiver_q_class #(axis_tr_class #(.N(N), .I(I), .D(D), .U(U)));

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


    //--------------------------------------------------------------------
    //
    function void set_tready(bit value);
      axis_in.cb_s.tready  <= value;
    endfunction: set_tready


    //--------------------------------------------------------------------
    //
    task rx_transaction(axis_tr_class #(.N(N), .I(I), .D(D), .U(U)) tr_h);
      repeat(tr_h.delay_h.delay) @(axis_in.cb_s);
      axis_in.cb_s.tready <= 1;

      @(axis_in.cb_s);
      wait(axis_in.cb_s.tvalid);
      // @(axis_in.cb_s iff axis_in.cb_s.tvalid);

      tr_h.tdata  <= axis_in.cb_s.tdata;
      tr_h.tstrb  <= axis_in.cb_s.tstrb;
      tr_h.tkeep  <= axis_in.cb_s.tkeep;
      tr_h.tlast  <= axis_in.cb_s.tlast;
      tr_h.tid    <= axis_in.cb_s.tid;
      tr_h.tdest  <= axis_in.cb_s.tdest;
      tr_h.tuser  <= axis_in.cb_s.tuser;

      axis_in.cb_s.tready <= 0;
    endtask: rx_transaction


    // --------------------------------------------------------------------
    //
    event rx_frame_done;

    virtual task receive(ref Q_T tr_h);
      tr_h = new();
      void'(tr_h.delay_h.next());
      rx_transaction(tr_h);
      ->rx_frame_done;
    endtask: receive


    //--------------------------------------------------------------------
    //
    task init;
      set_tready(0);
    endtask: init


    //--------------------------------------------------------------------
    //
    function new (virtual axis_if #(.N(N), .I(I), .D(D), .U(U)) axis_in);
      this.axis_in = axis_in;
      fork
        init();
      join_none
      $display("^^^ %16.t | %m", $time);
    endfunction: new

  endclass: axis_rx_bfm_class


// --------------------------------------------------------------------
//
endpackage: axis_bfm_pkg