URL https://opencores.org/ocsvn/turbo8051/turbo8051/trunk
Subversion Repositories turbo8051

[/] [turbo8051/] [trunk/] [rtl/] [gmac/] [mac/] [g_rx_fsm.v] - Blame information for rev 61

Go to most recent revision | Details | Compare with Previous | View Log

//////////////////////////////////////////////////////////////////////
////                                                              ////
////  Tubo 8051 cores MAC Interface Module                        ////
////                                                              ////
////  This file is part of the Turbo 8051 cores project           ////
////  http://www.opencores.org/cores/turbo8051/                   ////
////                                                              ////
////  Description                                                 ////
////  Turbo 8051 definitions.                                     ////
////                                                              ////
////  To Do:                                                      ////
////    nothing                                                   ////
////                                                              ////
////  Author(s):                                                  ////
////      - Dinesh Annayya, dinesha@opencores.org                 ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
////                                                              ////
//// Copyright (C) 2000 Authors and OPENCORES.ORG                 ////
////                                                              ////
//// 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                     ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
/***************************************************************
 Description:
 
 rx_fsm.v: This verilog file is the receive state machine for the MAC
 block. It receives nibbles from rmii block. It assembles
 double words from bytes. Generates writes to Receive FIFO
 Removes padding and generates appropriate signals to the
 CRC and Address Filtering block. It also generates the necessary
 signals to generate status for every frame.
 
 ***************************************************************/
/************** MODULE DECLARATION ****************************/
//`timescale 1ns/100ps
module g_rx_fsm(
                // Status information to Applications
                rx_sts_vld,
                rx_sts_bytes_rcvd,
                rx_sts_large_pkt,
                rx_sts_lengthfield_err,
                rx_sts_crc_err,
                rx_sts_runt_pkt_rcvd,
                rx_sts_rx_overrun,
                rx_sts_frm_length_err,
                rx_sts_len_mismatch,
                // Data Signals to Fifo Management Block
                clr_rx_error_from_rx_fsm,
                rx2ap_rx_fsm_wrt,
                rx2ap_rx_fsm_dt,
                // Fifo Control Signal to Fifo Management Block
                rx2ap_commit_write,
                rx2ap_rewind_write,
                // To address filtering block
                //commit
                commit_write_done,
 
                // Global Signals 
                reset_n,
                phy_rx_clk,
                // Signals from Mii/Rmii block for Receive data 
                mi2rx_strt_rcv,
                mi2rx_rcv_vld,
                mi2rx_rx_byte,
                mi2rx_end_rcv,
                mi2rx_extend,
                mi2rx_frame_err,
                mi2rx_end_frame,
                // Rx fifo management signal to indicate overrun
                rx_fifo_full,
                ap2rx_rx_fifo_err,
                // Signal from CRC check block
                rc2rx_crc_ok,
                // Signals from Config Management Block
                cf2rx_max_pkt_sz,
                cf2rx_rx_ch_en,
                cf2rx_strp_pad_en,
                cf2rx_snd_crc,
                cf2rx_rcv_runt_pkt_en,
                cf2rx_gigabit_xfr,
      //A200 change Port added for crs based flow control
      phy_crs
 
                );
 
 
