Subversion Repositories udp_ipv4_for_10g_ethernet

-------------------------------------------------------------------------------

--

-- (C) Copyright 2013 DFC Design, s.r.o., Brno, Czech Republic

-- Author: Marek Kvas (m.kvas@dfcdesign.cz)

--

-------------------------------------------------------------------------------

-- This file is part of UDP/IPv4 for 10 G Ethernet core.

-- 

-- UDP/IPv4 for 10 G Ethernet core 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 3 of the License, or

-- (at your option) any later version.

-- 

-- UDP/IPv4 for 10 G Ethernet core 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 UDP/IPv4 for 10 G Ethernet core.  If not, 

-- see <http://www.gnu.org/licenses/>.

-------------------------------------------------------------------------------

--

-- First block of the receiver chain. It has XGMII as an input.

-- Output is raw 64 bit data guaranteed to be aligned on the frame start and 

-- stripped of preamble and CRC, valid signal covering frame data,

-- and byte enable signal that shall be used in case data amount is not

-- 8 byte aligned. Another signal indicates either CRC error or line

-- signalized error, in which case frame should be discarded.

--

-- Byte enable signal is guaranteed to be all ones for whole frame except

-- for the last word, in case packet length is not 8 byte integer divisible.

--

-- This can work under assumption that minimum IPG in incoming stream is

-- 4 bytes. This means when T is on L0-L4, S cannot be on L5-L7 of the same

-- cycle and when T is on L5-L7 S cannot be on L0-L3 of the next cycle. Under

-- this condition DV is always at leased one cycle deasserted between

-- frames.

--

-- RST must be asserted for 16 cycles to fully empty pipeline

--

-------------------------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use ieee.numeric_std.all;

Library UNISIM;

use UNISIM.vcomponents.all;

library work;

use work.srl_pkg.all;

entity frame_receiver is

   port (

      RST               : in std_logic; -- Sync to XGMII_RX_CLK

      -- XGMII RX input interface

      XGMII_RXCLK       : in  std_logic;

      XGMII_RXD         : in  std_logic_vector(63 downto 0);

      XGMII_RXC         : in  std_logic_vector( 7 downto 0);

      -- Output interface

      RX_DATA           : out std_logic_vector(63 downto 0);

      RX_DV             : out std_logic;

      RX_BE             : out std_logic_vector(7 downto 0);

      RX_ERR            : out std_logic;

      RX_ERR_VALID      : out std_logic

        );

end entity;

