Subversion Repositories gbiteth

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

-- Title      : 

-- Project    : 

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

-- File       : rgmii_rx.vhd

-- Author     : liyi  <alxiuyain@foxmail.com>

-- Company    : OE@HUST

-- Created    : 2012-11-14

-- Last update: 2013-05-21

-- Platform   : 

-- Standard   : VHDL'93/02

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

-- Description: 

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

-- Copyright (c) 2012 OE@HUST

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

-- Revisions  :

-- Date        Version  Author  Description

-- 2012-11-14  1.0      root    Created

-- 2013-05-13  1.0      liyi    change dataen signal ,now the dest&sourcr mac

--                              addr and type_len info are counted as valid data 

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

LIBRARY ieee;

USE ieee.std_logic_1164.ALL;

USE ieee.numeric_std.ALL;

USE work.eth_pkg.ALL;

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

ENTITY rgmii_rx IS

  PORT (

    iClk   : IN STD_LOGIC;

    iRst_n : IN STD_LOGIC;

    iRxData : IN STD_LOGIC_VECTOR(7 DOWNTO 0);

    iRxDV   : IN STD_LOGIC;

    iRxEr   : IN STD_LOGIC;

    -- these signals come from wishbone clock domian, NOT synchronized

    iCheckSumIPCheck   : IN STD_LOGIC;

    iCheckSumTCPCheck  : IN STD_LOGIC;

    iCheckSumUDPCheck  : IN STD_LOGIC;

    iCheckSumICMPCheck : IN STD_LOGIC;

    oEOF         : OUT STD_LOGIC;

    oSOF         : OUT STD_LOGIC;

    oCRCErr      : OUT STD_LOGIC;

    oRxErr       : OUT STD_LOGIC;

    oLenErr      : OUT STD_LOGIC;

    oCheckSumErr : OUT STD_LOGIC;

    iMyMAC : IN STD_LOGIC_VECTOR(47 DOWNTO 0);

    oGetARP  : OUT    STD_LOGIC;

    oGetIPv4 : BUFFER STD_LOGIC;

    oGetCtrl : OUT    STD_LOGIC;

    oGetRaw  : BUFFER STD_LOGIC;

    oTaged      : OUT    STD_LOGIC;

    oTagInfo    : OUT    STD_LOGIC_VECTOR(15 DOWNTO 0);

    oStackTaged : BUFFER STD_LOGIC;

    oTagInfo2   : OUT    STD_LOGIC_VECTOR(15 DOWNTO 0);

    oLink   : OUT STD_LOGIC;

    oSpeed  : OUT STD_LOGIC_VECTOR(1 DOWNTO 0);

    oDuplex : OUT STD_LOGIC;

    oPayloadLen : BUFFER UNSIGNED(15 DOWNTO 0);

    oRxData     : OUT    STD_LOGIC_VECTOR(7 DOWNTO 0);

    oRxDV       : OUT    STD_LOGIC

    );

END ENTITY rgmii_rx;

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

ARCHITECTURE rtl OF rgmii_rx IS

  SIGNAL sof, eof      : STD_LOGIC;

  SIGNAL crcEn, crcEn2 : STD_LOGIC;

  SIGNAL crcErr        : STD_LOGIC;

  SIGNAL dvDly   : STD_LOGIC_VECTOR(3 DOWNTO 0);

  TYPE dataAyy_t IS ARRAY (3 DOWNTO 0) OF STD_LOGIC_VECTOR(7 DOWNTO 0);

  SIGNAL dataDly : dataAyy_t;

  TYPE state_t IS (IDLE, SFD, DEST_MAC, SOURCE_MAC, FRAME_TYPE, TAG_INFO1, TAG_INFO2, PAYLOAD);

  SIGNAL state       : state_t;

  SIGNAL byteCnt     : UNSIGNED(15 DOWNTO 0);

  SIGNAL destMACAddr : STD_LOGIC_VECTOR(47 DOWNTO 8);

  SIGNAL frm4Me : STD_LOGIC;

  SIGNAL rxDV, dataEn : STD_LOGIC;

  SIGNAL rCheckSumOk : BOOLEAN;

