Subversion Repositories 1000base-x

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

////                                                              ////

////  File name "ethernet_frame.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                     ////

////                                                              ////

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

////                                                              ////

////                                                              ////

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

package ethernet_frame;

   import tb_utils::hexpretty;

   import tb_utils::hexformat;

   typedef int crc_t[4];

   typedef int proto_t[2];

   typedef int payload_t[];

   typedef int ethernet_address_t[6];

   localparam ethernet_address_t ETH_A_TB        = '{'haa, 'hbb, 'hcc, 'hdd, 'hee, 'hff};

   localparam ethernet_address_t ETH_A_BCAST     = '{'hff, 'hff, 'hff, 'hff, 'hff, 'hff};

   localparam ethernet_address_t ETH_A_NULL      = '{'h00, 'h00, 'h00, 'h00, 'h00, 'h00};

   localparam ethernet_address_t ether_broadcast = ETH_A_BCAST;

   localparam ethernet_address_t ether_null      = ETH_A_NULL;

   localparam ethernet_address_t def_dst_addr    = ETH_A_TB;

   localparam ethernet_address_t def_src_addr    = ETH_A_TB;

   localparam proto_t ETH_P_IP                   = '{'h08, 'h00};

   localparam proto_t def_proto                  = ETH_P_IP;

   localparam int ethernet_preamble      = 'h5;

   localparam int ethernet_preamble_len  = 15;

   localparam int ethernet_sfd           = 'hd;

   localparam int ethernet_min_payload   = 46;

   localparam int ethernet_max_payload   = 2100;

   localparam int ethernet_crc_poly      = 32'h04c11db7;

   localparam int ethernet_overhead      = (6+6+2+4); // Excludes preamble, SFD

   // Parameters for 100BaseTx Ethernet:

   localparam int ethernet_slot_time        = 512;  // bit times

   localparam int ethernet_inter_frame_gap  = 96;   // bits

   localparam int ethernet_attempt_limit    = 16;

   localparam int ethernet_back_off_limit   = 10;

   localparam int ethernet_jam_size         = 32;   // bits

   localparam int ethernet_min_frame_size   = ethernet_min_payload + ethernet_overhead; // = 64;

   localparam int ethernet_clk_rate         = 25e6;

   typedef enum   { ETH10, ETH100, ETH1000 } EthernetSpeed;

   int            nothing[] = new[0];

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

   //

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