architecture synthesis of frame_receiver is

   -- Local constants

   constant LC_START_CHAR  : std_logic_vector(7 downto 0) := x"FB";

   constant LC_TERM_CHAR   : std_logic_vector(7 downto 0) := x"FD";

   constant LC_ERR_CHAR    : std_logic_vector(7 downto 0) := x"FE";

   -- Aligning block

   signal align_buf_data  : std_logic_vector(XGMII_RXD'length-1 downto 0);

   signal align_res_data  : std_logic_vector(XGMII_RXD'length-1 downto 0);

   signal align_res_data_d: std_logic_vector(XGMII_RXD'length-1 downto 0);

   signal align_buf_ctrl  : std_logic_vector(XGMII_RXC'length-1 downto 0);

   signal align_res_ctrl  : std_logic_vector(XGMII_RXC'length-1 downto 0);

   type align_mode_type  is (S_L0, S_L4);

   signal align_mode     : align_mode_type;

   signal crc_data_d    : std_logic_vector(XGMII_RXD'length-1 downto 0);

   signal crc_data_dd   : std_logic_vector(XGMII_RXD'length-1 downto 0);

   signal data_mask_d   : std_logic_vector(7 downto 0);

   signal data_mask_dd  : std_logic_vector(7 downto 0);

   signal crc_mask_dd   : std_logic_vector(2 downto 0);

   signal crc_dv_d      : std_logic;

   signal crc_dv_dd     : std_logic;

   signal crc_eop       : std_logic;

   signal crc_eop_d     : std_logic;

   signal crc_eop_dd    : std_logic;

   signal data_valid    : std_logic;

   signal data_valid_d  : std_logic;

   signal sop_found     : std_logic;

   signal sop_found_d   : std_logic;

   signal extracted_crc          : std_logic_vector(31 downto 0);

   signal extracted_crc_eq       : std_logic_vector(31 downto 0);

   signal extracted_crc_n        : std_logic_vector(31 downto 0);

   signal data_err_valid         : std_logic;

   signal data_err_valid_d       : std_logic;

   signal data_err_valid_dd      : std_logic;

   signal data_err_valid_reg     : std_logic;

   signal data_err_valid_d_reg   : std_logic;

   signal data_err_valid_dd_reg  : std_logic;

   signal data_err               : std_logic;

   signal data_err_d             : std_logic;

   signal data_err_dd            : std_logic;

   -- Internal versions of output signals

   signal rx_data_i           : std_logic_vector(63 downto 0);

   signal rx_dv_i             : std_logic;

   signal rx_err_i            : std_logic;

   signal rx_err_valid_i      : std_logic;

   signal rx_be_i             : std_logic_vector(7 downto 0);

   signal data_err_eq_m1      : std_logic;

   -- crc connection

   signal crc32_result        : std_logic_vector(31 downto 0);

   signal crc32_result_n      : std_logic_vector(31 downto 0);

   signal crc_vld             : std_logic;

-- Returns true if there is a terminate command character in data

   function check_terminate_func(rxc : std_logic_vector; rxd : std_logic_vector)

                                             return boolean is

      variable res : boolean := false;

   begin

      if (rxd(7  downto  0) = LC_TERM_CHAR and rxc(0) = '1') or

         (rxd(15 downto  8) = LC_TERM_CHAR and rxc(1) = '1') or

         (rxd(23 downto 16) = LC_TERM_CHAR and rxc(2) = '1') or

         (rxd(31 downto 24) = LC_TERM_CHAR and rxc(3) = '1') or

         (rxd(39 downto 32) = LC_TERM_CHAR and rxc(4) = '1') or

         (rxd(47 downto 40) = LC_TERM_CHAR and rxc(5) = '1') or

         (rxd(55 downto 48) = LC_TERM_CHAR and rxc(6) = '1') or

         (rxd(63 downto 56) = LC_TERM_CHAR and rxc(7) = '1') then

         res := true;

      end if;

      return res;

   end function;

-- Returns true if there is a error command character in data

   function check_err_func(rxc : std_logic_vector; rxd : std_logic_vector)

                                             return boolean is

      variable res : boolean := false;

   begin

      if (rxd(7  downto  0) = LC_ERR_CHAR and rxc(0) = '1') or

         (rxd(15 downto  8) = LC_ERR_CHAR and rxc(1) = '1') or

         (rxd(23 downto 16) = LC_ERR_CHAR and rxc(2) = '1') or

         (rxd(31 downto 24) = LC_ERR_CHAR and rxc(3) = '1') or

         (rxd(39 downto 32) = LC_ERR_CHAR and rxc(4) = '1') or

         (rxd(47 downto 40) = LC_ERR_CHAR and rxc(5) = '1') or

         (rxd(55 downto 48) = LC_ERR_CHAR and rxc(6) = '1') or

         (rxd(63 downto 56) = LC_ERR_CHAR and rxc(7) = '1') then

         res := true;

      end if;

      return res;

   end function;

   -- transform byte enables to crc mask

   function be_to_crc_mask_func(be : std_logic_vector) return std_logic_vector is

      variable res : std_logic_vector(2 downto 0);

   begin

      case be(7 downto 0) is

         when "00000000" => res := "000";

         when "00000001" => res := "111";

         when "00000011" => res := "110";

         when "00000111" => res := "101";

         when "00001111" => res := "100";

         when "00011111" => res := "011";

         when "00111111" => res := "010";

         when "01111111" => res := "001";

         when others => res := "000";

      end case;

      return res;

   end function;

   function swap_bytes32_cut(i : std_logic_vector; idx : integer)

                                                return std_logic_vector is

      variable res : std_logic_vector(31 downto 0);

   begin

      res(7  downto 0 ) := i(31 + idx*8 downto 24+ idx*8 );

      res(15 downto 8 ) := i(23 + idx*8 downto 16+ idx*8 );

      res(23 downto 16) := i(15 + idx*8 downto 8 + idx*8 );

      res(31 downto 24) := i(7  + idx*8 downto 0 + idx*8 );

      return res;

   end function;

begin

--------------------------------------------------------------------------------

-- Allign data if start is on Lane 4

--------------------------------------------------------------------------------

   align_proc : process (XGMII_RXCLK)

      variable tmp      : std_logic_vector(2*align_res_data'length - 1 downto 0);

   begin

      if rising_edge(XGMII_RXCLK) then

         tmp := align_res_data & align_res_data_d;

         rx_err_valid_i <= '0';

         rx_err_i <= '0';

         crc_eop <= '0';

         sop_found <= '0';

         -- First stage - directly connected to input

         if XGMII_RXC(0) = '1' and

            XGMII_RXD((0+1)*8-1 downto 0*8) = LC_START_CHAR then

            align_mode <= S_L0;

            sop_found <= '1';

            data_err <= '0';

         elsif XGMII_RXC(0) = '1' and

               XGMII_RXD((4+1)*8-1 downto 4*8) = LC_START_CHAR then

            align_mode <= S_L4;

            sop_found <= '1';

            data_err <= '0';

         end if;

         align_buf_data <= XGMII_RXD;

         align_buf_ctrl <= XGMII_RXC;

         -- Second stage - registers after multiplexer that takes data

         -- either from buffer or from input

         case align_mode is

            when S_L0 =>

               align_res_data <= align_buf_data;

               align_res_ctrl <= align_buf_ctrl;

            when S_L4 =>

               align_res_data <= XGMII_RXD(31 downto 0) &

                                 align_buf_data(63 downto 32);

               align_res_ctrl <= XGMII_RXC(3 downto 0) &

                                 align_buf_ctrl(7 downto 4);

         end case;

         sop_found_d <= sop_found;

         -- Derive correct BE and crc mask, align data for crc to this info

         -- derive error signal (remote error or invalid control combination

         -- 3 cycles

         align_res_data_d <= align_res_data;

         crc_data_d <= align_res_data_d;

         crc_data_dd <= crc_data_d;

         crc_eop_d <= crc_eop;

         crc_eop_dd <= crc_eop_d;

         data_mask_dd <= data_mask_d;

         crc_mask_dd <= be_to_crc_mask_func(data_mask_dd);

         data_valid <= data_valid or sop_found_d;

         data_valid_d <= data_valid;

         crc_dv_d <= data_valid_d;

         crc_dv_dd <= crc_dv_d;

         if data_valid = '1' then

            data_mask_d <= (others => '1');

         end if;

         if data_valid = '1' and

            check_terminate_func (align_res_ctrl, align_res_data) then

            case align_res_ctrl is

               when "10000000" =>

                  data_mask_d <= "00000111";

                  data_valid_d  <= '1';

                  data_valid <= '0';

                  crc_eop     <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,11);

               when "11000000" =>

                  data_mask_d <= "00000011";

                  data_valid_d <= '1';

                  data_valid <= '0';

                  crc_eop     <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,10);

               when "11100000" =>

                  data_mask_d <= "00000001";

                  data_valid_d <= '1';

                  data_valid <= '0';

                  crc_eop     <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,9);

               when "11110000" =>

                  data_mask_d <= "00000000";

                  data_valid_d <= '0';

                  data_valid <= '0';

                  crc_eop_d   <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,8);

               when "11111000" =>

                  data_mask_d <= "00000000";

                  data_valid_d <= '0';

                  data_valid <= '0';

                  data_mask_dd <= "01111111";

                  crc_eop_d   <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,7);

               when "11111100" =>

                  data_mask_d <= "00000000";

                  data_valid_d <= '0';

                  data_valid <= '0';

                  data_mask_dd <= "00111111";

                  crc_eop_d   <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,6);

               when "11111110" =>

                  data_mask_d <= "00000000";

                  data_valid_d <= '0';

                  data_valid <= '0';

                  data_mask_dd <= "00011111";

                  crc_eop_d   <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,5);

               when "11111111" =>

                  data_mask_d <= "00000000";

                  data_valid_d <= '0';

                  data_valid <= '0';

                  data_mask_dd <= "00001111";

                  crc_eop_d   <= '1';

                  extracted_crc <= swap_bytes32_cut(tmp,4);

               when others =>

                  data_err <= '1';

                  data_valid_d <= '0';

                  data_valid <= '0';

            end case;

         end if;

         if check_err_func(align_res_ctrl, align_res_data) then

            data_err <= '1';

         end if;

         -- Check CRC validity

         -- takes 1 cycle, but crc itself has 4 cycles

         -- 5 cycles

         if crc_vld = '1' then

            if extracted_crc /= crc32_result then

               -- CRC error

               rx_err_i <= '1';

            else

               rx_err_i <= data_err_eq_m1;

            end if;

            rx_err_valid_i <= '1';

         end if;

         -- Reset only input to pipeline reset should be held asserted long

         -- enough to reset pipeline

         if RST = '1' then

            align_mode <= S_L0;

            align_buf_data <= (others => '0');

            align_buf_ctrl <= (others => '0');

            align_res_data <= (others => '0');

            align_res_ctrl <= (others => '0');

            data_valid <= '0';

            sop_found <= '0';

         end if;

      end if;

   end process;

   -- Equalized signals

   rx_data_eq_inst : ssrl_bus

   generic map (rx_data'length, 4) port map (XGMII_RXCLK, crc_data_dd,rx_data_i);

   rx_be_eq_inst : ssrl_bus

   generic map (rx_be'length, 5) port map (XGMII_RXCLK, data_mask_dd, rx_be_i);

   rx_dv_eq_inst : ssrl

   generic map (4) port map (XGMII_RXCLK, crc_dv_dd, rx_dv_i);

   data_err_eq_inst : ssrl

   generic map (4) port map (XGMII_RXCLK, data_err, data_err_eq_m1);

--------------------------------------------------------------------------------

-- Process data

--------------------------------------------------------------------------------

   crc32_gen_inst: entity work.crc32_gen

   generic map (

      DATA_WIDTH => 64

   )

   port map(

      DI    => crc_data_dd,

      DI_DV => crc_dv_dd,

      EOP   => crc_eop_dd,

      MASK  => crc_mask_dd,

      CLK   => XGMII_RXCLK,

      RESET => RST,

      CRC   => crc32_result,

      DO_DV => crc_vld

   );

   crc32_result_n <= not crc32_result;

   -- Outputs assignment

   RX_DATA        <= rx_data_i;

   RX_DV          <= rx_dv_i;

   RX_BE          <= rx_be_i;

   RX_ERR         <= rx_err_i;

   RX_ERR_VALID   <= rx_err_valid_i;

end architecture;