parameter MIN_FRM_SIZE = 6'h2e        ;
  /******* INPUT & OUTPUT DECLARATIONS *************************/
  output        rx_sts_vld;                    // Receive status is available for the application
  output [15:0] rx_sts_bytes_rcvd;
  output        rx_sts_large_pkt;
  output        rx_sts_lengthfield_err;
  output        rx_sts_crc_err;
  output        rx_sts_runt_pkt_rcvd;
  output        rx_sts_rx_overrun;
  output        rx_sts_frm_length_err;
  output        rx_sts_len_mismatch;
 
  output        rx2ap_rx_fsm_wrt;              // Receive Fifo Write
  output [8:0]   rx2ap_rx_fsm_dt;               // This is 32 bit assembled receive data 
                                               // with EOP and valid bytes information in it.
  output        rx2ap_commit_write;            // This is to RX fifo MGMT to indicate 
                                               // that the current packet 
                                               // has to be sent to application
  output        rx2ap_rewind_write;            // This indicates the previous packet 
                                               // in the FIFO has a error
                                               // Ignore the packet and restart from the
                                               // end of previous packet
  output    clr_rx_error_from_rx_fsm;
  output    commit_write_done;
 
  input         reset_n;                               // reset from mac application interface
  input         phy_rx_clk;                    // Reference clock used for RX 
 
  input         mi2rx_strt_rcv;                // Receive data from the PHY
  input         mi2rx_rcv_vld;                 // Received nibble is valid
  input [7:0]    mi2rx_rx_byte;                 // Rx nibble from the RMII/MII block
  input         mi2rx_end_rcv;                 // This is provided by the RMII/MII 
                                               // block to indicate
                                               // end of receieve
  input         mi2rx_frame_err;
  input         mi2rx_end_frame;
  input         rx_fifo_full;
  input         ap2rx_rx_fifo_err;             // Receive error generated by the 
                                               // RX FIFO MGMT block
 
  input         rc2rx_crc_ok;                  // CRC of the receiving packet is OK. 
                                               // Generated by CRC block
 
  input [15:0]  cf2rx_max_pkt_sz;              // max packet size
 
  input         cf2rx_rx_ch_en;                // Receive Enabled
  input         cf2rx_strp_pad_en;             // Do not Append padding after the data
  input         cf2rx_snd_crc;                 // Append CRC to the data 
                                               // ( This automatically means padding
                                               // will be enabled)
  input         cf2rx_rcv_runt_pkt_en;         // Receive needs to receive
  input         cf2rx_gigabit_xfr;
  input         mi2rx_extend;
 
  //A200 change Port added for crs based flow control
  input  phy_crs;
 
 
  /******* WIRE & REG DECLARATION FOR INPUT AND OUTPUTS ********/
  reg           rx2ap_commit_write;
  reg           rx2ap_rewind_write;
  reg [8:0]      rx2ap_rx_fsm_dt;
  reg           rx2ap_rx_fsm_wrt;
  wire [31:0]    rx_sts_dt;
  reg [31:0]     rx_sts;
 
  /*** REG & WIRE DECLARATIONS FOR LOCAL SIGNALS ***************/
  reg           commit_write;
  reg           rewind_write;
  wire          look_at_length_field;
  reg           send_crc;
  reg           rcv_pad_data;
  reg           first_dword;
  wire [15:0]    inc_rcv_byte_count;
  reg [15:0]     rcv_byte_count;
  reg           reset_tmp_count;
  reg           ld_length_byte_1,ld_length_byte_2;
  reg           set_crc_error;
  reg           set_byte_allgn_error;
  reg           rx_sts_vld,e_rx_sts_vld;
  reg           padding_needed;
  reg           dec_data_len;
  reg           dec_pad_len;
  reg           gen_eop;
  reg           set_frm_lngth_error;
  reg           set_incomplete_frm;
  reg           byte_boundary;
  reg           error;
  reg           error_seen;
  reg           commit_write_done;
  reg           check_padding;
  reg           check_padding_in;
  reg [2:0]      padding_len_reg;
  reg [15:0]     rcv_length_reg;
  reg [15:0]     length_counter;
 
  reg [18:0]     rx_fsm_cur_st;
  reg [18:0]     rx_fsm_nxt_st;
  reg           crc_stat_reg;
  reg           rx_runt_pkt_reg;
  reg           large_pkt_reg;
  reg           rx_fifo_overrun_reg;
  reg           frm_length_err_reg;
  reg [2:0]      crc_count;
  reg           inc_shift_counter;
  reg           send_data_to_fifo;
  wire          send_runt_packet;
  reg [2:0]      shift_counter;
  reg [2:0]      bytes_to_fifo;
  reg [7:0]      buf_latch4,buf_latch3,buf_latch2,buf_latch1,buf_latch0;
  wire          ld_buf,ld_buf1,ld_buf2,ld_buf3,ld_buf4;
  reg           lengthfield_error;
  reg           lengthfield_err_reg;
  reg           addr_stat_chk;
  reg           clr_rx_error_from_rx_fsm;
 
  wire [15:0]    adj_rcv_length_reg;
  wire [15:0]    adj_rcv_byte_count;
  wire [15:0]    adj_cf2rx_max_pkt_sz;
  reg            set_tag1_flag, set_tag2_flag;
 
  parameter     rx_fsm_idle_st=               19'b0000000000000000000,
                rx_fsm_chkdestad_nib1_st =    19'b0000000000000000001,
                rx_fsm_lk4srcad_nib1_st =     19'b0000000000000000010,
                rx_fsm_lk4len_byte1_st =      19'b0000000000000000100,
                rx_fsm_lk4len_byte2_st =      19'b0000000000000001000,
                rx_fsm_getdt_nib1_st =        19'b0000000000000010000,
                rx_fsm_getpaddt_nib1_st =     19'b0000000000000100000,
                rx_fsm_updstat_st =           19'b0000000000001000000,
                rx_fsm_chkval_st =            19'b0000000000010000000,
                rx_fsm_extend_st =            19'b0000000100000000000;
 
  /***************** WIRE ASSIGNMENTS *************************/
  wire [6:0]     dec_pad_length;
  wire [15:0]    inc_length_counter;
  wire          rx_overrun_error;
  wire          commit_condition;
 