class CRC32;

   static function reg [7:0] byte_swap(reg [7:0] x);

      return {x[0], x[1], x[2], x[3], x[4], x[5], x[6], x[7]};

   endfunction

   static function reg [31:0] word_swap(reg [31:0] x);

      return {byte_swap(x[7:0]), byte_swap(x[15:8]), byte_swap(x[23:16]), byte_swap(x[31:24])};

   endfunction

   static function reg[31:0] pack_swap(reg [31:0] x);

      return  { x[7:0], x[15:8], x[23:16], x[31:24]};

   endfunction // pack_swap

   static int     crc32_table[256];

   static int     crc32_table_ready = 0;

   int            accum = 32'hffffffff;

   static function automatic void populate_crc_table();

      $display("Populating crc32 table...");

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

        begin

           int c = i<<24;

           for(int j=0; j<8; j++)

             begin

                if(c & 32'h80000000)

                  c = (c << 1) ^ ethernet_crc_poly;

                else

                  c = (c << 1);

             end

           crc32_table[byte_swap(i)] = word_swap(c);

        end

      crc32_table_ready = 1;

   endfunction

   function void reset();

      accum = 32'hffffffff;

      if(!crc32_table_ready) populate_crc_table();

   endfunction

   function new();

      reset();

   endfunction

   function void push(int x);

      accum = (accum[31:8] ^ crc32_table[accum[7:0] ^ x[7:0]]) & 32'hffffffff;

   endfunction

   function int eval();

      return ~accum;

   endfunction

   static function int block(int buffer[], int start, int finish);

      CRC32 x = new();

      x.reset();

      for(int i=start; i<finish; i++) x.push(buffer[i]);

      return x.eval();

   endfunction

endclass // CRC32

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

   //

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

   function automatic string fmt_addr(ethernet_address_t addr);

      $sformat(fmt_addr, "%02X.%02X.%02X.%02X.%02X.%02X",

               addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);

   endfunction

   function void random_payload(int size, output int rv[], input int randomize, int seed=-1);

      int tmp;

      if (seed >= 0) tmp = $urandom(seed);

      rv = new[size];

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

        rv[i] = (randomize) ? ($urandom() & 'hff) : ((1+i) & 'hff);

   endfunction

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

  class EthernetFrame extends packet::Packet;

    int raw[];

    int badcrc;

    time delay = 0;

    int epd_sequence = 0;

    function new(

      int da[]      = def_dst_addr,

      int sa[]      = def_src_addr,

      int proto[]   = def_proto,

      int payload[] = nothing,

      int seed      = -1,

      int randomize = 1,

      int length    = 100,

      int badcrc    = 0,

      int initraw[] = nothing

    );

       set_badcrc(badcrc, 0);

      if(initraw.size()!=0)

        raw = new[initraw.size()](initraw);

      else

        begin

          if(payload.size()==0) random_payload(length, payload, randomize, seed);

          set_payload(payload);

          set_da(da, 0);

          set_sa(sa, 0);

          set_proto(proto, 1);

        end

    endfunction

    function int len();

      return raw.size();

    endfunction

    function int payload_len();

      return raw.size() - ethernet_overhead;

    endfunction

    function string repr_verbose(int n_start=4, int n_end=4);

      string s;

      $sformat(s, "<Frame,da=%s,sa=%s,len=%s,pay=%s,crc=%s>",

        fmt_addr(get_da()),

        fmt_addr(get_sa()),

        hexpretty(get_proto()),

        hexpretty(get_payload(), n_start, n_end),

        hexpretty(get_crc())

      );

      return s;

   endfunction // repr

   function string dump();

      string s;

      $sformat(s, "<len=%0d,da=%s,sa=%s,type=%s,pay=%s,crc=%s>",

        len(),

        fmt_addr(get_da()),

        fmt_addr(get_sa()),

        hexpretty(get_proto()),

        hexformat(get_payload(), "0x%02x", ","),

        hexpretty(get_crc())

      );

      return s;

    endfunction

    function void resize(int n);

      raw = new[n](raw);

    endfunction

     function void cut(int pos, int n);

        for(int i=pos; i<(raw.size-n); i++)

          raw[i] = raw[i+n];

        resize(raw.size - n);

     endfunction; // extract  

    function void set_da(ethernet_address_t da, int update=1);

      raw[0:5] = da;

      if(update)

        update_crc();

    endfunction

    function ethernet_address_t get_da();

      return raw[0:5];

    endfunction

    function void set_sa(ethernet_address_t sa, int update=1);

      raw[6:11] = sa;

      if(update)

        update_crc();

    endfunction

    function ethernet_address_t get_sa();

      return raw[6:11];

    endfunction

    function void set_proto(proto_t x, int update=1);

      raw[12:13] = x;

      if(update)

        update_crc();

    endfunction

    function proto_t get_proto();

      return raw[12:13];

    endfunction

    function void set_badcrc(int b, int update=1);

      badcrc = b;

      if(update)

        update_crc();

    endfunction

     function void set_payload(int p[]);

       int   n = p.size();

       resize(n+ethernet_overhead);

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

         raw[14+i] = p[i];

    endfunction

    function void pad_up();

      int n = raw.size();

      if(n < ethernet_min_frame_size)

        begin

           $display("Inserting %0d bytes of padding.", ethernet_min_frame_size-n);

           resize(ethernet_min_frame_size);

           for(int i=n-4; i<ethernet_min_frame_size-4; i++)

             raw[i] = 0;

           update_crc();

        end

    endfunction

     function void align();

        int n = raw.size();

        if(n[0])

          begin

             $display("Increasing size of frame from %0d bytes to %0d bytes.", n, n+1);

             resize(n+1);

             raw[n-4] = 0;

             update_crc();

          end

     endfunction

    // Seems we can't avoid the copy in here...

    function payload_t get_payload();

      int n = raw.size()-ethernet_overhead;

      get_payload = new[n];

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

        get_payload[i] = raw[14+i];

    endfunction

    function crc_t calc_crc();

      int crc = CRC32::block(raw, 0, raw.size()-4);

      calc_crc[0] = crc[7:0];

      calc_crc[1] = crc[15:8];

      calc_crc[2] = crc[23:16];

      calc_crc[3] = crc[31:24];

    endfunction

    function crc_t get_crc();

      return raw[raw.size()-4+:4];

    endfunction

    function int check_crc();

      int expected_crc[4] = calc_crc();

      int extracted_crc[4] = get_crc();

      return expected_crc==extracted_crc;

    endfunction

    // Update length and CRC fields.

    function void update_crc();

      if(raw.size()>=4)

        begin

          int fcs[4];

          int n;

          fcs = calc_crc();

           n = raw.size();

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

            raw[n-4+i] = fcs[i] ^ (badcrc ? 'ha5 : 0);

        end

    endfunction

  endclass

  // Specialize a mailbox for passing Ethernet frames.

  typedef mailbox #(EthernetFrame) FrameMailBox;

endpackage