URL https://opencores.org/ocsvn/xge_mac/xge_mac/trunk

Subversion Repositories xge_mac

[/] [xge_mac/] [trunk/] [rtl/] [verilog/] [tx_dequeue.v] - Blame information for rev 26

Details | Compare with Previous | View Log


//////////////////////////////////////////////////////////////////////
////                                                              ////
////  File name "tx_dequeue.v"                                    ////
////                                                              ////
////  This file is part of the "10GE MAC" project                 ////
////  http://www.opencores.org/cores/xge_mac/                     ////
////                                                              ////
////  Author(s):                                                  ////
////      - A. Tanguay (antanguay@opencores.org)                  ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2008 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 "defines.v"
 
module tx_dequeue(/*AUTOARG*/
  // Outputs
  txdfifo_ren, txhfifo_ren, txhfifo_wdata, txhfifo_wstatus,
  txhfifo_wen, xgmii_txd, xgmii_txc, status_txdfifo_udflow_tog,
  txsfifo_wen, txsfifo_wdata,
  // Inputs
  clk_xgmii_tx, reset_xgmii_tx_n, ctrl_tx_enable_ctx,
  status_local_fault_ctx, status_remote_fault_ctx, txdfifo_rdata,
  txdfifo_rstatus, txdfifo_rempty, txdfifo_ralmost_empty,
  txhfifo_rdata, txhfifo_rstatus, txhfifo_rempty,
  txhfifo_ralmost_empty, txhfifo_wfull, txhfifo_walmost_full
  );