//COMMIT_WRITE CONDITION
assign commit_condition = ((inc_rcv_byte_count[14:0] == 15'd65)&& !commit_write_done );
 
 
 
  /******** SEQUENTIAL LOGIC **********************************/
  half_dup_dble_reg U_dble_reg1 (
                        //outputs
                        .sync_out_pulse(rx_ch_en),
                        //inputs
                        .in_pulse(cf2rx_rx_ch_en),
                        .dest_clk(phy_rx_clk),
                        .reset_n(reset_n)
                        );
 
  // ap2rx_rx_fifo_err signal is generated in rx_clk domain
  assign        rx_overrun_error = ap2rx_rx_fifo_err;
 
  reg           rx_sts_vld_delayed;
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          rx_sts <= 32'b0;
          rx_sts_vld <= 1'b0;
          rx_sts_vld_delayed <= 1'b0;
        end
      else
        begin
          rx_sts_vld <= rx_sts_vld_delayed;
          rx_sts_vld_delayed <= e_rx_sts_vld;
          if (e_rx_sts_vld)
            rx_sts <= rx_sts_dt;
        end
    end
 
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          rx_fsm_cur_st <= rx_fsm_idle_st;
          check_padding <= 1'b0;
        end
      else
        begin
          rx_fsm_cur_st <= rx_fsm_nxt_st;
          check_padding <= check_padding_in;
        end
    end
  reg first_byte_seen;
 
 
  always @(posedge phy_rx_clk
           or negedge reset_n)
      if(!reset_n)
        first_byte_seen <= 1'b0;
      else if(mi2rx_strt_rcv)
        first_byte_seen <= 1'b1;
      else if(mi2rx_rcv_vld)
        first_byte_seen <= 1'b0;
 
 
 
// adjust rcv_length reg for packet sizes < 64 bytes
assign adj_rcv_length_reg =   (rcv_length_reg < 8'h2E) ? 8'h2E : rcv_length_reg;
 
// subtr 18 bytes (sa + da + fcs + t/l)
assign adj_rcv_byte_count = rcv_byte_count - 8'd18;
 
// configured max packet size should be 16'd1518.
assign adj_cf2rx_max_pkt_sz = cf2rx_max_pkt_sz;
 
 
 
  // Following state machine is to receive nibbles from the RMII/MII
  // block and packetize them to 32 bits with information of EOP and 
  // valid bytes. It also discards packets which are less than minimum
  // frame size. It performs Address validity and Data validity.
  always @(rx_fsm_cur_st or mi2rx_strt_rcv or rx_ch_en or cf2rx_strp_pad_en
           or cf2rx_snd_crc or look_at_length_field
           or mi2rx_rcv_vld or first_dword or rc2rx_crc_ok
           or mi2rx_end_rcv or mi2rx_rx_byte or mi2rx_extend
           or inc_length_counter or rcv_length_reg or commit_write_done
           or crc_count or shift_counter or bytes_to_fifo
            or cf2rx_rcv_runt_pkt_en
           or inc_rcv_byte_count or send_runt_packet
           or rcv_byte_count or first_dword
           or commit_condition or rx_fifo_full or ap2rx_rx_fifo_err )
    begin
      rx_fsm_nxt_st = rx_fsm_cur_st;
      set_tag1_flag = 1'b0;
      set_tag2_flag = 1'b0;
      reset_tmp_count = 1'b0;
      ld_length_byte_1 = 1'b0;
      ld_length_byte_2 = 1'b0;
      dec_data_len = 1'b0;
      dec_pad_len = 1'b0;
      commit_write = 1'b0;
      rewind_write = 1'b0;
      e_rx_sts_vld = 1'b0;
      set_crc_error = 1'b0;
      check_padding_in = 1'b0;
      set_byte_allgn_error = 1'b0;
      set_incomplete_frm = 1'b0;
      set_frm_lngth_error = 1'b0;
      gen_eop = 1'b0;
      error = 1'b0;
      byte_boundary= 1'b0;
      send_crc = 1'b0;
      rcv_pad_data = 1'b0;
      inc_shift_counter = 1'b0;
      send_data_to_fifo = 1'b0;
      lengthfield_error = 1'b0;
      addr_stat_chk = 1'b0;
      clr_rx_error_from_rx_fsm = 1'b0;
 
 
      casex(rx_fsm_cur_st)       // synopsys parallel_case full_case
        rx_fsm_idle_st:
          // Waiting for packet from mii block
          // Continues accepting data only if
          // receive has been enabled
          begin
            if(ap2rx_rx_fifo_err)
                begin
                   clr_rx_error_from_rx_fsm = 1'b1;
                   rx_fsm_nxt_st = rx_fsm_idle_st;
                end
            else if (rx_fifo_full)
              rx_fsm_nxt_st = rx_fsm_idle_st;
            else if(mi2rx_strt_rcv && rx_ch_en )
              rx_fsm_nxt_st = rx_fsm_chkdestad_nib1_st;
            else
              rx_fsm_nxt_st = rx_fsm_idle_st;
          end
 
        rx_fsm_chkdestad_nib1_st:
          begin
            // collecting the nibbles of destination
            // address
            if(ap2rx_rx_fifo_err)
              begin
                rewind_write = 1'b1;
                rx_fsm_nxt_st = rx_fsm_idle_st;
              end
            else if(mi2rx_end_rcv)
              begin
                if(cf2rx_rcv_runt_pkt_en)
                  begin
                    rx_fsm_nxt_st = rx_fsm_chkval_st;
                    commit_write = 1'b1;
                  end
                else
                  begin
                    rx_fsm_nxt_st = rx_fsm_idle_st;
                    if (rcv_byte_count[2:0] > 5)
                      rewind_write = 1'b1;
                  end
              end // if (mi2rx_end_rcv)
 
            else if(mi2rx_rcv_vld && inc_rcv_byte_count[14:0] == 15'd6)
              begin
                       rx_fsm_nxt_st = rx_fsm_lk4srcad_nib1_st;
              end
            else
              begin
                rx_fsm_nxt_st = rx_fsm_chkdestad_nib1_st;
              end
          end
 
        rx_fsm_lk4srcad_nib1_st:
          // collecting nibbles of source address
          // in case of termination of packet
          // or carrier sense error then generate eop
          // and generate status
          begin
            if(ap2rx_rx_fifo_err )
              begin
                rewind_write = 1;
                rx_fsm_nxt_st = rx_fsm_idle_st;
              end // else: !if(mi2rx_end_rcv)
            else if(mi2rx_end_rcv)
              begin
                if(cf2rx_rcv_runt_pkt_en)
                  begin
                    rx_fsm_nxt_st = rx_fsm_chkval_st;
                    commit_write = 1'b1;
                  end
                else
                  begin
                    rx_fsm_nxt_st = rx_fsm_idle_st;
                    rewind_write = 1'b1;
                  end
              end
            else if(mi2rx_rcv_vld && inc_rcv_byte_count[14:0] == 15'd12)
              begin
                  rx_fsm_nxt_st = rx_fsm_lk4len_byte1_st;
              end
            else
              begin
                rx_fsm_nxt_st = rx_fsm_lk4srcad_nib1_st;
              end
          end
 
        rx_fsm_lk4len_byte1_st:
          // this state collects the odd nibbles of the length 
          // field. 
          begin
            if(ap2rx_rx_fifo_err)
              begin
                rewind_write = 1;
                rx_fsm_nxt_st = rx_fsm_idle_st;
              end // else: !if(mi2rx_end_rcv)
            else if(mi2rx_end_rcv)
              begin
                if(cf2rx_rcv_runt_pkt_en)
                  begin
                    rx_fsm_nxt_st = rx_fsm_chkval_st;
                    commit_write = 1'b1;
                  end
                else
                  begin
                    rx_fsm_nxt_st = rx_fsm_idle_st;
                    rewind_write = 1'b1;
                  end
              end
            else if(mi2rx_rcv_vld)
              begin
                ld_length_byte_1 = 1'b1;
                rx_fsm_nxt_st = rx_fsm_lk4len_byte2_st;
              end
            else
              rx_fsm_nxt_st = rx_fsm_lk4len_byte1_st;
          end
 
        rx_fsm_lk4len_byte2_st:
          // This state generates the even nibbles of the length
          // field
        begin
           if(ap2rx_rx_fifo_err )
           begin
              rewind_write = 1;
              rx_fsm_nxt_st = rx_fsm_idle_st;
           end // else: !if(mi2rx_end_rcv)
           else if(mi2rx_end_rcv)
           begin
              if(cf2rx_rcv_runt_pkt_en)
              begin
                 rx_fsm_nxt_st = rx_fsm_chkval_st;
                 commit_write = 1'b1;
              end
              else
              begin
                 rx_fsm_nxt_st = rx_fsm_idle_st;
                 rewind_write = 1'b1;
              end
           end
           else if(mi2rx_rcv_vld )
           begin
              ld_length_byte_2 = 1'b1;
              check_padding_in = 1'b1;
              rx_fsm_nxt_st = rx_fsm_getdt_nib1_st;
           end
           else
                rx_fsm_nxt_st = rx_fsm_lk4len_byte2_st;
        end // rx_fsm_lk4len_byte2_st
 
        rx_fsm_getdt_nib1_st: //state number 7
          // This state collects the nibbles of the receive data
          // This state makes a determination to remove padding
          // only if strip padding is enabled and the length field
          // detected is less than 64
          begin
            if  (commit_condition)
              commit_write = 1'b1;
 
            if((ap2rx_rx_fifo_err) && !commit_write_done)
              begin
                rewind_write = 1;
                rx_fsm_nxt_st = rx_fsm_idle_st;
              end // else: !if(mi2rx_end_rcv)
            else if (ap2rx_rx_fifo_err)
              begin
                rx_fsm_nxt_st = rx_fsm_updstat_st;
              end
            else if(mi2rx_end_rcv)
              begin
                if(cf2rx_rcv_runt_pkt_en && !(commit_write_done | commit_condition))
                  begin
                    commit_write = 1'b1;
                    rx_fsm_nxt_st = rx_fsm_chkval_st;
                  end
                else if(!(commit_write_done | commit_condition) && !cf2rx_rcv_runt_pkt_en)
                  begin
                    rewind_write = 1'b1;
                    rx_fsm_nxt_st = rx_fsm_idle_st;
                  end
                else
                  rx_fsm_nxt_st = rx_fsm_chkval_st;
              end
            else if(mi2rx_rcv_vld && (inc_length_counter == rcv_length_reg) &&
                    look_at_length_field)
              begin
                dec_data_len = 1'b1;
                rx_fsm_nxt_st = rx_fsm_getpaddt_nib1_st;
              end
            else if(mi2rx_rcv_vld && look_at_length_field)
              begin
                dec_data_len = 1'b1;
                rx_fsm_nxt_st = rx_fsm_getdt_nib1_st;
              end
            else
              rx_fsm_nxt_st = rx_fsm_getdt_nib1_st;
          end
 
        rx_fsm_getpaddt_nib1_st:
          // This state handles the padded data in case of less than 64
          // byte packets This handles the odd nibbles
          begin
            if(ap2rx_rx_fifo_err)
              begin
                if(rcv_byte_count[14:0] <= 15'd64) // mfilardo
                //if(inc_rcv_byte_count[14:0] <= 15'd64)
                  begin
                    rewind_write = 1'b1;
                    rx_fsm_nxt_st = rx_fsm_idle_st;
                  end
                else
                  rx_fsm_nxt_st = rx_fsm_updstat_st;
              end
            else if(mi2rx_end_rcv)
              begin
                //if(inc_rcv_byte_count[14:0] == 15'd64)
                if(rcv_byte_count[14:0] == 15'd64) // mfilardo
                  lengthfield_error = 0;
                else
                  lengthfield_error = 1;
 
                  rx_fsm_nxt_st = rx_fsm_extend_st;
              end
            else if(mi2rx_rcv_vld)
              begin
                if(cf2rx_strp_pad_en)
                  rcv_pad_data = 1'b1;
              end
            else
              rx_fsm_nxt_st = rx_fsm_getpaddt_nib1_st;
          end // case: rx_fsm_getpaddt_nib1_st
 
 
        rx_fsm_extend_st:
          //This state handles the first extend conditon in the
          //cf2rx_gigabit_xfr
          //transfer
          begin
            if (mi2rx_extend)
              begin
                  rx_fsm_nxt_st = rx_fsm_extend_st;
              end
            else
              begin
                commit_write = 1'b1;
                rx_fsm_nxt_st = rx_fsm_chkval_st;
              end
          end
        rx_fsm_chkval_st:
          // This packet generates the validity of the packet
          // This is reached either on clean or error type
          // completion of packet.
          begin
            if(ap2rx_rx_fifo_err)
              begin
                rx_fsm_nxt_st = rx_fsm_updstat_st;
              end
            else if(cf2rx_rcv_runt_pkt_en && first_dword)
              begin
                rx_fsm_nxt_st = rx_fsm_chkval_st;
                case(rcv_byte_count[2:0])
                  3'd1:
                    begin
                      if(shift_counter == 3'd4)
                        begin
                          if(bytes_to_fifo == rcv_byte_count[2:0])
                            begin
                              gen_eop = 1'b1;
                              rx_fsm_nxt_st = rx_fsm_updstat_st;
                            end // if (bytes_to_fifo == rcv_nibble_count[3:1])
                          else
                            send_data_to_fifo = 1'b1;
                        end // if (shift_counter == 3'd4)
                      else
                        inc_shift_counter = 1;
                    end // case: 3'd1
 
                  3'd2:
                    begin
                      if(shift_counter == 3'd3)
                        begin
                          if(bytes_to_fifo == rcv_byte_count[2:0])
                            begin
                              gen_eop = 1'b1;
                              rx_fsm_nxt_st = rx_fsm_updstat_st;
                            end // if (bytes_to_fifo == rcv_nibble_count[3:1])
                          else
                            send_data_to_fifo = 1'b1;
                        end // if (shift_counter == 3'd3)
                      else
                        inc_shift_counter = 1;
                    end // case: 3'd2
 
                  3'd3:
                    begin
                      if(shift_counter == 3'd2)
                        begin
                          if(bytes_to_fifo == rcv_byte_count[2:0])
                            begin
                              gen_eop = 1'b1;
                              rx_fsm_nxt_st = rx_fsm_updstat_st;
                            end
                          else
                            send_data_to_fifo = 1'b1;
                        end // if (shift_counter == 3'd2)
                      else
                        inc_shift_counter = 1;
                    end // case: 3'd3
 
                  3'd4:
                    begin
                      if(shift_counter == 3'd1)
                        begin
                          if(bytes_to_fifo == rcv_byte_count[2:0])
                            begin
                              gen_eop = 1'b1;
                              rx_fsm_nxt_st = rx_fsm_updstat_st;
                            end // if (bytes_to_fifo == rcv_nibble_count[3:1])
                          else
                            send_data_to_fifo = 1'b1;
                        end
                      else
                        inc_shift_counter = 1;
                    end // case: 3'd4
                  default:
                    begin
                      rx_fsm_nxt_st = rx_fsm_idle_st;
                      gen_eop = 1'b0;
                    end
                endcase // case(rcv_nibble_count[3
              end // if (cf2rx_rcv_runt_pkt_en && first_dword)
            else if(((cf2rx_snd_crc || send_runt_packet || look_at_length_field)
                     && crc_count == 3'd4))
              begin
                gen_eop = 1'b1;
                rx_fsm_nxt_st = rx_fsm_updstat_st;
              end
            else if(send_runt_packet || look_at_length_field)
              begin
                send_crc = 1'b1;
                rx_fsm_nxt_st = rx_fsm_chkval_st;
              end
            else if(!cf2rx_snd_crc)
              begin
                gen_eop = 1'b1;
                rx_fsm_nxt_st = rx_fsm_updstat_st;
              end
            else
              begin
                send_crc = 1'b1;
                rx_fsm_nxt_st = rx_fsm_chkval_st;
              end
          end // case: rx_fsm_chkval_st
 
        rx_fsm_updstat_st:
          // This state updates the status to the application
          // This allows the application to determine the validity
          // of the packet so that it can take the necessary action
          begin
            e_rx_sts_vld = 1'b1;
            rx_fsm_nxt_st = rx_fsm_idle_st;
          end
 
        default:
          begin
            rx_fsm_nxt_st = rx_fsm_idle_st;
          end
      endcase // casex(rx_fsm_cur_st)
    end // always @ (rx_fsm_cur_st or mi2rx_strt_rcv or rx_ch_en or cf2rx_strp_pad_en...
 
  always @(inc_rcv_byte_count)
    begin
      if(inc_rcv_byte_count[14:0] < 15'd6)
        first_dword = 1'b1;
      else
        first_dword = 1'b0;
    end // always @ (inc_rcv_nibble_count or...
 
 
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        crc_count <= 3'b000;
      else if(mi2rx_strt_rcv)
        crc_count <= 3'b000;
      else if(send_crc)
        crc_count <= crc_count + 1;
    end // always @ (posedge phy_rx_clk...
 
  // These signals are used as intermediate flags to determine
  // whether to commit pointer or not to commit pointers
  // to the  application
  // error_seen helps in tracking errors which could occurs in between
  // packet transfer
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          commit_write_done <= 1'b1;
          error_seen <= 1'b0;
        end
      else if(mi2rx_strt_rcv)
        begin
          commit_write_done <= 1'b0;
          error_seen <= 1'b0;
        end
      else
        begin
          if(commit_write)
            commit_write_done <= 1'b1;
          if(error)
            error_seen <= 1'b1;
        end
    end // always @ (posedge phy_rx_clk...
 
  assign look_at_length_field = cf2rx_strp_pad_en &&
                                (rcv_length_reg < MIN_FRM_SIZE) && (|rcv_length_reg);
  assign send_runt_packet = cf2rx_rcv_runt_pkt_en &&
         (rcv_byte_count[15:8] == 8'd0 && rcv_byte_count[7:0] < 8'd64);
 
 
 
 
  assign inc_rcv_byte_count = rcv_byte_count + 16'h1;
 
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        rcv_byte_count <= 16'h0000;
      else if(mi2rx_strt_rcv)
        rcv_byte_count <= 16'h0000;
      else if(mi2rx_rcv_vld)
        rcv_byte_count <= inc_rcv_byte_count;
    end // always @ (posedge phy_rx_clk...
 
  // This signal is asserted wheneven there is no valid transfer on the
  // line. Valid transfer is only between mi2rx_strt_rcv and
  // mi2rx_end_rcv. In case
  // of rewind write transfer becomes invalid. Such data should not be
  // written in to the fifo
  reg dt_xfr_invalid;
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        dt_xfr_invalid <= 1;
      else if(rewind_write || ap2rx_rx_fifo_err)
        dt_xfr_invalid <= 1;
      else if(mi2rx_strt_rcv)
        dt_xfr_invalid <= 0;
    end
  // This is the mux to gather nibbles to two octets for the length field
  // of the register
  assign inc_length_counter = length_counter + 16'h1;
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          rcv_length_reg <= 16'b0;
          length_counter <= 16'b0;
        end // if (reset_n)
      else if (rx_ch_en)
        begin
          if(mi2rx_strt_rcv)
            begin
              length_counter <= 16'b0;
              rcv_length_reg <= 16'b0;
            end
          else if(dec_data_len )
            length_counter <= inc_length_counter;
          else
            begin
              if(ld_length_byte_1)
                begin
                  rcv_length_reg[15:8] <= mi2rx_rx_byte;
                end
            else if(ld_length_byte_2)
              begin
                rcv_length_reg[7:0] <= mi2rx_rx_byte;
              end
            end // else: !if(dec_data_len)
        end // else: !if(!reset_n)
    end // always @ (posedge phy_rx_clk...
 
  // This signal helps in making sure that when packets are received the
  // channel is enabled else ignore the complete packet until next start
  // of packet
  reg enable_channel;
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        enable_channel <= 0;
      else if(gen_eop)
        enable_channel <= 0;
      else if(mi2rx_strt_rcv && rx_ch_en)
        enable_channel <= 1;
    end
 
  // This is the decremented padding length register
  // Once it reaches zero CRC should follow
  assign dec_pad_length = padding_len_reg - 7'h1;
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          padding_needed <= 1'b0;
          padding_len_reg <= 6'b0;
        end
      else if(mi2rx_strt_rcv)
        begin
          padding_needed <= 1'b0;
          padding_len_reg <= 6'b0;
        end
      else if(look_at_length_field &&
              check_padding)
        begin
          padding_len_reg <= MIN_FRM_SIZE - rcv_length_reg[5:0];
          padding_needed <= 1'b1;
        end
      else if(dec_pad_len)
        begin
          padding_len_reg <= dec_pad_len;
          padding_needed <= padding_needed;
        end
    end // always @ (posedge phy_rx_clk...
 
  /*********************************************************
   Status Generation for Receive packets
   Statuses in this case are checked at end of receive packets
   and are registered and provided inthe next state along with
   rx_sts_valid bit asserted
   *********************************************************/
 
  reg[14:0] fifo_byte_count;
  wire [14:0] inc_fifo_byte_count;
  wire [14:0] dec_fifo_byte_count;
  assign      inc_fifo_byte_count = fifo_byte_count + 15'h1;
  assign      dec_fifo_byte_count = fifo_byte_count - 15'h1;
 
  always @(posedge phy_rx_clk or negedge reset_n)
    begin
      if(!reset_n)
        fifo_byte_count <= 15'd0;
      else if(rewind_write || mi2rx_strt_rcv)
        fifo_byte_count <= 15'd0;
      else if(rx2ap_rx_fsm_wrt)
        fifo_byte_count <= inc_fifo_byte_count;
    end
 
  reg        length_sz_mismatch;
 
  assign rx_sts_dt[31:16] = (e_rx_sts_vld && ap2rx_rx_fifo_err) ?
                            {dec_fifo_byte_count + 16'h1} : {fifo_byte_count + 16'h1};
  assign rx_sts_dt[15:13] = 3'd0;
  assign rx_sts_dt[12] = length_sz_mismatch;
  assign rx_sts_dt[11] = 1'b0;
  assign rx_sts_dt[10] = large_pkt_reg;
  assign rx_sts_dt[7] = lengthfield_err_reg;
  assign rx_sts_dt[6] = crc_stat_reg;
  assign rx_sts_dt[5] = rx_runt_pkt_reg;
  assign rx_sts_dt[4] = rx_fifo_overrun_reg;
  assign rx_sts_dt[2] = frm_length_err_reg;
  assign rx_sts_dt[1:0] = 2'd0;
 
  wire        rx_sts_large_pkt;
  wire [15:0] rx_sts_bytes_rcvd;
  wire        rx_sts_lengthfield_err;
  wire        rx_sts_crc_err;
  wire        rx_sts_runt_pkt_rcvd;
  wire        rx_sts_rx_overrun;
  wire        rx_sts_frm_length_err;
  wire        rx_sts_len_mismatch;
 
  assign      rx_sts_bytes_rcvd = rx_sts[31:16];
  assign      rx_sts_len_mismatch = rx_sts[12];
  assign      rx_sts_large_pkt = rx_sts[10];
  assign      rx_sts_lengthfield_err = rx_sts[7];
  assign      rx_sts_crc_err = rx_sts[6];
  assign      rx_sts_runt_pkt_rcvd = rx_sts[5];
  assign      rx_sts_rx_overrun = rx_sts[4];
  assign      rx_sts_frm_length_err = rx_sts[2];
 
 
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          crc_stat_reg <= 1'b0;
          frm_length_err_reg <= 1'b0;
          lengthfield_err_reg <= 1'b0;
          rx_fifo_overrun_reg <= 1'b0;
          rx_runt_pkt_reg <= 1'b0;
          large_pkt_reg <= 1'b0;
          length_sz_mismatch <= 1'b0;
        end
      else if(mi2rx_strt_rcv)
        begin
          crc_stat_reg <= 1'b0;
          frm_length_err_reg <= 1'b0;
          lengthfield_err_reg <= 1'b0;
          rx_fifo_overrun_reg <= 1'b0;
          rx_runt_pkt_reg <= 1'b0;
          large_pkt_reg <= 1'b0;
          length_sz_mismatch <= 1'b0;
        end
      else
        begin
          if(rx_overrun_error)
            rx_fifo_overrun_reg <= 1'b1;
 
          if(lengthfield_error)
            lengthfield_err_reg <= 1'b1;
 
          if(mi2rx_end_rcv && mi2rx_frame_err)
            frm_length_err_reg <= 1'b1;
 
          if(mi2rx_end_rcv)
            begin
              if(!rc2rx_crc_ok)
                crc_stat_reg <= 1'b1;
              if(rcv_byte_count[14:0] < 15'd64)
                rx_runt_pkt_reg <= 1'b1;
              if(rcv_byte_count[14:0] > adj_cf2rx_max_pkt_sz)
                large_pkt_reg <= 1'b1;
              if( (adj_rcv_byte_count[15:0] != adj_rcv_length_reg) && (adj_rcv_length_reg <= 16'd1500) )
                length_sz_mismatch <= 1'b1;
            end // if (mi2rx_end_rcv)
        end // else: !if(mi2rx_strt_rcv)
    end // always @ (posedge phy_rx_clk...
 
  /***************************************************/
  //
  // Additions for Byte operation 
  //
  /***************************************************/
  always @(posedge phy_rx_clk or
           negedge reset_n)
    begin
      if(!reset_n)
        shift_counter <= 3'd0;
      else if(mi2rx_strt_rcv)
        shift_counter <= 3'd0;
      else if(inc_shift_counter)
        shift_counter <= shift_counter + 1;
    end // always @ (posedge phy_rx_clk or...
 
  always @(posedge phy_rx_clk or
           negedge reset_n)
    begin
      if(!reset_n)
        bytes_to_fifo <= 3'd0;
      else if(mi2rx_strt_rcv)
        bytes_to_fifo <= 3'd1;
      else if(send_data_to_fifo)
        bytes_to_fifo <= bytes_to_fifo + 1;
    end // always @ (posedge phy_rx_clk or...
 
  wire[8:0] e_rx_fsm_dt;
  wire      e_rx_fsm_wrt;
  assign    e_rx_fsm_dt[7:0] = buf_latch4;
//  assign    e_rx_fsm_dt[8] = (rx_fifo_full) ? 1'b1 :gen_eop;
  assign    e_rx_fsm_dt[8] = gen_eop;
 
  always @(posedge phy_rx_clk or
           negedge reset_n)
    begin
      if(!reset_n)
        begin
          rx2ap_rx_fsm_dt <= 9'd0;
          rx2ap_rx_fsm_wrt <= 1'b0;
          rx2ap_commit_write <= 1'b0;
          rx2ap_rewind_write <= 1'b0;
        end
      else
        begin
          rx2ap_rx_fsm_wrt <= e_rx_fsm_wrt && (!ap2rx_rx_fifo_err);
          rx2ap_rx_fsm_dt <= e_rx_fsm_dt;
          rx2ap_commit_write <= commit_write;
          rx2ap_rewind_write <= rewind_write;
        end
    end // always @ (posedge phy_rx_clk or...
 
  assign e_rx_fsm_wrt = ((enable_channel &&
                          mi2rx_rcv_vld && !first_dword) ||
                         (enable_channel &&
                          (gen_eop || send_crc)) ||
                         (enable_channel && send_data_to_fifo)) && !rcv_pad_data
                        && !dt_xfr_invalid && !rewind_write;
  assign ld_buf = enable_channel && !rcv_pad_data && (|rcv_byte_count == 1) &&
         (mi2rx_rcv_vld) || send_crc || inc_shift_counter || send_data_to_fifo;
 
  assign ld_buf4 = ld_buf ;
  assign ld_buf3 = ld_buf ;
  assign ld_buf2 = ld_buf ;
  assign ld_buf1 = ld_buf ;
  always @(posedge phy_rx_clk
           or negedge reset_n)
    begin
      if(!reset_n)
        begin
          buf_latch4 <= 8'b0;
          buf_latch3 <= 8'b0;
          buf_latch2 <= 8'b0;
          buf_latch1 <= 8'b0;
          buf_latch0 <= 8'b0;
        end
      else
        begin
          if(ld_buf4)
            buf_latch4 <= buf_latch3;
 
          if(ld_buf3)
            buf_latch3 <= buf_latch2;
 
          if(ld_buf2)
            buf_latch2 <= buf_latch1;
 
          if(ld_buf1)
            buf_latch1 <= buf_latch0;
 
          if (rx_ch_en)
            begin
              if(mi2rx_strt_rcv)
                begin
                  buf_latch0 <= 8'b0;
                end
              else
                begin
                  if(mi2rx_rcv_vld && !rcv_pad_data)
                    begin
                      buf_latch0 <= mi2rx_rx_byte;
                    end
                end // else: !if(mi2rx_strt_rcv)
            end // if (rx_ch_en)
        end // else: !if(!reset_n)
    end // always @ (posedge phy_rx_clk...
 
endmodule
Browse

Tools

Subversion Repositories turbo8051

[/] [turbo8051/] [trunk/] [rtl/] [gmac/] [mac/] [g_rx_fsm.v] - Blame information for rev 61

Line No.	Rev	Author	Line
1	12	dinesha	`//////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// Tubo 8051 cores MAC Interface Module ////`
4			`//// ////`
5			`//// This file is part of the Turbo 8051 cores project ////`
6			`//// http://www.opencores.org/cores/turbo8051/ ////`
7			`//// ////`
8			`//// Description ////`
9			`//// Turbo 8051 definitions. ////`
10			`//// ////`
11			`//// To Do: ////`
12			`//// nothing ////`
13			`//// ////`
14			`//// Author(s): ////`
15			`//// - Dinesh Annayya, dinesha@opencores.org ////`
16			`//// ////`
17			`//////////////////////////////////////////////////////////////////////`
18			`//// ////`
19			`//// Copyright (C) 2000 Authors and OPENCORES.ORG ////`
20			`//// ////`
21			`//// This source file may be used and distributed without ////`
22			`//// restriction provided that this copyright statement is not ////`
23			`//// removed from the file and that any derivative work contains ////`
24			`//// the original copyright notice and the associated disclaimer. ////`
25			`//// ////`
26			`//// This source file is free software; you can redistribute it ////`
27			`//// and/or modify it under the terms of the GNU Lesser General ////`
28			`//// Public License as published by the Free Software Foundation; ////`
29			`//// either version 2.1 of the License, or (at your option) any ////`
30			`//// later version. ////`
31			`//// ////`
32			`//// This source is distributed in the hope that it will be ////`
33			`//// useful, but WITHOUT ANY WARRANTY; without even the implied ////`
34			`//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR ////`
35			`//// PURPOSE. See the GNU Lesser General Public License for more ////`
36			`//// details. ////`
37			`//// ////`
38			`//// You should have received a copy of the GNU Lesser General ////`
39			`//// Public License along with this source; if not, download it ////`
40			`//// from http://www.opencores.org/lgpl.shtml ////`