BEGIN  -- ARCHITECTURE rtl

  -- check sum calc

  blkCS : BLOCK IS

    TYPE state_t IS (IDLE, IP4_HEAD, TCP, UDP, ICMP, UNKNOWN, DONE);

    SIGNAL rState         : state_t;

    SIGNAL cRxDataD1      : STD_LOGIC_VECTOR(7 DOWNTO 0);

    SIGNAL rCheckSum      : UNSIGNED(31 DOWNTO 0);

    SIGNAL cCheckSum      : UNSIGNED(15 DOWNTO 0);

    SIGNAL rIPCSOK        : BOOLEAN;               -- ip checksum ok

    SIGNAL rByteCnt       : UNSIGNED(15 DOWNTO 0);

    SIGNAL cByteValid     : STD_LOGIC;

    SIGNAL rPesudoCS      : UNSIGNED(18 DOWNTO 0);

    SIGNAL rIPHeadLen     : UNSIGNED(5 DOWNTO 0);  -- 20~60 bytes

    SIGNAL rTotalLen      : UNSIGNED(15 DOWNTO 0);

    SIGNAL cIPPayloadLen  : UNSIGNED(15 DOWNTO 0);

    SIGNAL rProtocol      : STD_LOGIC_VECTOR(7 DOWNTO 0);

    SIGNAL cIPCSCheckEn   : BOOLEAN;

    SIGNAL cTCPCSCheckEn  : BOOLEAN;

    SIGNAL cICMPCSCheckEn : BOOLEAN;

    SIGNAL cUDPCSCheckEn  : BOOLEAN;

    SIGNAL rGetCheckSum   : BOOLEAN;

    SIGNAL rCsCheckSync   : STD_LOGIC_VECTOR(7 DOWNTO 0);

  BEGIN  -- BLOCK blkCS

    cRxDataD1      <= dataDly(0);

    cByteValid     <= dvDly(0);

    cCheckSum      <= rCheckSum(31 DOWNTO 16) + rCheckSum(15 DOWNTO 0);

    --cCheckSumOk   <= cCheckSum = X"FFFF";

    cIPPayloadLen  <= rTotalLen - rIPHeadLen;

    cIPCSCheckEn   <= rCsCheckSync(1) = '1';

    cTCPCSCheckEn  <= rCsCheckSync(3) = '1';

    cUDPCSCheckEn  <= rCsCheckSync(5) = '1';

    cICMPCSCheckEn <= rCsCheckSync(7) = '1';

    PROCESS (iClk) IS

    BEGIN

      IF rising_edge(iClk) THEN

        rCsCheckSync(1 DOWNTO 0) <= rCsCheckSync(0)&iCheckSumIPCheck;

        rCsCheckSync(3 DOWNTO 2) <= rCsCheckSync(2)&iCheckSumTCPCheck;

        rCsCheckSync(5 DOWNTO 4) <= rCsCheckSync(4)&iCheckSumUDPCheck;

        rCsCheckSync(7 DOWNTO 6) <= rCsCheckSync(6)&iCheckSumICMPCheck;

      END IF;

    END PROCESS;

    PROCESS (iClk, iRst_n) IS

    BEGIN

      IF iRst_n = '0' THEN

        rState       <= IDLE;

        rCheckSum    <= (OTHERS => '0');

        rByteCnt     <= (OTHERS => '0');

        rPesudoCS    <= (OTHERS => '0');

        rIPHeadLen   <= (OTHERS => '0');

        rTotalLen    <= (OTHERS => '0');

        rProtocol    <= (OTHERS => '0');

        rCheckSumOk  <= FALSE;

        rGetCheckSum <= FALSE;

        rIPCSOK      <= FALSE;

      ELSIF rising_edge(iClk) THEN

        rGetCheckSum <= FALSE;

        IF eof = '1' THEN

          rState <= IDLE;

        END IF;

        CASE rState IS

          WHEN IDLE =>

            rPesudoCS   <= (OTHERS => '0');

            rCheckSum   <= (OTHERS => '0');

            rByteCnt    <= X"0001";

            rCheckSumOk <= TRUE;

            rIPCSOK     <= FALSE;

            IF oGetIPv4 = '1' THEN

              rState <= IP4_HEAD;

              rCheckSumOk <= FALSE;

            END IF;

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

          WHEN IP4_HEAD =>

            IF cByteValid = '1' THEN

              rByteCnt <= rByteCnt + 1;

              IF rByteCnt(0) = '1' THEN  -- higher byte

                rCheckSum <= rCheckSum + to_integer(UNSIGNED(cRxDataD1)&X"00");

              ELSE                       -- lower byte

                rCheckSum <= rCheckSum + UNSIGNED(cRxDataD1);

              END IF;

              CASE rByteCnt(5 DOWNTO 0) IS

                WHEN B"000001" =>

                  rIPHeadLen <= UNSIGNED(cRxDataD1(3 DOWNTO 0))&B"00";

                WHEN B"000011" => rTotalLen(15 DOWNTO 8) <= UNSIGNED(cRxDataD1);

                WHEN B"000100" => rTotalLen(7 DOWNTO 0)  <= UNSIGNED(cRxDataD1);

                WHEN B"001010" =>        -- Protocol

                  rPesudoCS <= rPesudoCS + UNSIGNED(cRxDataD1);

                  rProtocol <= cRxDataD1;

                WHEN B"001011" =>

                  rPesudoCS <= rPesudoCS + cIPPayloadLen;

                -- source &Destination ip addr

                WHEN B"001101" | B"001111" | B"010001" | B"010011" =>

                  rPesudoCS <= rPesudoCS + to_integer(UNSIGNED(cRxDataD1)&X"00");

                WHEN B"001110" | B"010000" | B"010010" | B"010100"=>

                  rPesudoCS <= rPesudoCS + UNSIGNED(cRxDataD1);

                WHEN OTHERS => NULL;

              END CASE;

              IF rIPHeadLen = rByteCnt(5 DOWNTO 0) THEN

                rGetCheckSum <= TRUE;

                rState       <= UNKNOWN;

                CASE rProtocol IS

                  WHEN X"01" =>          -- ICMP

                    rState <= ICMP;

                  WHEN X"06" =>          -- TCP

                    rState <= TCP;

                  WHEN X"11" =>          -- UDP

                    rState <= UDP;

                  WHEN OTHERS => NULL;

                END CASE;

              END IF;

            END IF;

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

          -- tcp & udp are the same,both contain a pesudo header

          WHEN TCP | UDP =>

            IF rGetCheckSum THEN

              rIPCSOK   <= NOT cIPCSCheckEn OR (cIPCSCheckEn AND cCheckSum = X"FFFF");

              rCheckSum <= X"000"&B"0"&rPesudoCS;

            END IF;

            IF cByteValid = '1' THEN

              rByteCnt <= rByteCnt + 1;

              IF rByteCnt(0) = '1' THEN  -- higher byte

                IF rGetCheckSum THEN

                  rCheckSum <= X"000"&'0'&rPesudoCS + to_integer(UNSIGNED(cRxDataD1)&X"00");

                ELSE

                  rCheckSum <= rCheckSum + to_integer(UNSIGNED(cRxDataD1)&X"00");

                END IF;

              ELSE                       -- lower byte

                rCheckSum <= rCheckSum + UNSIGNED(cRxDataD1);

              END IF;

              IF rByteCnt = rTotalLen THEN

                rState       <= DONE;

                rGetCheckSum <= TRUE;

              END IF;

            END IF;

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

          WHEN ICMP =>

            IF rGetCheckSum THEN

              rIPCSOK   <= NOT cIPCSCheckEn OR (cIPCSCheckEn AND cCheckSum = X"FFFF");

              rCheckSum <= (OTHERS => '0');

            END IF;

            IF cByteValid = '1' THEN

              rByteCnt <= rByteCnt + 1;

              IF rByteCnt(0) = '1' THEN  -- higher byte

                IF rGetCheckSum THEN

                  rCheckSum <= X"0000"&UNSIGNED(cRxDataD1)&X"00";

                ELSE

                  rCheckSum <= rCheckSum + to_integer(UNSIGNED(cRxDataD1)&X"00");

                END IF;

              ELSE                       -- lower byte

                rCheckSum <= rCheckSum + UNSIGNED(cRxDataD1);

              END IF;

              IF rByteCnt = rTotalLen THEN

                rState       <= DONE;

                rGetCheckSum <= TRUE;

              END IF;

            END IF;

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

          WHEN UNKNOWN =>

            IF rGetCheckSum THEN

              rCheckSumOk <= NOT cIPCSCheckEn OR (cIPCSCheckEn AND cCheckSum = X"FFFF");

            END IF;

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

          WHEN DONE =>

            IF rGetCheckSum THEN

              CASE rProtocol IS

                WHEN X"01" =>

                  rCheckSumOk <= rIPCSOK AND

                                 (NOT cICMPCSCheckEn OR

                                  (cICMPCSCheckEn AND cCheckSum = X"FFFF"));

                WHEN X"06" =>

                  rCheckSumOk <= rIPCSOK AND

                                 (NOT cTCPCSCheckEn OR

                                  (cTCPCSCheckEn AND cCheckSum = X"FFFF"));

                WHEN X"11" =>

                  rCheckSumOk <= rIPCSOK AND

                                 (NOT cUDPCSCheckEn OR

                                  (cUDPCSCheckEn AND cCheckSum = X"FFFF"));

                WHEN OTHERS => NULL;

              END CASE;

            END IF;

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

          WHEN OTHERS => NULL;

        END CASE;

      END IF;

    END PROCESS;

  END BLOCK blkCS;

  -- USE normal inter-frame TO get link information

  PROCESS (iClk, iRst_n) IS

  BEGIN

    IF iRst_n = '0' THEN

      oLink   <= '0';

      oSpeed  <= B"00";

      oDuplex <= '0';

    ELSIF rising_edge(iClk) THEN

      IF iRxEr = '0' AND iRxDV = '0' THEN

        oLink   <= iRxData(0);          -- 0=down,1=up

        oSpeed  <= iRxData(2 DOWNTO 1);  -- 00=10Mbps,01=100Mbps,10=1000Mbps,11=reserved

        oDuplex <= iRxData(3);          -- 0=half-duplex,1=full-duplex

      END IF;

    END IF;

  END PROCESS;

  oEOF    <= eof;

  oCRCErr <= crcErr;

  -- delay! IN order TO get OUT OF the CRC part

  rxDV    <= iRxDV AND dataEn AND NOT iRxEr;

  oRxData <= dataDly(3);

  --oRxDV   <= dvDly(3) AND rxDV;

  oRxDV   <= dvDly(3) AND dataEn;       -- changed @ 2013-05-20

  PROCESS (iClk, iRst_n) IS

  BEGIN

    IF iRst_n = '0' THEN

      dvDly      <= (OTHERS => '0');

      dataDly(0) <= (OTHERS => '0');

      dataDly(1) <= (OTHERS => '0');

      dataDly(2) <= (OTHERS => '0');

      dataDly(3) <= (OTHERS => '0');

    ELSIF rising_edge(iClk) THEN

      dvDly      <= dvDly(2 DOWNTO 0) & rxDV;

      dataDly(3) <= dataDly(2);

      dataDly(2) <= dataDly(1);

      dataDly(1) <= dataDly(0);

      dataDly(0) <= iRxData;

    END IF;

  END PROCESS;

  crcEn2 <= crcEn AND iRxDV AND NOT iRxEr;

  crcCheck : ENTITY work.eth_crc32

    PORT MAP (

      iClk    => iClk,

      iRst_n  => iRst_n,

      iInit   => sof,

      iCalcEn => crcEn2,

      iData   => iRxData,

      oCRC    => OPEN,

      oCRCErr => crcErr);

  PROCESS (iClk, iRst_n) IS

    VARIABLE ethType : STD_LOGIC_VECTOR(15 DOWNTO 0);

  BEGIN

    IF iRst_n = '0' THEN

      state        <= IDLE;

      eof          <= '0';

      byteCnt      <= (OTHERS => '0');

      oPayloadLen  <= (OTHERS => '0');

      oGetCtrl     <= '0';

      oGetARP      <= '0';

      oGetIPv4     <= '0';

      oGetRaw      <= '0';

      --oDrop       <= '0';

      frm4Me       <= '0';

      crcEn        <= '0';

      sof          <= '0';

      dataEn       <= '0';

      destMACAddr  <= (OTHERS => '0');

      oTagInfo2    <= (OTHERS => '0');

      oTaged       <= '0';

      oStackTaged  <= '0';

      oTagInfo     <= (OTHERS => '0');

      oLenErr      <= '0';

      oCheckSumErr <= '0';

      oSOF         <= '0';

    ELSIF rising_edge(iClk) THEN

      --oGetCtrl <= '0';

      --oGetARP  <= '0';

      --oGetIPv4 <= '0';

      --oGetRaw  <= '0';

      eof  <= '0';

      --oDrop    <= '0';

      sof  <= '0';

      oSOF <= '0';

      IF iRxDV = '1' AND iRxEr = '1' THEN

        oRxErr <= '1';

      END IF;

      CASE state IS

        WHEN IDLE =>

          crcEn        <= '0';

          dataEn       <= '0';

          frm4Me       <= '0';

          oGetCtrl     <= '0';

          oGetARP      <= '0';

          oGetIPv4     <= '0';

          oGetRaw      <= '0';

          oRxErr       <= '0';

          oTaged       <= '0';

          oStackTaged  <= '0';

          oLenErr      <= '0';

          oCheckSumErr <= '0';

          IF iRxData = X"55" THEN

            state   <= SFD;

            byteCnt <= (OTHERS => '0');

            sof     <= '1';

          END IF;

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

        WHEN SFD =>

          IF iRxData = X"55" THEN

            byteCnt <= byteCnt + 1;

          ELSIF iRxData = X"D5" THEN

            IF byteCnt(2 DOWNTO 0) = B"110" THEN

              state   <= DEST_MAC;

              crcEn   <= '1';

              dataEn  <= '1';           -- 2013-05-13

              oSOF    <= '1';

              byteCnt <= (OTHERS => '0');

            ELSE

              state <= IDLE;

            END IF;

          ELSE

            state <= IDLE;

          END IF;

          IF iRxDV = '0' THEN

            state   <= IDLE;

            eof     <= '1';

            oLenErr <= '1';

          END IF;

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

        WHEN DEST_MAC =>

          IF iRxDV = '1' AND iRxEr = '0' THEN

            byteCnt <= byteCnt + 1;

            CASE byteCnt(2 DOWNTO 0) IS

              WHEN B"000" => destMACAddr(47 DOWNTO 40) <= iRxData;

              WHEN B"001" => destMACAddr(39 DOWNTO 32) <= iRxData;

              WHEN B"010" => destMACAddr(31 DOWNTO 24) <= iRxData;

              WHEN B"011" => destMACAddr(23 DOWNTO 16) <= iRxData;

              WHEN B"100" => destMACAddr(15 DOWNTO 8)  <= iRxData;

              WHEN B"101" =>

                byteCnt(2 DOWNTO 0) <= (OTHERS => '0');

                state               <= SOURCE_MAC;

                IF destMACAddr(47 DOWNTO 8)&iRxData = iMyMAC  -- unicast

                            OR destMACAddr(47 DOWNTO 8)&iRxData = MAC_ADDR_CTRL  -- multicast for flow control

                            OR destMACAddr(47 DOWNTO 8)&iRxData = X"FFFFFFFFFFFF" THEN  -- broadcast

                  --oDrop <= '1';

                  frm4Me <= '1';

                END IF;

              WHEN OTHERS => NULL;

            END CASE;

          END IF;

          IF iRxDV = '0' THEN

            state   <= IDLE;

            eof     <= '1';

            oLenErr <= '1';

          END IF;

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

        WHEN SOURCE_MAC =>

          IF iRxDV = '1' AND iRxEr = '0' THEN

            byteCnt <= byteCnt + 1;

            IF byteCnt(2 DOWNTO 0) = B"101" THEN

              state               <= FRAME_TYPE;

              byteCnt(2 DOWNTO 0) <= (OTHERS => '0');

            END IF;

          END IF;

          IF iRxDV = '0' THEN

            state   <= IDLE;

            eof     <= '1';

            oLenErr <= '1';

          END IF;

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

        WHEN FRAME_TYPE =>

          IF iRxDV = '1' AND iRxEr = '0' THEN

            byteCnt <= byteCnt + 1;

            IF byteCnt(0) = '0' THEN

              destMACAddr(15 DOWNTO 8) <= iRxData;

            ELSE

              byteCnt(1 DOWNTO 0) <= (OTHERS => '0');

              ethType             := destMACAddr(15 DOWNTO 8) & iRxData;

              IF ethType < X"0600" AND ethType > X"0000" THEN

                oGetRaw <= frm4Me;

                state   <= PAYLOAD;

                dataEn  <= '1';

              END IF;

              oPayloadLen <= UNSIGNED(ethType);

              -- check the ethnert frame TYPE ,only ARP AND IP PACKAGE are wanted

              CASE ethType IS

                WHEN ETH_TYPE_IPv4 =>

                  oGetIPv4 <= frm4Me;

                  state    <= PAYLOAD;

                  dataEn   <= '1';

                WHEN ETH_TYPE_ARP =>

                  oGetARP <= frm4Me;

                  state   <= PAYLOAD;

                  dataEn  <= '1';

                WHEN ETH_TYPE_CTRL =>

                  oGetCtrl <= frm4Me;

                  state    <= PAYLOAD;

                  dataEn   <= '1';

                WHEN x"8100" =>

                  oTaged <= '1';

                  state  <= TAG_INFO1;

                  dataEn <= '0';

                WHEN x"88A8" | x"9100" =>

                  oStackTaged <= '1';

                  state       <= TAG_INFO1;

                  dataEn      <= '0';

                WHEN OTHERS =>          --oDrop    <= '1';

                  state  <= PAYLOAD;

                  dataEn <= '0';

                  frm4Me <= '0';        -- add @ 2013-05-13

              END CASE;

            END IF;

          END IF;

          IF iRxDV = '0' THEN

            state   <= IDLE;

            eof     <= '1';

            oLenErr <= '1';

          END IF;

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

        WHEN TAG_INFO1 =>

          IF iRxDV = '1' AND iRxEr = '0' THEN

            byteCnt <= byteCnt + 1;

            IF byteCnt(0) = '0' THEN

              oTagInfo(15 DOWNTO 8) <= iRxData;

            ELSE

              byteCnt(1 DOWNTO 0)  <= (OTHERS => '0');

              oTagInfo(7 DOWNTO 0) <= iRxData;

              IF oStackTaged = '1' THEN

                state <= TAG_INFO2;

              ELSE

                state <= FRAME_TYPE;

              END IF;

            END IF;

          END IF;

          IF iRxDV = '0' THEN

            state   <= IDLE;

            eof     <= '1';

            oLenErr <= '1';

          END IF;

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

        WHEN TAG_INFO2 =>

          IF iRxDV = '1' AND iRxEr = '0' THEN

            byteCnt <= byteCnt + 1;

            CASE byteCnt(1 DOWNTO 0) IS

              -- we do NOT check,but 0x8100 is expected!

              WHEN B"00" => NULL;

              WHEN B"01" => NULL;

              WHEN B"10" =>

                oTagInfo2(15 DOWNTO 8) <= iRxData;

              WHEN B"11" =>

                oTagInfo2(7 DOWNTO 0) <= iRxData;

                byteCnt(2 DOWNTO 0)   <= (OTHERS => '0');

                state                 <= FRAME_TYPE;

              WHEN OTHERS => NULL;

            END CASE;

          END IF;

                             IF iRxDV = '0' THEN

                               state   <= IDLE;

                               eof     <= '1';

                               oLenErr <= '1';

                             END IF;

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

        WHEN PAYLOAD =>

          IF oGetRaw = '1' THEN

            IF byteCnt + 1 = oPayloadLen THEN                 -- PAD truncation

              dataEn <= '0';

            END IF;

          END IF;

          IF iRxDV = '1' THEN

            IF iRxEr = '0' THEN

              byteCnt <= byteCnt + 1;

            END IF;

          ELSE

            state <= IDLE;

            eof   <= '1';

            IF rCheckSumOk THEN

              oCheckSumErr <= '0';

            ELSE

              oCheckSumErr <= '1';

            END IF;

            IF frm4Me = '0' THEN        -- add @ 2013-05-13

              oLenErr <= '1';

            END IF;

            IF oGetRaw = '0' THEN

              -- oPayloadLen <= byteCnt - 4; change @ 2013-05-13

              oPayloadLen <= 14 + byteCnt - 4;

            ELSIF oPayloadLen > byteCnt - 4 THEN

              oLenErr <= '1';

            END IF;

            -- add @ 2013-05-13

            IF oGetRaw = '1' THEN

              oPayloadLen <= oPayloadLen + 14;

            END IF;

            IF byteCnt > X"0600" OR byteCnt < X"0020" THEN

              oLenErr <= '1';

            END IF;

          END IF;

        WHEN OTHERS => state <= IDLE;

      END CASE;

    END IF;

  END PROCESS;

END ARCHITECTURE rtl;