`include "CRC32_D64.v"
`include "CRC32_D8.v"
`include "utils.v"
 
input         clk_xgmii_tx;
input         reset_xgmii_tx_n;
 
input         ctrl_tx_enable_ctx;
 
input         status_local_fault_ctx;
input         status_remote_fault_ctx;
 
input  [63:0] txdfifo_rdata;
input  [7:0]  txdfifo_rstatus;
input         txdfifo_rempty;
input         txdfifo_ralmost_empty;
 
input  [63:0] txhfifo_rdata;
input  [7:0]  txhfifo_rstatus;
input         txhfifo_rempty;
input         txhfifo_ralmost_empty;
 
input         txhfifo_wfull;
input         txhfifo_walmost_full;
 
output        txdfifo_ren;
 
output        txhfifo_ren;
 
output [63:0] txhfifo_wdata;
output [7:0]  txhfifo_wstatus;
output        txhfifo_wen;
 
output [63:0] xgmii_txd;
output [7:0]  xgmii_txc;
 
output        status_txdfifo_udflow_tog;
 
output        txsfifo_wen;
output [13:0] txsfifo_wdata;
 
 
/*AUTOREG*/
// Beginning of automatic regs (for this module's undeclared outputs)
reg                     status_txdfifo_udflow_tog;
reg                     txdfifo_ren;
reg                     txhfifo_ren;
reg [63:0]              txhfifo_wdata;
reg                     txhfifo_wen;
reg [7:0]               txhfifo_wstatus;
reg [13:0]              txsfifo_wdata;
reg                     txsfifo_wen;
reg [7:0]               xgmii_txc;
reg [63:0]              xgmii_txd;
// End of automatics
 
/*AUTOWIRE*/
 
 
reg   [63:0]    xgxs_txd;
reg   [7:0]     xgxs_txc;
 
reg   [63:0]    next_xgxs_txd;
reg   [7:0]     next_xgxs_txc;
 
reg   [2:0]     curr_state_enc;
reg   [2:0]     next_state_enc;
 
reg   [0:0]     curr_state_pad;
reg   [0:0]     next_state_pad;
 
reg             start_on_lane0;
reg             next_start_on_lane0;
 
reg   [2:0]     ifg_deficit;
reg   [2:0]     next_ifg_deficit;
 
reg             ifg_4b_add;
reg             next_ifg_4b_add;
 
reg             ifg_8b_add;
reg             next_ifg_8b_add;
 
reg             ifg_8b2_add;
reg             next_ifg_8b2_add;
 
reg   [7:0]     eop;
reg   [7:0]     next_eop;
 
reg   [63:32]   xgxs_txd_barrel;
reg   [7:4]     xgxs_txc_barrel;
 
reg   [63:0]    txhfifo_rdata_d1;
 
reg   [13:0]    add_cnt;
reg   [13:0]    byte_cnt;
 
reg   [31:0]    crc32_d64;
reg   [31:0]    crc32_d8;
reg   [31:0]    crc32_tx;
 
reg   [63:0]    shift_crc_data;
reg   [3:0]     shift_crc_eop;
reg   [3:0]     shift_crc_cnt;
 
reg   [31:0]    crc_data;
 
reg             frame_available;
reg             next_frame_available;
 
reg   [63:0]    next_txhfifo_wdata;
reg   [7:0]     next_txhfifo_wstatus;
reg             next_txhfifo_wen;
 
reg             txdfifo_ren_d1;
 
reg             frame_end;
 
parameter [2:0]
             SM_IDLE      = 3'd0,
             SM_PREAMBLE  = 3'd1,
             SM_TX        = 3'd2,
             SM_EOP       = 3'd3,
             SM_TERM      = 3'd4,
             SM_TERM_FAIL = 3'd5,
             SM_IFG       = 3'd6;
 
parameter [0:0]
             SM_PAD_EQ    = 1'd0,
             SM_PAD_PAD   = 1'd1;
 
 
//---
// RC layer
 
always @(posedge clk_xgmii_tx or negedge reset_xgmii_tx_n) begin
 
    if (reset_xgmii_tx_n == 1'b0) begin
 
        xgmii_txd <= {8{`IDLE}};
        xgmii_txc <= 8'hff;
 
    end
    else begin
 
 
        //---
        // RC Layer, insert local or remote fault messages based on status
        // of fault state-machine
 
        if (status_local_fault_ctx) begin
 
            // If local fault detected, send remote fault message to
            // link partner
 
            xgmii_txd <= {`REMOTE_FAULT, 8'h0, 8'h0, `SEQUENCE,
                          `REMOTE_FAULT, 8'h0, 8'h0, `SEQUENCE};
            xgmii_txc <= {4'b0001, 4'b0001};
        end
        else if (status_remote_fault_ctx) begin
 
            // If remote fault detected, inhibit transmission and send
            // idle codes
 
            xgmii_txd <= {8{`IDLE}};
            xgmii_txc <= 8'hff;
        end
        else begin
            xgmii_txd <= xgxs_txd;
            xgmii_txc <= xgxs_txc;
        end
    end
 
end
 
 
always @(posedge clk_xgmii_tx or negedge reset_xgmii_tx_n) begin
 
    if (reset_xgmii_tx_n == 1'b0) begin
 
        curr_state_enc <= SM_IDLE;
 
        start_on_lane0 <= 1'b1;
        ifg_deficit <= 3'b0;
        ifg_4b_add <= 1'b0;
        ifg_8b_add <= 1'b0;
        ifg_8b2_add <= 1'b0;
 
        eop <= 8'b0;
 
        txhfifo_rdata_d1 <= 64'b0;
 
        xgxs_txd_barrel <= {4{`IDLE}};
        xgxs_txc_barrel <= 4'hf;
 
        frame_available <= 1'b0;
 
        xgxs_txd <= {8{`IDLE}};
        xgxs_txc <= 8'hff;
 
        status_txdfifo_udflow_tog <= 1'b0;
 
        txsfifo_wen <= 1'b0;
        txsfifo_wdata <= 14'b0;
 
    end
    else begin
 
        curr_state_enc <= next_state_enc;
 
        start_on_lane0 <= next_start_on_lane0;
        ifg_deficit <= next_ifg_deficit;
        ifg_4b_add <= next_ifg_4b_add;
        ifg_8b_add <= next_ifg_8b_add;
        ifg_8b2_add <= next_ifg_8b2_add;
 
        eop <= next_eop;
 
        txhfifo_rdata_d1 <= txhfifo_rdata;
 
        xgxs_txd_barrel <= next_xgxs_txd[63:32];
        xgxs_txc_barrel <= next_xgxs_txc[7:4];
 
        frame_available <= next_frame_available;
 
        txsfifo_wen <= 1'b0;
        txsfifo_wdata <= byte_cnt;
 
        //---
        // Barrel shifter. Previous stage always align packet with LANE0.
        // This stage allow us to shift packet to align with LANE4 if needed
        // for correct inter frame gap (IFG).
 
        if (next_start_on_lane0) begin
 
            xgxs_txd <= next_xgxs_txd;
            xgxs_txc <= next_xgxs_txc;
 
        end
        else begin
 
            xgxs_txd <= {next_xgxs_txd[31:0], xgxs_txd_barrel};
            xgxs_txc <= {next_xgxs_txc[3:0], xgxs_txc_barrel};
 
        end
 
        //---
        // FIFO errors, used to generate interrupts.
 
        if (txdfifo_ren && txdfifo_rempty) begin
            status_txdfifo_udflow_tog <= ~status_txdfifo_udflow_tog;
        end
 
        //---
        // Frame count and size
 
        if (frame_end) begin
            txsfifo_wen <= 1'b1;
        end
 
    end
 
end
 
always @(/*AS*/crc32_tx or ctrl_tx_enable_ctx or curr_state_enc or eop
         or frame_available or ifg_4b_add or ifg_8b2_add or ifg_8b_add
         or ifg_deficit or start_on_lane0 or status_local_fault_ctx
         or status_remote_fault_ctx or txhfifo_ralmost_empty
         or txhfifo_rdata_d1 or txhfifo_rempty or txhfifo_rstatus) begin
 
    next_state_enc = curr_state_enc;
 
    next_start_on_lane0 = start_on_lane0;
    next_ifg_deficit = ifg_deficit;
    next_ifg_4b_add = ifg_4b_add;
    next_ifg_8b_add = ifg_8b_add;
    next_ifg_8b2_add = ifg_8b2_add;
 
    next_eop = eop;
 
    next_xgxs_txd = {8{`IDLE}};
    next_xgxs_txc = 8'hff;
 
    txhfifo_ren = 1'b0;
 
    next_frame_available = frame_available;
 
    case (curr_state_enc)
 
        SM_IDLE:
          begin
 
              // Wait for frame to be available. There should be a least N bytes in the
              // data fifo or a crc in the control fifo. The N bytes in the data fifo
              // give time to the enqueue engine to calculate crc and write it to the
              // control fifo. If crc is already in control fifo we can start transmitting
              // with no concern. Transmission is inhibited if local or remote faults
              // are detected.
 
              if (ctrl_tx_enable_ctx && frame_available &&
                  !status_local_fault_ctx && !status_remote_fault_ctx) begin
 
                  txhfifo_ren = 1'b1;
                  next_state_enc = SM_PREAMBLE;
 
              end
              else begin
 
                  next_frame_available = !txhfifo_ralmost_empty;
                  next_ifg_4b_add = 1'b0;
 
              end
 
          end
 
        SM_PREAMBLE:
         begin
 
             // On reading SOP from fifo, send SFD and preamble characters
 
             if (txhfifo_rstatus[`TXSTATUS_SOP]) begin
 
                 next_xgxs_txd = {`SFD, {6{`PREAMBLE}}, `START};
                 next_xgxs_txc = 8'h01;
 
                 txhfifo_ren = 1'b1;
 
                 next_state_enc = SM_TX;
 
             end
             else begin
 
                 next_frame_available = 1'b0;
                 next_state_enc = SM_IDLE;
 
             end
 
 
             // Depending on deficit idle count calculations, add 4 bytes
             // or IFG or not. This will determine on which lane start the
             // next frame.
 
             if (ifg_4b_add) begin
                 next_start_on_lane0 = 1'b0;
             end
             else begin
                 next_start_on_lane0 = 1'b1;
             end
 
          end
 
        SM_TX:
          begin
 
              next_xgxs_txd = txhfifo_rdata_d1;
              next_xgxs_txc = 8'h00;
 
              txhfifo_ren = 1'b1;
 
 
              // Wait for EOP indication to be read from the fifo, then
              // transition to next state.
 
              if (txhfifo_rstatus[`TXSTATUS_EOP]) begin
 
                  txhfifo_ren = 1'b0;
                  next_frame_available = !txhfifo_ralmost_empty;
                  next_state_enc = SM_EOP;
 
              end
              else if (txhfifo_rempty || txhfifo_rstatus[`TXSTATUS_SOP]) begin
 
                  // Failure condition, we did not see EOP and there
                  // is no more data in fifo or SOP, force end of packet transmit.
 
                  next_state_enc = SM_TERM_FAIL;
 
              end
 
              next_eop[0] = txhfifo_rstatus[2:0] == 3'd1;
              next_eop[1] = txhfifo_rstatus[2:0] == 3'd2;
              next_eop[2] = txhfifo_rstatus[2:0] == 3'd3;
              next_eop[3] = txhfifo_rstatus[2:0] == 3'd4;
              next_eop[4] = txhfifo_rstatus[2:0] == 3'd5;
              next_eop[5] = txhfifo_rstatus[2:0] == 3'd6;
              next_eop[6] = txhfifo_rstatus[2:0] == 3'd7;
              next_eop[7] = txhfifo_rstatus[2:0] == 3'd0;
 
          end
 
        SM_EOP:
          begin
 
              // Insert TERMINATE character in correct lane depending on position
              // of EOP read from fifo. Also insert CRC read from control fifo.
 
              if (eop[0]) begin
                  next_xgxs_txd = {{2{`IDLE}}, `TERMINATE,
                                   crc32_tx[31:0], txhfifo_rdata_d1[7:0]};
                  next_xgxs_txc = 8'b11100000;
              end
 
              if (eop[1]) begin
                  next_xgxs_txd = {`IDLE, `TERMINATE,
                                   crc32_tx[31:0], txhfifo_rdata_d1[15:0]};
                  next_xgxs_txc = 8'b11000000;
              end
 
              if (eop[2]) begin
                  next_xgxs_txd = {`TERMINATE, crc32_tx[31:0], txhfifo_rdata_d1[23:0]};
                  next_xgxs_txc = 8'b10000000;
              end
 
              if (eop[3]) begin
                  next_xgxs_txd = {crc32_tx[31:0], txhfifo_rdata_d1[31:0]};
                  next_xgxs_txc = 8'b00000000;
              end
 
              if (eop[4]) begin
                  next_xgxs_txd = {crc32_tx[23:0], txhfifo_rdata_d1[39:0]};
                  next_xgxs_txc = 8'b00000000;
              end
 
              if (eop[5]) begin
                  next_xgxs_txd = {crc32_tx[15:0], txhfifo_rdata_d1[47:0]};
                  next_xgxs_txc = 8'b00000000;
              end
 
              if (eop[6]) begin
                  next_xgxs_txd = {crc32_tx[7:0], txhfifo_rdata_d1[55:0]};
                  next_xgxs_txc = 8'b00000000;
              end
 
              if (eop[7]) begin
                  next_xgxs_txd = {txhfifo_rdata_d1[63:0]};
                  next_xgxs_txc = 8'b00000000;
              end
 
              if (!frame_available) begin
 
                  // If there is not another frame ready to be transmitted, interface
                  // will go idle and idle deficit idle count calculation is irrelevant.
                  // Set deficit to 0.
 
                  next_ifg_deficit = 3'b0;
 
              end
              else begin
 
                  // Idle deficit count calculated based on number of "wasted" bytes
                  // between TERMINATE and alignment of next frame in LANE0.
 
                  next_ifg_deficit = ifg_deficit +
                                     {2'b0, eop[0] | eop[4]} +
                                     {1'b0, eop[1] | eop[5], 1'b0} +
                                     {1'b0, eop[2] | eop[6],
                                      eop[2] | eop[6]};
              end
 
              // IFG corrections based on deficit count and previous starting lane
              // Calculated based on following table:
              //
              //                 DIC=0          DIC=1          DIC=2          DIC=3
              //              -------------  -------------  -------------  -------------
              // PktLen       IFG      Next  IFG      Next  IFG      Next  IFG      Next
              // Modulus      Length   DIC   Length   DIC   Length   DIC   Length   DIC
              // -----------------------------------------------------------------------
              //    0           12      0      12      1      12      2      12      3
              //    1           11      1      11      2      11      3      15      0
              //    2           10      2      10      3      14      0      14      1
              //    3            9      3      13      0      13      1      13      2
              //
              //
              // In logic it translates into adding 4, 8, or 12 bytes of IFG relative
              // to LANE0.
              //   IFG and Add columns assume no deficit applied
              //   IFG+DIC and Add+DIC assume deficit must be applied
              //
              //                        Start lane 0       Start lane 4
              // EOP Pads IFG  IFG+DIC  Add   Add+DIC      Add    Add IFG
              // 0   3    11   15        8     12           12     16
              // 1   2    10   14        8     12           12     16
              // 2   1    9    13        8     12           12     16
              // 3   8    12   12        4     4            8      8
              // 4   7    11   15        4     8            8      12
              // 5   6    10   14        4     8            8      12
              // 6   5    9    13        4     8            8      12
              // 7   4    12   12        8     8            12     12
 
              if (!frame_available) begin
 
                  // If there is not another frame ready to be transmitted, interface
                  // will go idle and idle deficit idle count calculation is irrelevant.
 
                  next_ifg_4b_add = 1'b0;
                  next_ifg_8b_add = 1'b0;
                  next_ifg_8b2_add = 1'b0;
 
              end
              else if (next_ifg_deficit[2] == ifg_deficit[2]) begin
 
                  // Add 4 bytes IFG
 
                  next_ifg_4b_add = (eop[0] & !start_on_lane0) |
                                    (eop[1] & !start_on_lane0) |
                                    (eop[2] & !start_on_lane0) |
                                    (eop[3] & start_on_lane0) |
                                    (eop[4] & start_on_lane0) |
                                    (eop[5] & start_on_lane0) |
                                    (eop[6] & start_on_lane0) |
                                    (eop[7] & !start_on_lane0);
 
                  // Add 8 bytes IFG
 
                  next_ifg_8b_add = (eop[0]) |
                                    (eop[1]) |
                                    (eop[2]) |
                                    (eop[3] & !start_on_lane0) |
                                    (eop[4] & !start_on_lane0) |
                                    (eop[5] & !start_on_lane0) |
                                    (eop[6] & !start_on_lane0) |
                                    (eop[7]);
 
                  // Add another 8 bytes IFG
 
                  next_ifg_8b2_add = 1'b0;
 
              end
              else begin
 
                  // Add 4 bytes IFG
 
                  next_ifg_4b_add = (eop[0] & start_on_lane0) |
                                    (eop[1] & start_on_lane0) |
                                    (eop[2] & start_on_lane0) |
                                    (eop[3] &  start_on_lane0) |
                                    (eop[4] & !start_on_lane0) |
                                    (eop[5] & !start_on_lane0) |
                                    (eop[6] & !start_on_lane0) |
                                    (eop[7] & !start_on_lane0);
 
                  // Add 8 bytes IFG
 
                  next_ifg_8b_add = (eop[0]) |
                                    (eop[1]) |
                                    (eop[2]) |
                                    (eop[3] & !start_on_lane0) |
                                    (eop[4]) |
                                    (eop[5]) |
                                    (eop[6]) |
                                    (eop[7]);
 
                  // Add another 8 bytes IFG
 
                  next_ifg_8b2_add = (eop[0] & !start_on_lane0) |
                                     (eop[1] & !start_on_lane0) |
                                     (eop[2] & !start_on_lane0);
 
              end
 
              if (|eop[2:0]) begin
 
                  if (frame_available) begin
 
                      // Next state depends on number of IFG bytes to be inserted.
                      // Skip idle state if needed.
 
                      if (next_ifg_8b2_add) begin
                          next_state_enc = SM_IFG;
                      end
                      else if (next_ifg_8b_add) begin
                          next_state_enc = SM_IDLE;
                      end
                      else begin
                          txhfifo_ren = 1'b1;
                          next_state_enc = SM_PREAMBLE;
                      end
 
                  end
                  else begin
                      next_state_enc = SM_IFG;
                  end
              end
 
              if (|eop[7:3]) begin
                  next_state_enc = SM_TERM;
              end
 
          end
 
        SM_TERM:
          begin
 
              // Insert TERMINATE character in correct lane depending on position
              // of EOP read from fifo. Also insert CRC read from control fifo.
 
              if (eop[3]) begin
                  next_xgxs_txd = {{7{`IDLE}}, `TERMINATE};
                  next_xgxs_txc = 8'b11111111;
              end
 
              if (eop[4]) begin
                  next_xgxs_txd = {{6{`IDLE}}, `TERMINATE, crc32_tx[31:24]};
                  next_xgxs_txc = 8'b11111110;
              end
 
              if (eop[5]) begin
                  next_xgxs_txd = {{5{`IDLE}}, `TERMINATE, crc32_tx[31:16]};
                  next_xgxs_txc = 8'b11111100;
              end
 
              if (eop[6]) begin
                  next_xgxs_txd = {{4{`IDLE}}, `TERMINATE, crc32_tx[31:8]};
                  next_xgxs_txc = 8'b11111000;
              end
 
              if (eop[7]) begin
                  next_xgxs_txd = {{3{`IDLE}}, `TERMINATE, crc32_tx[31:0]};
                  next_xgxs_txc = 8'b11110000;
              end
 
              // Next state depends on number of IFG bytes to be inserted.
              // Skip idle state if needed.
 
              if (frame_available && !ifg_8b_add) begin
                  txhfifo_ren = 1'b1;
                  next_state_enc = SM_PREAMBLE;
              end
              else if (frame_available) begin
                  next_state_enc = SM_IDLE;
              end
              else begin
                  next_state_enc = SM_IFG;
              end
 
          end
 
        SM_TERM_FAIL:
          begin
 
              next_xgxs_txd = {{7{`IDLE}}, `TERMINATE};
              next_xgxs_txc = 8'b11111111;
              next_state_enc = SM_IFG;
 
          end
 
        SM_IFG:
          begin
 
              next_state_enc = SM_IDLE;
 
          end
 
        default:
          begin
              next_state_enc = SM_IDLE;
          end
 
    endcase
 
end
 
 
always @(/*AS*/crc32_d64 or next_txhfifo_wstatus or txhfifo_wen
         or txhfifo_wstatus) begin
 
    if (txhfifo_wen && txhfifo_wstatus[`TXSTATUS_SOP]) begin
        crc_data = 32'hffffffff;
    end
    else begin
        crc_data = crc32_d64;
    end
 
    if (next_txhfifo_wstatus[`TXSTATUS_EOP] && next_txhfifo_wstatus[2:0] != 3'b0) begin
        add_cnt = {11'b0, next_txhfifo_wstatus[2:0]};
    end
    else begin
        add_cnt = 14'd8;
    end
 
end
 
always @(/*AS*/byte_cnt or curr_state_pad or txdfifo_rdata
         or txdfifo_rempty or txdfifo_ren_d1 or txdfifo_rstatus
         or txhfifo_walmost_full) begin
 
    next_state_pad = curr_state_pad;
 
    next_txhfifo_wdata = txdfifo_rdata;
    next_txhfifo_wstatus = txdfifo_rstatus;
 
    txdfifo_ren = 1'b0;
    next_txhfifo_wen = 1'b0;
 
    case (curr_state_pad)
 
      SM_PAD_EQ: begin
 
 
          //---
          // If room availabe in hoding fifo and data available in
          // data fifo, transfer data words. If transmit state machine
          // is reading from fifo we can assume room will be available.
 
          if (!txhfifo_walmost_full) begin
 
              txdfifo_ren = !txdfifo_rempty;
 
          end
 
 
          //---
          // This logic dependent on read during previous cycle.
 
          if (txdfifo_ren_d1) begin
 
              next_txhfifo_wen = 1'b1;
 
              // On EOP, decide if padding is required for this packet.
 
              if (txdfifo_rstatus[`TXSTATUS_EOP]) begin
 
                  if (byte_cnt < 14'd60) begin
 
                      next_txhfifo_wstatus = `TXSTATUS_NONE;
                      txdfifo_ren = 1'b0;
                      next_state_pad = SM_PAD_PAD;
 
                  end
                  else if (byte_cnt == 14'd60 &&
                           (txdfifo_rstatus[2:0] == 3'd1 ||
                            txdfifo_rstatus[2:0] == 3'd2 ||
                            txdfifo_rstatus[2:0] == 3'd3)) begin
 
                      // Pad up to LANE3, keep the other 4 bytes for crc that will
                      // be inserted by dequeue engine.
 
                      next_txhfifo_wstatus[2:0] = 3'd4;
 
                      // Pad end bytes with zeros.
 
                      if (txdfifo_rstatus[2:0] == 3'd1)
                        next_txhfifo_wdata[31:8] = 24'b0;
                      if (txdfifo_rstatus[2:0] == 3'd2)
                        next_txhfifo_wdata[31:16] = 16'b0;
                      if (txdfifo_rstatus[2:0] == 3'd3)
                        next_txhfifo_wdata[31:24] = 8'b0;
 
                      txdfifo_ren = 1'b0;
 
                  end
                  else begin
 
                      txdfifo_ren = 1'b0;
 
                  end
 
              end
 
          end
 
      end
 
      SM_PAD_PAD: begin
 
          //---
          // Pad packet to 64 bytes by writting zeros to holding fifo.
 
          if (!txhfifo_walmost_full) begin
 
              next_txhfifo_wdata = 64'b0;
              next_txhfifo_wstatus = `TXSTATUS_NONE;
              next_txhfifo_wen = 1'b1;
 
              if (byte_cnt == 14'd60) begin
 
 
                  // Pad up to LANE3, keep the other 4 bytes for crc that will
                  // be inserted by dequeue engine.
 
                  next_txhfifo_wstatus[`TXSTATUS_EOP] = 1'b1;
                  next_txhfifo_wstatus[2:0] = 3'd4;
 
                  next_state_pad = SM_PAD_EQ;
 
              end
 
          end
 
      end
 
      default:
        begin
            next_state_pad = SM_PAD_EQ;
        end
 
    endcase
 
end
 
 
always @(posedge clk_xgmii_tx or negedge reset_xgmii_tx_n) begin
 
    if (reset_xgmii_tx_n == 1'b0) begin
 
        curr_state_pad <= SM_PAD_EQ;
 
        txdfifo_ren_d1 <= 1'b0;
 
        txhfifo_wdata <= 64'b0;
        txhfifo_wstatus <= 8'b0;
        txhfifo_wen <= 1'b0;
 
        byte_cnt <= 14'b0;
 
        shift_crc_data <= 64'b0;
        shift_crc_eop <= 4'b0;
        shift_crc_cnt <= 4'b0;
 
        crc32_d64 <= 32'b0;
        crc32_d8 <= 32'b0;
        crc32_tx <= 32'b0;
 
        frame_end <= 1'b0;
 
    end
    else begin
 
        curr_state_pad <= next_state_pad;
 
        txdfifo_ren_d1 <= txdfifo_ren;
 
        txhfifo_wdata <= next_txhfifo_wdata;
        txhfifo_wstatus <= next_txhfifo_wstatus;
        txhfifo_wen <= next_txhfifo_wen;
 
        frame_end <= 1'b0;
 
        //---
        // Reset byte count on SOP
 
        if (next_txhfifo_wen) begin
 
            if (next_txhfifo_wstatus[`TXSTATUS_SOP]) begin
 
                // Init byte count, 8-bytes + 4-bytes for CRC at the end of frame
 
                byte_cnt <= 14'd12;
 
            end
            else begin
 
                byte_cnt <= byte_cnt + add_cnt;
 
            end
 
            frame_end <= next_txhfifo_wstatus[`TXSTATUS_EOP];
 
        end
 
 
        //---
        // Calculate CRC as data is written to holding fifo. The holding fifo creates
        // a delay that allow the CRC calculation to complete before the end of the frame
        // is ready to be transmited.
 
        if (txhfifo_wen) begin
 
            crc32_d64 <= nextCRC32_D64(reverse_64b(txhfifo_wdata), crc_data);
 
        end
 
        if (txhfifo_wen && txhfifo_wstatus[`TXSTATUS_EOP]) begin
 
            // Last bytes calculated 8-bit at a time instead of 64-bit. Start
            // this process at the end of the frame.
 
            crc32_d8 <= crc32_d64;
 
            shift_crc_data <= txhfifo_wdata;
            shift_crc_cnt <= 4'd9;
 
            if (txhfifo_wstatus[2:0] == 3'b0) begin
              shift_crc_eop <= 4'd8;
            end
            else begin
                shift_crc_eop <= {1'b0, txhfifo_wstatus[2:0]};
            end
 
        end
        else if (shift_crc_eop != 4'b0) begin
 
            // Complete crc calculation 8-bit at a time until finished. This can
            // be 1 to 8 bytes long.
 
            crc32_d8 <= nextCRC32_D8(reverse_8b(shift_crc_data[7:0]), crc32_d8);
 
            shift_crc_data <= {8'b0, shift_crc_data[63:8]};
            shift_crc_eop <= shift_crc_eop - 4'd1;
 
        end
 
 
        //---
        // Update CRC register at the end of calculation. Always update after 8
        // cycles for deterministic results, even if a single byte was present in
        // last data word.
 
        if (shift_crc_cnt == 4'b1) begin
 
            crc32_tx <= ~reverse_32b(crc32_d8);
 
        end
        else begin
 
            shift_crc_cnt <= shift_crc_cnt - 4'd1;
 
        end
 
    end
 
end
 
endmodule

Line No.	Rev	Author	Line
1	2	antanguay	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// File name "tx_dequeue.v" ////`
4			`//// ////`
5			`//// This file is part of the "10GE MAC" project ////`
6			`//// http://www.opencores.org/cores/xge_mac/ ////`
7			`//// ////`
8			`//// Author(s): ////`
9			`//// - A. Tanguay (antanguay@opencores.org) ////`
10			`//// ////`
11			`//////////////////////////////////////////////////////////////////////`
12			`//// ////`
13			`//// Copyright (C) 2008 AUTHORS. All rights reserved. ////`
14			`//// ////`
15			`//// This source file may be used and distributed without ////`
16			`//// restriction provided that this copyright statement is not ////`
17			`//// removed from the file and that any derivative work contains ////`
18			`//// the original copyright notice and the associated disclaimer. ////`
19			`//// ////`
20			`//// This source file is free software; you can redistribute it ////`
21			`//// and/or modify it under the terms of the GNU Lesser General ////`
22			`//// Public License as published by the Free Software Foundation; ////`
23			`//// either version 2.1 of the License, or (at your option) any ////`
24			`//// later version. ////`
25			`//// ////`
26			`//// This source is distributed in the hope that it will be ////`
27			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
28			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
29			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
30			`//// details. ////`
31			`//// ////`
32			`//// You should have received a copy of the GNU Lesser General ////`
33			`//// Public License along with this source; if not, download it ////`
34			`//// from http://www.opencores.org/lgpl.shtml ////`
35			`//// ////`
36			`//////////////////////////////////////////////////////////////////////`
37
38
39			`include "defines.v"
40
41			`module tx_dequeue(/AUTOARG/`
42			`// Outputs`
43	12	antanguay	`txdfifo_ren, txhfifo_ren, txhfifo_wdata, txhfifo_wstatus,`
44			`txhfifo_wen, xgmii_txd, xgmii_txc, status_txdfifo_udflow_tog,`
45	24	antanguay	`txsfifo_wen, txsfifo_wdata,`
46	2	antanguay	`// Inputs`
47	12	antanguay	`clk_xgmii_tx, reset_xgmii_tx_n, ctrl_tx_enable_ctx,`
48			`status_local_fault_ctx, status_remote_fault_ctx, txdfifo_rdata,`
49			`txdfifo_rstatus, txdfifo_rempty, txdfifo_ralmost_empty,`
50			`txhfifo_rdata, txhfifo_rstatus, txhfifo_rempty,`
51	2	antanguay	`txhfifo_ralmost_empty, txhfifo_wfull, txhfifo_walmost_full`
52			`);`
53			`include "CRC32_D64.v"
54			`include "CRC32_D8.v"
55			`include "utils.v"
56
57			`input clk_xgmii_tx;`
58			`input reset_xgmii_tx_n;`
59
60			`input ctrl_tx_enable_ctx;`
61	20	antanguay
62	2	antanguay	`input status_local_fault_ctx;`
63			`input status_remote_fault_ctx;`
64	20	antanguay
65	2	antanguay	`input [63:0] txdfifo_rdata;`
66			`input [7:0] txdfifo_rstatus;`
67			`input txdfifo_rempty;`
68			`input txdfifo_ralmost_empty;`
69
70			`input [63:0] txhfifo_rdata;`
71			`input [7:0] txhfifo_rstatus;`
72			`input txhfifo_rempty;`
73			`input txhfifo_ralmost_empty;`
74
75			`input txhfifo_wfull;`
76			`input txhfifo_walmost_full;`
77
78			`output txdfifo_ren;`
79
80			`output txhfifo_ren;`
81
82			`output [63:0] txhfifo_wdata;`
83			`output [7:0] txhfifo_wstatus;`
84	20	antanguay	`output txhfifo_wen;`
85	2	antanguay
86			`output [63:0] xgmii_txd;`
87			`output [7:0] xgmii_txc;`
88
89			`output status_txdfifo_udflow_tog;`
90
91	24	antanguay	`output txsfifo_wen;`
92			`output [13:0] txsfifo_wdata;`
93	2	antanguay
94
95			`/AUTOREG/`
96			`// Beginning of automatic regs (for this module's undeclared outputs)`
97			`reg status_txdfifo_udflow_tog;`
98			`reg txdfifo_ren;`
99			`reg txhfifo_ren;`
100			`reg [63:0] txhfifo_wdata;`
101			`reg txhfifo_wen;`
102			`reg [7:0] txhfifo_wstatus;`
103	24	antanguay	`reg [13:0] txsfifo_wdata;`
104			`reg txsfifo_wen;`
105	2	antanguay	`reg [7:0] xgmii_txc;`
106			`reg [63:0] xgmii_txd;`
107			`// End of automatics`
108
109			`/AUTOWIRE/`
110
111
112			`reg [63:0] xgxs_txd;`
113			`reg [7:0] xgxs_txc;`
114
115			`reg [63:0] next_xgxs_txd;`
116			`reg [7:0] next_xgxs_txc;`
117
118	10	antanguay	`reg [2:0] curr_state_enc;`
119			`reg [2:0] next_state_enc;`
120	2	antanguay
121	10	antanguay	`reg [0:0] curr_state_pad;`
122			`reg [0:0] next_state_pad;`
123	2	antanguay
124			`reg start_on_lane0;`
125			`reg next_start_on_lane0;`
126
127			`reg [2:0] ifg_deficit;`
128			`reg [2:0] next_ifg_deficit;`
129
130			`reg ifg_4b_add;`
131			`reg next_ifg_4b_add;`
132
133			`reg ifg_8b_add;`
134			`reg next_ifg_8b_add;`
135
136			`reg ifg_8b2_add;`
137			`reg next_ifg_8b2_add;`
138
139	6	antanguay	`reg [7:0] eop;`
140			`reg [7:0] next_eop;`
141
142	2	antanguay	`reg [63:32] xgxs_txd_barrel;`
143			`reg [7:4] xgxs_txc_barrel;`
144
145			`reg [63:0] txhfifo_rdata_d1;`
146
147	26	antanguay	`reg [13:0] add_cnt;`
148	2	antanguay	`reg [13:0] byte_cnt;`
149
150			`reg [31:0] crc32_d64;`
151			`reg [31:0] crc32_d8;`
152			`reg [31:0] crc32_tx;`
153
154			`reg [63:0] shift_crc_data;`
155	6	antanguay	`reg [3:0] shift_crc_eop;`
156			`reg [3:0] shift_crc_cnt;`
157	2	antanguay
158			`reg [31:0] crc_data;`
159
160			`reg frame_available;`
161			`reg next_frame_available;`
162
163			`reg [63:0] next_txhfifo_wdata;`
164			`reg [7:0] next_txhfifo_wstatus;`
165	20	antanguay	`reg next_txhfifo_wen;`
166	2	antanguay
167	6	antanguay	`reg txdfifo_ren_d1;`
168
169	23	antanguay	`reg frame_end;`
170
171	2	antanguay	`parameter [2:0]`
172			`SM_IDLE = 3'd0,`
173			`SM_PREAMBLE = 3'd1,`
174			`SM_TX = 3'd2,`
175			`SM_EOP = 3'd3,`
176			`SM_TERM = 3'd4,`
177			`SM_TERM_FAIL = 3'd5,`
178			`SM_IFG = 3'd6;`
179
180	6	antanguay	`parameter [0:0]`
181	10	antanguay	`SM_PAD_EQ = 1'd0,`
182			`SM_PAD_PAD = 1'd1;`
183	2	antanguay
184
185			`//---`
186			`// RC layer`
187
188			`always @(posedge clk_xgmii_tx or negedge reset_xgmii_tx_n) begin`
189
190			`if (reset_xgmii_tx_n == 1'b0) begin`
191
192			xgmii_txd <= {8{`IDLE}};
193			`xgmii_txc <= 8'hff;`
194
195			`end`
196			`else begin`
197
198
199			`//---`
200			`// RC Layer, insert local or remote fault messages based on status`
201			`// of fault state-machine`
202
203			`if (status_local_fault_ctx) begin`
204
205			`// If local fault detected, send remote fault message to`
206			`// link partner`
207	20	antanguay
208	2	antanguay	xgmii_txd <= {`REMOTE_FAULT, 8'h0, 8'h0, `SEQUENCE,
209			`REMOTE_FAULT, 8'h0, 8'h0, `SEQUENCE};
210			`xgmii_txc <= {4'b0001, 4'b0001};`
211			`end`
212			`else if (status_remote_fault_ctx) begin`
213
214			`// If remote fault detected, inhibit transmission and send`
215			`// idle codes`
216	20	antanguay
217	2	antanguay	xgmii_txd <= {8{`IDLE}};
218			`xgmii_txc <= 8'hff;`
219			`end`
220			`else begin`
221			`xgmii_txd <= xgxs_txd;`
222			`xgmii_txc <= xgxs_txc;`
223			`end`
224			`end`
225
226			`end`
227
228
229			`always @(posedge clk_xgmii_tx or negedge reset_xgmii_tx_n) begin`
230
231			`if (reset_xgmii_tx_n == 1'b0) begin`
232
233	10	antanguay	`curr_state_enc <= SM_IDLE;`
234	2	antanguay
235			`start_on_lane0 <= 1'b1;`
236			`ifg_deficit <= 3'b0;`
237			`ifg_4b_add <= 1'b0;`
238			`ifg_8b_add <= 1'b0;`
239			`ifg_8b2_add <= 1'b0;`
240
241	6	antanguay	`eop <= 8'b0;`
242
243	2	antanguay	`txhfifo_rdata_d1 <= 64'b0;`
244
245			xgxs_txd_barrel <= {4{`IDLE}};
246			`xgxs_txc_barrel <= 4'hf;`
247
248			`frame_available <= 1'b0;`
249
250			xgxs_txd <= {8{`IDLE}};
251			`xgxs_txc <= 8'hff;`
252
253			`status_txdfifo_udflow_tog <= 1'b0;`
254
255	24	antanguay	`txsfifo_wen <= 1'b0;`
256			`txsfifo_wdata <= 14'b0;`
257	23	antanguay
258	2	antanguay	`end`
259			`else begin`
260
261	10	antanguay	`curr_state_enc <= next_state_enc;`
262	2	antanguay
263			`start_on_lane0 <= next_start_on_lane0;`
264			`ifg_deficit <= next_ifg_deficit;`
265			`ifg_4b_add <= next_ifg_4b_add;`
266			`ifg_8b_add <= next_ifg_8b_add;`
267			`ifg_8b2_add <= next_ifg_8b2_add;`
268
269	6	antanguay	`eop <= next_eop;`
270
271	2	antanguay	`txhfifo_rdata_d1 <= txhfifo_rdata;`
272
273			`xgxs_txd_barrel <= next_xgxs_txd[63:32];`
274			`xgxs_txc_barrel <= next_xgxs_txc[7:4];`
275
276			`frame_available <= next_frame_available;`
277
278	24	antanguay	`txsfifo_wen <= 1'b0;`
279			`txsfifo_wdata <= byte_cnt;`
280
281	2	antanguay	`//---`
282			`// Barrel shifter. Previous stage always align packet with LANE0.`
283			`// This stage allow us to shift packet to align with LANE4 if needed`
284			`// for correct inter frame gap (IFG).`
285
286			`if (next_start_on_lane0) begin`
287
288			`xgxs_txd <= next_xgxs_txd;`
289			`xgxs_txc <= next_xgxs_txc;`
290
291			`end`
292			`else begin`
293
294			`xgxs_txd <= {next_xgxs_txd[31:0], xgxs_txd_barrel};`
295			`xgxs_txc <= {next_xgxs_txc[3:0], xgxs_txc_barrel};`
296
297			`end`
298
299			`//---`
300			`// FIFO errors, used to generate interrupts.`
301	20	antanguay
302	2	antanguay	`if (txdfifo_ren && txdfifo_rempty) begin`
303			`status_txdfifo_udflow_tog <= ~status_txdfifo_udflow_tog;`
304			`end`
305
306	23	antanguay	`//---`
307			`// Frame count and size`
308
309			`if (frame_end) begin`
310	24	antanguay	`txsfifo_wen <= 1'b1;`
311	23	antanguay	`end`
312
313	2	antanguay	`end`
314
315			`end`
316
317	10	antanguay	`always @(/AS/crc32_tx or ctrl_tx_enable_ctx or curr_state_enc or eop`
318	2	antanguay	`or frame_available or ifg_4b_add or ifg_8b2_add or ifg_8b_add`
319			`or ifg_deficit or start_on_lane0 or status_local_fault_ctx`
320	21	antanguay	`or status_remote_fault_ctx or txhfifo_ralmost_empty`
321			`or txhfifo_rdata_d1 or txhfifo_rempty or txhfifo_rstatus) begin`
322	2	antanguay
323	10	antanguay	`next_state_enc = curr_state_enc;`
324	2	antanguay
325			`next_start_on_lane0 = start_on_lane0;`
326			`next_ifg_deficit = ifg_deficit;`
327			`next_ifg_4b_add = ifg_4b_add;`
328			`next_ifg_8b_add = ifg_8b_add;`
329			`next_ifg_8b2_add = ifg_8b2_add;`
330
331	6	antanguay	`next_eop = eop;`
332
333	2	antanguay	next_xgxs_txd = {8{`IDLE}};
334			`next_xgxs_txc = 8'hff;`
335
336			`txhfifo_ren = 1'b0;`
337
338			`next_frame_available = frame_available;`
339
340	10	antanguay	`case (curr_state_enc)`
341	2	antanguay
342			`SM_IDLE:`
343			`begin`
344
345			`// Wait for frame to be available. There should be a least N bytes in the`
346			`// data fifo or a crc in the control fifo. The N bytes in the data fifo`
347			`// give time to the enqueue engine to calculate crc and write it to the`
348			`// control fifo. If crc is already in control fifo we can start transmitting`
349			`// with no concern. Transmission is inhibited if local or remote faults`
350			`// are detected.`
351
352			`if (ctrl_tx_enable_ctx && frame_available &&`
353	20	antanguay	`!status_local_fault_ctx && !status_remote_fault_ctx) begin`
354	2	antanguay
355			`txhfifo_ren = 1'b1;`
356	10	antanguay	`next_state_enc = SM_PREAMBLE;`
357	2	antanguay
358			`end`
359			`else begin`
360
361			`next_frame_available = !txhfifo_ralmost_empty;`
362			`next_ifg_4b_add = 1'b0;`
363
364			`end`
365
366			`end`
367
368			`SM_PREAMBLE:`
369			`begin`
370
371			`// On reading SOP from fifo, send SFD and preamble characters`
372
373	6	antanguay	if (txhfifo_rstatus[`TXSTATUS_SOP]) begin
374	2	antanguay
375			next_xgxs_txd = {`SFD, {6{`PREAMBLE}}, `START};
376			`next_xgxs_txc = 8'h01;`
377
378	6	antanguay	`txhfifo_ren = 1'b1;`
379	2	antanguay
380	10	antanguay	`next_state_enc = SM_TX;`
381	2	antanguay
382	6	antanguay	`end`
383			`else begin`
384
385			`next_frame_available = 1'b0;`
386	10	antanguay	`next_state_enc = SM_IDLE;`
387	6	antanguay
388			`end`
389
390
391	2	antanguay	`// Depending on deficit idle count calculations, add 4 bytes`
392			`// or IFG or not. This will determine on which lane start the`
393			`// next frame.`
394	20	antanguay
395	2	antanguay	`if (ifg_4b_add) begin`
396			`next_start_on_lane0 = 1'b0;`
397			`end`
398			`else begin`
399			`next_start_on_lane0 = 1'b1;`
400			`end`
401
402			`end`
403
404			`SM_TX:`
405			`begin`
406
407			`next_xgxs_txd = txhfifo_rdata_d1;`
408			`next_xgxs_txc = 8'h00;`
409
410			`txhfifo_ren = 1'b1;`
411
412
413			`// Wait for EOP indication to be read from the fifo, then`
414			`// transition to next state.`
415
416	6	antanguay	if (txhfifo_rstatus[`TXSTATUS_EOP]) begin
417	20	antanguay
418	2	antanguay	`txhfifo_ren = 1'b0;`
419			`next_frame_available = !txhfifo_ralmost_empty;`
420	10	antanguay	`next_state_enc = SM_EOP;`
421	6	antanguay
422	2	antanguay	`end`
423	6	antanguay	else if (txhfifo_rempty \|\| txhfifo_rstatus[`TXSTATUS_SOP]) begin
424	2	antanguay
425			`// Failure condition, we did not see EOP and there`
426	6	antanguay	`// is no more data in fifo or SOP, force end of packet transmit.`
427	2	antanguay
428	10	antanguay	`next_state_enc = SM_TERM_FAIL;`
429	2	antanguay
430			`end`
431
432	6	antanguay	`next_eop[0] = txhfifo_rstatus[2:0] == 3'd1;`
433			`next_eop[1] = txhfifo_rstatus[2:0] == 3'd2;`
434			`next_eop[2] = txhfifo_rstatus[2:0] == 3'd3;`
435			`next_eop[3] = txhfifo_rstatus[2:0] == 3'd4;`
436			`next_eop[4] = txhfifo_rstatus[2:0] == 3'd5;`
437			`next_eop[5] = txhfifo_rstatus[2:0] == 3'd6;`
438			`next_eop[6] = txhfifo_rstatus[2:0] == 3'd7;`
439			`next_eop[7] = txhfifo_rstatus[2:0] == 3'd0;`
440	20	antanguay
441	2	antanguay	`end`
442
443			`SM_EOP:`
444			`begin`
445
446			`// Insert TERMINATE character in correct lane depending on position`
447			`// of EOP read from fifo. Also insert CRC read from control fifo.`
448
449	6	antanguay	`if (eop[0]) begin`
450	20	antanguay	next_xgxs_txd = {{2{`IDLE}}, `TERMINATE,
451	2	antanguay	`crc32_tx[31:0], txhfifo_rdata_d1[7:0]};`
452			`next_xgxs_txc = 8'b11100000;`
453			`end`
454
455	6	antanguay	`if (eop[1]) begin`
456	2	antanguay	next_xgxs_txd = {`IDLE, `TERMINATE,
457			`crc32_tx[31:0], txhfifo_rdata_d1[15:0]};`
458			`next_xgxs_txc = 8'b11000000;`
459			`end`
460
461	6	antanguay	`if (eop[2]) begin`
462	2	antanguay	next_xgxs_txd = {`TERMINATE, crc32_tx[31:0], txhfifo_rdata_d1[23:0]};
463			`next_xgxs_txc = 8'b10000000;`
464			`end`
465
466	6	antanguay	`if (eop[3]) begin`
467	2	antanguay	`next_xgxs_txd = {crc32_tx[31:0], txhfifo_rdata_d1[31:0]};`
468			`next_xgxs_txc = 8'b00000000;`
469			`end`
470
471	6	antanguay	`if (eop[4]) begin`
472	2	antanguay	`next_xgxs_txd = {crc32_tx[23:0], txhfifo_rdata_d1[39:0]};`
473			`next_xgxs_txc = 8'b00000000;`
474			`end`
475
476	6	antanguay	`if (eop[5]) begin`
477	2	antanguay	`next_xgxs_txd = {crc32_tx[15:0], txhfifo_rdata_d1[47:0]};`
478			`next_xgxs_txc = 8'b00000000;`
479			`end`
480
481	6	antanguay	`if (eop[6]) begin`
482	2	antanguay	`next_xgxs_txd = {crc32_tx[7:0], txhfifo_rdata_d1[55:0]};`
483			`next_xgxs_txc = 8'b00000000;`
484			`end`
485
486	6	antanguay	`if (eop[7]) begin`
487	2	antanguay	`next_xgxs_txd = {txhfifo_rdata_d1[63:0]};`
488			`next_xgxs_txc = 8'b00000000;`
489			`end`
490
491			`if (!frame_available) begin`
492
493			`// If there is not another frame ready to be transmitted, interface`
494			`// will go idle and idle deficit idle count calculation is irrelevant.`
495			`// Set deficit to 0.`
496	20	antanguay
497	2	antanguay	`next_ifg_deficit = 3'b0;`
498
499			`end`
500			`else begin`

Browse

Tools

Subversion Repositories xge_mac

[/] [xge_mac/] [trunk/] [rtl/] [verilog/] [tx_dequeue.v] - Blame information for rev 26