Subversion Repositories 1000base-x

//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "gmii_rx_model.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"
 
module gmii_rx_model #(
  parameter DEBUG     = 0,
  parameter REDUCED   = 0, 
  parameter in_delay  = 2
)(
  interface check_intf,
 
  input         mii_rxck_in,
  input         gmii_rxck_in,
  output        mii_rxck_out,
 
  input [7:0]   rxd,
  input         rx_dv,
  input         rx_er
);
 
   import tb_utils::hexformat; 
 
   import ethernet_frame::EthernetFrame;
   import ethernet_frame::EthernetSpeed;
   import ethernet_frame::ETH10;
   import ethernet_frame::ETH1000; 
   import ethernet_frame::ethernet_inter_frame_gap;
   import ethernet_frame::ethernet_address_t;
   import ethernet_frame::ethernet_preamble_len;
   import ethernet_frame::FrameMailBox;
   import ethernet_frame::fmt_addr;
   import ethernet_frame::ethernet_preamble;
   import ethernet_frame::ethernet_sfd;
 
  wire [7:0] tmp_rxd;
  wire       tmp_rx_dv, tmp_rx_er;
 
   assign #in_delay tmp_rx_dv = rx_dv;
   assign #in_delay tmp_rx_er = rx_er;
   assign #in_delay tmp_rxd   = rxd;
 
   EthernetSpeed  speed = ETH1000;
 
   reg 	     mii_rxck10baseT;
 
   wire      rx_clk  = (speed == ETH1000) ? gmii_rxck_in     :
                       (speed == ETH10)   ? mii_rxck10baseT : mii_rxck_in ;
 
   assign mii_rxck_out = (speed == ETH10) ? mii_rxck10baseT : mii_rxck_in;
 
   FrameMailBox registered_mailboxes[ethernet_address_t];
 
   int 	     eth_parity = 0; int  eth_errors = 0;
 
   virtual   ether_send_intf loopback_intf;
 
  //----------------------------------------------------------------------------
  // Generate 10 baseT rx clock
  //----------------------------------------------------------------------------
  initial
    begin
      mii_rxck10baseT <= 0;
      while(1)
        begin
          repeat(5)
            @(posedge mii_rxck_in) mii_rxck10baseT <= 1;
          repeat(5)
            @(posedge mii_rxck_in) mii_rxck10baseT <= 0;
        end
    end
 
 
  //----------------------------------------------------------------------------
  // Check interface functions
  //----------------------------------------------------------------------------
 
  function automatic string check_intf.whoami();
    string buffer;
    $sformat(buffer, "%m");
    return buffer.substr(0, buffer.len()-17);
  endfunction
 
  // Register a mailbox to receive frames from a particular source address.
  function automatic void check_intf.register_mailbox(ethernet_address_t sa, FrameMailBox mbx);
    $display("%m: Registering a mailbox to address %s", fmt_addr(sa));
    registered_mailboxes[sa] = mbx;
  endfunction
 
  // Remove a mailbox.
  function automatic void check_intf.unregister_mailbox(ethernet_address_t sa);
    registered_mailboxes.delete(sa);
  endfunction
 
  // Set/clear loopback
  function automatic void check_intf.enable_loopback(virtual ether_send_intf intf);
    loopback_intf = intf;
  endfunction
 
  function automatic void check_intf.set_parity_errors(int parity, int errors);
    eth_parity = parity;
    eth_errors = errors;
  endfunction
 
  function automatic void check_intf.set_speed(EthernetSpeed m);
    speed = m;
  endfunction
 
 
   task automatic check_frame(EthernetFrame frame);
      ethernet_address_t da;
 
      if (!frame.check_crc())
	begin
           $display(" -> Error, CRC incorrect.");
           $display(" ->   Received %s", hexformat(frame.get_crc()));
           $display(" ->   Expected %s", hexformat(frame.calc_crc()));
           return;
	end
 
      da = frame.get_da();
 
      // Look for a mailbox registered to this address.
      if(registered_mailboxes.exists(da))
	void'(registered_mailboxes[da].try_put(frame));
      else
	begin
           ethernet_address_t addr;
           $display("Warning, no handler registered for Ethernet address %s.", fmt_addr(da));
           $display("%0d addresses registered:", registered_mailboxes.num());
           for(int ok=registered_mailboxes.first(addr); ok; ok=registered_mailboxes.next(addr))
             $display("  %s", fmt_addr(addr));
	end
   endtask
 
  //----------------------------------------------------------------------------
  // Receive Process.
  //----------------------------------------------------------------------------
 
  task automatic gmii_receive();
     EthernetFrame rx_frame;
     int odd, prev_dibit;
     int nybbles[$];
     int raw_frame[$];
     int errored;
     int preamble_count;
     int found_sfd;
     int min_gap_symbols;
 
     int gap = 0;
 
     if(DEBUG) $display("%m");
 
     while(tmp_rx_dv !== 1)
       begin
          gap++;
          @(posedge rx_clk);
       end
 
     if(DEBUG) $display("%m: Start of receive frame.");
 
     min_gap_symbols = (speed==ETH1000) ? ethernet_inter_frame_gap/8 : ethernet_inter_frame_gap/(REDUCED ? 2 : 4);
 
     if(gap < min_gap_symbols)
       $display("%m: Warning, insufficient interframe gap (got %0d symbols, require %0d).", gap, min_gap_symbols);
 
     // Now grab the frame. We don't attempt to decode it during reception.
     nybbles = {};  errored = 0; odd = 0; prev_dibit = 0;
 
     while(tmp_rx_dv)
       begin
          if(REDUCED & odd)
            begin
               nybbles.push_back(((tmp_rxd & 3)<<2) | prev_dibit);
 
               if(tmp_rx_er) errored = 1;
            end
          else if(!REDUCED)
            begin
               nybbles.push_back(tmp_rxd & 'hf);
 
               if (speed == ETH1000) nybbles.push_back((tmp_rxd>>4) & 'hf);
 
               if(tmp_rx_er) errored = 1;
            end
 
          prev_dibit = tmp_rxd & 3;
          odd = !odd;
 
          @(posedge rx_clk);
       end
 
    // This will mostly catch collisions, so make it just a warning.
    if (errored) begin
       $display("%m: Warning, frame contained errors (rx_er detected).");
       return;
    end
 
    // Search for the SFD.
    preamble_count = 0; found_sfd = 0;
 
     for (int i=0; i<nybbles.size(); i++)
       begin
          int nyb = nybbles[i];
 
          if      (nyb == ethernet_preamble) preamble_count++;
          else if (nyb == ethernet_sfd) begin
             found_sfd = 1; break;
          end
          else preamble_count = 0;
       end
 
    if (!found_sfd) begin
       $display("%m: Error, SFD not found.");
       $display("%s", hexformat(nybbles[0:20], "0x%02x", ","));
       return;
    end
 
     if (preamble_count != ethernet_preamble_len) begin
	$display("%m: Warning, preamble was %0d nybbles long.", preamble_count);
       $stop;	 
    end
 
    if ((preamble_count<4) || (preamble_count>2*ethernet_preamble_len)) return;
 
    // Chop off preamble and SFD.
    nybbles = nybbles[preamble_count+1:$];
 
    // Deal with an odd number of nybbles.
    if(nybbles.size() & 1)
      begin
        nybbles.push_back(0);
        $display("%m: Warning, frame contained an odd number of nybbles.");
      end
 
    // Convert frame to bytes:
    raw_frame = {};
 
     for (int i=0; i<nybbles.size(); i+=2)
       raw_frame.push_back(nybbles[i] | (nybbles[i+1]<<4));
 
    if (raw_frame.size() < ethernet_frame::ethernet_min_frame_size)
      begin
         // This will mostly catch collisions, so make it just a warning.
         $display("%m: Warning, frame too small. (%0d bytes).", raw_frame.size());
         $display("%m: Raw received frame:");
	 $display("%s", hexformat(raw_frame, "0x%01x", ","));
	 return;
      end
 
    if(DEBUG>1)
      begin
        $display("%m: Raw received frame:");
        $display("%s", hexformat(raw_frame, "0x%01x", ","));
      end
 
    rx_frame = new(.initraw(raw_frame));
 
    if (loopback_intf)
      begin
         // Swap around dst and src MAC addresses
         ethernet_address_t sa = rx_frame.get_sa();
 
         rx_frame.set_sa(rx_frame.get_da()); rx_frame.set_da(sa);
 
        // Retransmit frame.
        loopback_intf.queue_frame(rx_frame);
      end
    else
      check_frame(rx_frame);
 
  endtask
 
  always
    gmii_receive();
 
endmodule