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

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


  // --------------------------------------------------------------------
  //
  class riffa_transaction_class #(N);

    rand logic [31:0] len;
    rand logic [30:0] off;
    rand logic last;
    rand logic [(8*N)-1:0] data[];


    //--------------------------------------------------------------------
    //
    function int get_data_size(int len);
      int words = ((len * 4) % N == 0) ? ((len * 4) / N) : ((len * 4) / N) + 1;
      // $display("^^^ %16.t | N     = %d", $time, N);
      // $display("^^^ %16.t | len   = %d", $time, len);
      // $display("^^^ %16.t | mod   = %d", $time, (len * 4) % N);
      // $display("^^^ %16.t | words = %d", $time, words);
      return(words);
    endfunction: get_data_size


    //--------------------------------------------------------------------
    //
    function void constant(int len, int off, bit last, logic [(8*N)-1:0] value);
      this.data = new[get_data_size(len)];
      this.len = len;
      this.off = off;
      this.last = last;
      foreach(this.data[i])
        this.data[i] = value;
    endfunction: constant


    //--------------------------------------------------------------------
    //
    function void counting(int len, int off, bit last);
      this.data = new[get_data_size(len)];
      this.len = len;
      this.off = off;
      this.last = last;
      foreach(this.data[i])
        this.data[i] = i;
    endfunction: counting


    //--------------------------------------------------------------------
    //
    function void hex(string str, int off, bit last);
      string rev_str;
      string char;
      int w, c;
      this.len  = (str.len() % (2 * 4)) == 0
                ? (str.len() / (2 * 4))
                : (str.len() / (2 * 4)) + 1;
      this.data = new[get_data_size(this.len)];
      this.off = off;
      this.last = last;
      rev_str = {<<8{str}}; // reverse string
      for(w = 0; w < rev_str.len(); w += (N * 2))
        for(c = 0; c < (N * 2); c++)
        begin
          char = string'(rev_str.getc(w + c));
          if(char == "")
            this.data[w / (N * 2)][(c * 4) +: 4] = 0;
          else
            this.data[w / (N * 2)][(c * 4) +: 4] = char.atohex();
        end
    endfunction: hex


    //--------------------------------------------------------------------
    //
    function void random(int len, int off, bit last);
      this.data = new[get_data_size(len)];
      assert(this.randomize() with
      {
        this.len == len;  // why not working?
        this.off == off;
        this.last == last;
      });
      this.len = len;
      this.off = off;
      this.last = last;
    endfunction: random


    //--------------------------------------------------------------------
    //
    function void compare(riffa_transaction_class #(N) to, int max_mismatches = 8);
      int error_count = 0;
      $display("!!! %16.t | %m", $time);
      if(this.len != to.len)
        $display("!!! %16.t | ERROR! len mismatch", $time);

      if(this.off != to.off)
        $display("!!! %16.t | ERROR! off mismatch", $time);

      if(this.last != to.last)
        $display("!!! %16.t | ERROR! last mismatch", $time);

      foreach(this.data[i])
      begin
        if(error_count > max_mismatches)
          break;
        if(this.data[i] !== to.data[i])
        begin
          $display("!!! %16.t | ERROR! | 0x%x | this != to | 0x%x != 0x%x", $time, i, this.data[i], to.data[i]);
          error_count++;
        end
      end
    endfunction: compare


    // // --------------------------------------------------------------------
    // //
    // function void copy(ref riffa_transaction_class #(N) from);
      // this.len = from.len;
      // this.off = from.off;
      // this.last = from.last;
    // endfunction: copy


    // // --------------------------------------------------------------------
    // //
    // function riffa_transaction_class #(N) clone();
      // clone = new(0, 0, 0);
      // clone.copy(this);
    // endfunction: clone


    //--------------------------------------------------------------------
    function new(int len, int off, bit last);
      this.data = new[get_data_size(len)];
      this.len  = len;
      this.off  = off;
      this.last = last;
    endfunction: new


  // --------------------------------------------------------------------
  //
  endclass: riffa_transaction_class


  // --------------------------------------------------------------------
  // root port tx
  class rp_tx_bfm_class #(N)
    extends blocking_transmission_q_class #(riffa_transaction_class #(N));

    virtual riffa_chnl_if #(.N(N)) chnl_bus;

    // --------------------------------------------------------------------
    //
    task set_default;

      chnl_bus.cb_rp_tx.rx <= 0;
      chnl_bus.cb_rp_tx.rx_last <= 'bx;
      chnl_bus.cb_rp_tx.rx_len <= 'bx;
      chnl_bus.cb_rp_tx.rx_off <= 'bx;
      chnl_bus.cb_rp_tx.rx_data <= 'bx;
      chnl_bus.cb_rp_tx.rx_data_valid <= 0;

    endtask: set_default


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

    task transmit(ref Q_T tr_h);

      @(chnl_bus.cb_rp_tx);
      chnl_bus.cb_rp_tx.rx_len <= tr_h.len;  // must be => 4
      chnl_bus.cb_rp_tx.rx_off <= tr_h.off;
      chnl_bus.cb_rp_tx.rx_last <= tr_h.last;
      chnl_bus.cb_rp_tx.rx <= 1;

      @(chnl_bus.cb_rp_tx iff chnl_bus.cb_rp_tx.rx_ack);
      chnl_bus.cb_rp_tx.rx_data_valid <= 1;

      foreach(tr_h.data[i])
      begin
        chnl_bus.cb_rp_tx.rx_data <= tr_h.data[i];
        @(chnl_bus.cb_rp_tx iff chnl_bus.cb_rp_tx.rx_data_ren);
      end

      set_default();
      ->tx_done;
    endtask: transmit


    //--------------------------------------------------------------------
    //
    function new(virtual riffa_chnl_if #(.N(N)) chnl_bus);
      this.chnl_bus = chnl_bus;
      fork
        set_default();
      join_none
    endfunction: new


    // --------------------------------------------------------------------
    //
  endclass: rp_tx_bfm_class


  // --------------------------------------------------------------------
  // root port rx
  class rp_rx_bfm_class #(N)
    extends blocking_transmission_q_class #(riffa_transaction_class #(N));

    virtual riffa_chnl_if #(.N(N)) chnl_bus;
    mailbox #(riffa_transaction_class #(N)) rx_q;


    // --------------------------------------------------------------------
    //
    task set_default;

      chnl_bus.cb_rp_rx.tx_ack <= 0;
      chnl_bus.cb_rp_rx.tx_data_ren <= 0;

    endtask: set_default


    // --------------------------------------------------------------------
    //
    event rx_done;

    task automatic transmit(ref Q_T tr_h);
      int last;
      int len;
      int off;

      @(chnl_bus.cb_rp_rx iff chnl_bus.cb_rp_rx.tx);

      last = chnl_bus.cb_rp_rx.tx_last;
      len = chnl_bus.cb_rp_rx.tx_len; // must be => 4
      off = chnl_bus.cb_rp_rx.tx_off;
      tr_h = new(len, off, last);

      chnl_bus.cb_rp_rx.tx_ack <= 1;
      chnl_bus.cb_rp_rx.tx_data_ren <= 1;

      fork
        @(chnl_bus.cb_rp_rx)
          chnl_bus.cb_rp_rx.tx_ack <= 0;
      join_none

      foreach(tr_h.data[i])
      begin
        @(chnl_bus.cb_rp_rx iff chnl_bus.cb_rp_rx.tx_data_valid)
          tr_h.data[i] <= chnl_bus.cb_rp_rx.tx_data;
        // $display("^^^ %16.t | %d | %h", $time, i, chnl_bus.cb_rp_rx.tx_data);
      end

      rx_q.put(tr_h);
      set_default();
      ->rx_done;
    endtask: transmit


    //--------------------------------------------------------------------
    //
    function new(virtual riffa_chnl_if  #(.N(N)) chnl_bus);
      this.chnl_bus = chnl_bus;
      this.rx_q = new();
      fork
        set_default();
      join_none
    endfunction: new


    // --------------------------------------------------------------------
    //
  endclass: rp_rx_bfm_class

// --------------------------------------------------------------------
//
endpackage: riffa_bfm_class_pkg