Subversion Repositories 1000base-x

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

////                                                              ////

////  File name "ethernet_threads.v"                              ////

////                                                              ////

////  This file is part of the :                                  ////

////                                                              ////

//// "1000BASE-X IEEE 802.3-2008 Clause 36 - PCS project"         ////

////                                                              ////

////  http://opencores.org/project,1000base-x                     ////

////                                                              ////

////  Author(s):                                                  ////

////      - D.W.Pegler Cambridge Broadband Networks Ltd           ////

////                                                              ////

////      { peglerd@gmail.com, dwp@cambridgebroadand.com }        ////

////                                                              ////

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

////                                                              ////

//// Copyright (C) 2009 AUTHORS. All rights reserved.             ////

////                                                              ////

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

////                                                              ////

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

////                                                              ////

////                                                              ////

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

`include "timescale_tb.v"

`include "ge_1000baseX_constants.v"

package ethernet_threads;

  import tb_utils::hexformat;

  import packet::Packet;

  import packet::PacketMailBox;

  import ethernet_frame::EthernetFrame;

  import ethernet_frame::FrameMailBox;

  import ethernet_frame::ethernet_address_t;

`define VALID 1'b1

`define INVALID 1'b0

  virtual class TxThread;

    virtual task run(PacketMailBox mbx);

    endtask

    virtual task pass_to_checker(Packet p, PacketMailBox mbx);

      mbx.put(p);

    endtask

  endclass

   virtual class RxThread;

     virtual task run(ref int errors, PacketMailBox mbx);

     endtask

   endclass

   function [15:0] reorder(input [15:0] x);

      reorder = {x[7:0], x[15:8]};

   endfunction // byte_swap

   //******************************************************************************

   // 8B/10B random

   //******************************************************************************

   function automatic void random(int seed=-1, output int value);

      if (seed >= 0) begin int tmp = $urandom(seed); end

      value = $urandom() & 'hff;

   endfunction // random

  //******************************************************************************

  // Ethernet frame sending thread...

  //******************************************************************************

  class GmiiTxThread extends TxThread;

    virtual gmii_tx_if   tx;

    ethernet_address_t   dst_addr;

    ethernet_address_t   src_addr;

    int                  length;

    int                  num_frames;

    int                  spacing;

    // Do nothing constructor.

    function new(); endfunction

    // Use a static function for construction so we can use :: notation.

    static function GmiiTxThread NEW(

      virtual gmii_tx_if  tx,

      ethernet_address_t  dst_addr,

      ethernet_address_t  src_addr,

      int                 length,

      int                 num_frames,

      int                 spacing

    );

      GmiiTxThread x = new();

      x.tx           = tx;

      x.dst_addr     = dst_addr;

      x.src_addr     = src_addr;

      x.length       = length;

      x.num_frames   = num_frames;

      x.spacing      = spacing;

      return x;

    endfunction

    virtual task run(PacketMailBox mbx);

      EthernetFrame frame;

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

        begin

          int len = length<0 ? i-length : length;

          $display("\nSending Ethernet frame: %0d, length: %0d", i, len);

          frame = new(dst_addr, src_addr, .length(len));

          //$display("Transmit: %s", frame.repr_verbose(20,20));

            $display("Transmit: %s", frame.dump());

          tx.queue_frame(EthernetFrame'(frame));

          pass_to_checker(frame, mbx);

          # spacing;

       end

      mbx.put(null);

    endtask

  endclass

  //******************************************************************************

  // Ethernet frame checking thread...

  //******************************************************************************

  class GmiiRxThread extends RxThread;

    virtual gmii_rx_if  rx;

    ethernet_address_t  dst_addr;

    time                timeout_first;

    time                timeout_rest;

    int                 dut_will_pad;

    // Do nothing constructor.

    function new(); endfunction

    // Use a static function for construction so we can use :: notation.

    static function GmiiRxThread NEW(

      input virtual gmii_rx_if   rx,

      input ethernet_address_t   dst_addr,

      input time                 timeout_first,

      input time                 timeout_rest,

      input int                  dut_will_pad=1

    );

      GmiiRxThread x = new();

      x.rx      = rx;

      x.dst_addr            = dst_addr;

      x.timeout_first = timeout_first;

      x.timeout_rest  = timeout_rest;

      x.dut_will_pad  = dut_will_pad;

      return x;

    endfunction

    virtual task run(ref int errors, PacketMailBox mbx);

      string         mod_name = string'(rx.whoami());

      FrameMailBox   rx_mbx = new();

      Packet         p;

      EthernetFrame  expected_frames[$];

      int            finished = 0;

      EthernetFrame  frame;

      time           end_time;

      time           timeout = timeout_first;

      int            matched;

      int            frames_matched = 0;

      rx.register_mailbox(ethernet_address_t'(dst_addr), FrameMailBox'(rx_mbx));

      while(1)

        begin

          // Fetch the next cell to be matched from the FIFO...

          if(!finished)

            begin

              mbx.get(p);

              if(p==null)

                finished = 1;

              else begin

                EthernetFrame expected = EthernetFrame'(p);

                // If the DUT pads frames up to the minimum Ethernet frame size then

                // we must pad the expected frame also!

                if(dut_will_pad)

                  expected.pad_up();

                expected_frames.push_back(expected);

                end

            end

          if(expected_frames.size()==0)

            break;

          // Wait for a frame to be received

          end_time = $time + timeout;

          timeout = timeout_rest;

          while((rx_mbx.try_get(frame)==0) && ($time<end_time))

            #100ns;

          if(frame==null)

            begin

              $display("%s: %0t: Error, frame timed out for address %s.", mod_name, $time, ethernet_frame::fmt_addr(dst_addr));

              errors += 1;

              // A timeout probably means the link is broken, so don't waste too much time waiting...

              if(finished)

                begin

                  void'(expected_frames.pop_back());

                  timeout_rest = timeout_rest / 2;

                end

            end

          else

            begin

              // Search the list of expected cells for one matching the received frames

              matched = 0;

              for(int i=0; i<expected_frames.size(); i++)

                if(frame.raw==expected_frames[i].raw)

                  begin

                    if(i==0) begin

                       $display("%s: -> Frame matched O.K %03d", mod_name, frames_matched++);

                    end

                    else

                      $display("%s: -> Frame did not match the next expected frame but did match frame number %0d.", mod_name, i);

                    expected_frames.delete(i);

                    matched = 1;

                    break;

                  end

              if(!matched)

                begin

                   $display("%s: %0t: -> Unexpected frame received.", mod_name, $time);

                   $display("  Rec: %s", frame.repr_verbose(25,10));

                   $display("  Exp: %s", expected_frames[0].repr_verbose(25,10));

                  errors += 1;

                end

            end

        end

      rx.unregister_mailbox(ethernet_address_t'(dst_addr));

      $display("%s: GmiiRxThread for %s has completed.", mod_name, ethernet_frame::fmt_addr(dst_addr));

    endtask

  endclass

  //******************************************************************************

  // Ignore frames from the specified address.

  //******************************************************************************

  task EtherIgnoreThread(

    virtual gmii_rx_intf rx,

    ethernet_address_t      dst_addr

  );

    FrameMailBox rx_mbx = new();

    EthernetFrame   frame;

    rx.register_mailbox(ethernet_address_t'(dst_addr), FrameMailBox'(rx_mbx));

    while(1)

      rx_mbx.get(frame);

  endtask

  //******************************************************************************

  // This structure specifies a traffic stream to be sent between two points.

  //******************************************************************************

  typedef struct {

    TxThread tx; RxThread rxi;

  } EthernetFlowEntry;

  //******************************************************************************

  // Traffic send/check task.

  //******************************************************************************

  class EthernetFlow;

    EthernetFlowEntry flow_table[$];

    function void create(TxThread s, RxThread c);

      EthernetFlowEntry f = '{s, c};

      flow_table.push_back(f);

    endfunction

    function void clear();

      flow_table = {};

    endfunction

    task start(ref int errors);

       EthernetFlowEntry f;

       int       local_errors = 0;

      $display("%m: Starting traffic flow.");

      // Launch all the send/receive threads...

      for(int i=0; i<flow_table.size(); i++)

        begin

          f = flow_table[i];

          fork

            PacketMailBox mbx = new();

            f.tx.run(mbx);

            if(f.rxi)

              f.rxi.run(local_errors, mbx);

          join_none

          #0; // Wait for the forked threads to start before changing their parameters!!!

        end

      wait fork;

      errors += local_errors;

      $display("%m: %0tns: All threads completed.", $time);

    endtask

  endclass

endpackage