Subversion Repositories 1000base-x

//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "encoder_8b_tx_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                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// This module is based on the coding method described in       ////
//// IEEE Std 802.3-2008 Clause 36 "Physical Coding Sublayer(PCS) ////
//// and Physical Medium Attachment (PMA) sublayer, type          ////
//// 1000BASE-X"; see :                                           ////
////                                                              ////
//// http://standards.ieee.org/about/get/802/802.3.html           ////
//// and                                                          ////
//// doc/802.3-2008_section3.pdf, Clause/Section 36.              ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
 
`include "timescale_tb.v"
 
module encoder_8b_tx_model #(
  parameter DEBUG       = 0,
  parameter out_delay   = 5,
  parameter in_delay    = 2
)(
  interface send_intf,
 
   // --- Clocks
   input SBYTECLK,
 
   input disparity_in,
 
   // --- Eight bit input bus	  
   output [7:0] ebi,
 
 
   output K
);
 
   import ethernet_frame::EthernetFrame;
 
   reg [7:0] 	tmp_ebi;
   reg          tmp_K;
   reg 		disparity;
 
   assign #out_delay ebi = tmp_ebi;
   assign #out_delay K   = tmp_K;
 
   // Single transmit data queue
   reg [7:0] encoder_8b_data_queue[$];
 
   // Config data queue
   reg [15:0] encoder_8b_config_queue[$];
 
   // Single transmit queue
   EthernetFrame transmit_queue[$];
 
   //----------------------------------------------------------------------------
  // Send interface functions
  //----------------------------------------------------------------------------
 
   function automatic string send_intf.whoami();
      string buffer;
      $sformat(buffer, "%m");
      return buffer.substr(0, buffer.len()-17);
   endfunction
 
   function automatic void send_intf.push_8B_symbol(reg [7:0] symbol);
 
      encoder_8b_data_queue.push_back(symbol);
 
   endfunction // automatic
 
 
   function automatic void send_intf.push_config(reg [15:0] config_reg);
 
      encoder_8b_config_queue.push_back(config_reg);
 
   endfunction // automatic
 
 
   // Queue frame for transmission.
   function automatic void send_intf.queue_frame(EthernetFrame frame);
 
      EthernetFrame f = frame;
 
      transmit_queue.push_back(f);
 
  endfunction // automatic
 
 
  // Wait for all frames to be transmitted.
   task automatic send_intf.sleep(time timeout);
      time start_time = $time;
      time end_time = start_time + timeout;
 
      while(1)
      begin
         @(posedge SBYTECLK);
 
         if ($time > end_time)  break;
      end
  endtask
 
   //----------------------------------------------------------------------------
   //
   //----------------------------------------------------------------------------
 
`define K28_5 8'b10111100   
 
   task automatic encoder_8b_push_symbol(input K, input [7:0] ebi);
      tmp_K = K; tmp_ebi = ebi;
      @(posedge SBYTECLK);
   endtask
 
 
   //----------------------------------------------------------------------------
   // Test Sequence Functions
   //----------------------------------------------------------------------------
 
   task automatic encoder_8b_push_test_sequence();
 
      encoder_8b_push_symbol(1'b1, `K28_5);
   endtask
 
   //----------------------------------------------------------------------------
   // IDLE Sequence Functions
   //----------------------------------------------------------------------------
 
`define D5_6  8'b11000101
`define D16_2 8'b01010000
 
   reg [7:0] I1[2] = '{ `K28_5, `D5_6  };
   reg [7:0] I2[2] = '{ `K28_5, `D16_2 };
 
   task automatic encoder_8b_push_idle_sequence();
 
      for (int x=0; x<2; x++)
	encoder_8b_push_symbol(~x, (disparity_in) ? I1[x] : I2[x]);
 
   endtask // automatic
 
 
   //----------------------------------------------------------------------------
   // Config Sequence Functions
   //----------------------------------------------------------------------------
 
`define D21_5 8'b10110101
`define D2_2  8'b01000010
 
   reg [7:0] C1[2] = '{ `K28_5, `D21_5 };
   reg [7:0] C2[2] = '{ `K28_5, `D2_2  };
 
   reg 	     c_toggle = 0;
 
   task automatic encoder_8b_push_config_sequence(reg [15:0] config_reg);
 
      //$display("%m: pushing config_reg: %016b", config_reg);
 
      for (int x=0; x<2; x++)
 
	// If disparity after K28.5 is +ve then choose
	// D2.2 to flip disparity
	// If disparity after K28.5 is -ve then choose
	// D31.5 to leave the disparity as -ve.: +(--+-)+
	// Doing this ensures that in a burst of /C/ sequences,
	// The disparity on before K28_5 is -ve so +comma is
	// always chosen!
	encoder_8b_push_symbol(~x, (c_toggle) ? C2[x] : C1[x]);
 
      // Push Config Register value
      encoder_8b_push_symbol(1'b0, config_reg[7:0]);
 
      // Push Config Register value
      encoder_8b_push_symbol(1'b0, config_reg[15:8]);
 
      c_toggle = ~c_toggle;
 
   endtask // automatic
 
   //----------------------------------------------------------------------------
   // Frame transmit Functions
   //----------------------------------------------------------------------------
 
`define K23_7  8'b11110111
`define K27_7  8'b11111011
`define K29_7  8'b11111101
 
   task automatic encoder_8b_transmit_frame();
 
      EthernetFrame frame;
 
      integer burst_size = transmit_queue.size;
 
      integer burst_count = 0;
 
      while (transmit_queue.size())
	begin
	   // Select frame at front of the queue
	   frame = transmit_queue[0];
 
	   // If this a burst insert /R/ before /S/
	   if ((burst_size > 1) && (burst_count))
	     encoder_8b_push_symbol(1'b1, `K23_7);
 
	     // Transmit SFD
	   encoder_8b_push_symbol(1'b1, `K27_7);
 
	   // Push frame
	   for (int index=0; index<frame.len(); index++)
	     encoder_8b_push_symbol(1'b0, frame.raw[index]);
 
	   // Push EPD
	   encoder_8b_push_symbol(1'b1, `K29_7);
 
	   // Keep track of the number of frames transmitted in a burst.
	   burst_count += 1;
 
	   void'(transmit_queue.pop_front());
	end
   endtask // automatic
 
   //----------------------------------------------------------------------------
   // Transmit Process.
   //----------------------------------------------------------------------------
   task automatic encoder_8b_push();
 
      // Is there any ctrl data to bus
      if (encoder_8b_config_queue.size())     
 
	// Push sequence C1/C2/Config_Reg
	encoder_8b_push_config_sequence(encoder_8b_config_queue.pop_front());
 
      // Are there any frames to transmit ?
      else if (transmit_queue.size())
 
	// Push SPD + frame + EFD
	encoder_8b_transmit_frame();
 
      // Is there any Data to push
      else if (encoder_8b_data_queue.size()) 
 
	// Push data 
	encoder_8b_push_symbol(1'b0, encoder_8b_data_queue.pop_front());
 
      else
	// Otherwise push the Idle sequence I1 or I2
	encoder_8b_push_idle_sequence();
 
   endtask // automatic
 
 
   //----------------------------------------------------------------------------
   //----------------------------------------------------------------------------
 
  initial
    begin
       tmp_ebi = 8'h00; tmp_K = 0;
 
       // Get initial disparity
       disparity = disparity_in;
 
       /// Obtain initial sync...
       @(posedge SBYTECLK);
 
       while(1)
	 begin
	    encoder_8b_push();
 
	    // Get disparity at end of every symbol push
	    disparity = disparity_in;
	 end
 
    end
 
endmodule