Page 1279 - 5G Basics - Core Network Aspects
P. 1279

Transport aspects                                              2


            R_BLOCK_TYPE = {C, S, T, D, E, M}

                    This function classifies each 66-bit rx_tcd vector as belonging to one of the six types depending on
                    its contents.
                    Values: C, S, T, and D are defined in clause 49.2.13.2.3 of [IEEE 802.3].
                        M: the vector contains a sync header of 10 and is recognized as a valid PCS lane alignment
                        marker by using the state machine shown in Figure F.3.
                        E: the vector does not meet the criteria for any other value.

            R_TYPE(rx_tcd<65:0>)
                    Returns the R_BLOCK_TYPE of the rx_tcd<65:0> bit vector.

            R_TYPE_NEXT
                    Prescient  end  of  packet  check  function.  It  returns  the  R_BLOCK_TYPE  of  the  rx_tcd  vector
                    immediately following the current rx_tcd vector.
            F.3.2.4      Counters

            cnt
                    Count up to a maximum of p of the number of PCS lanes.

            F.3.3   State diagrams
            The receive state machine for a series of 513-bit blocks shown in Figure F.2 determines whether the 513-bit
            block contains valid eight 66-bit blocks or not.


                                         re
                                         reset + 1027B_hi_ber + set + 1027B_hi_ber +
                                         !1027B_block_lock1027B_block_lock
                                         !
                                            R R RX513B_INITX513B_INITX513B_INIT
                                                              POS_violation +S_violation +
                                    rx rx                     PO
                                    rx513_raw  8 x EBLOCK_T 513_raw  8 x EBLOCK_T 513_raw  8 x EBLOCK_T
                                                              s
                                                              seq_violation +eq_violation +
                                                              Mseq_violationeq_violation
                                                              Ms
                                      !
                                      !POS_violation *POS_violation *
                                      ! !seq_violation *seq_violation *
                                      !
                                      !Mseq_violationMseq_violation
                                                        V V V
                                           R R
                                           RX513B_VALIDX513B_VALIDX513B_VALID
                          !POS_violation *POS_violation *  rx513_raw  DECODE(rx513_coded)513_raw  DECODE(rx513_coded)513_raw  DECODE(rx513_coded)
                          !
                                    rx rx
                          !seq_violation *seq_violation *   POS_violation +S_violation +
                          !
                                                            PO
                          ! !Mseq_violationMseq_violation
                                                            s
                                                            seq_violation +eq_violation +
                                                            Mseq_violationeq_violation
                                                            Ms
                                                                    R R
                                                                    RX513B_INVALIDX513B_INVALIDX513B_INVALID
                                                             rx rx
                                                             rx513_raw  8 x EBLOCK_T513_raw  8 x EBLOCK_T513_raw  8 x EBLOCK_T
                                                                                     PO
                                                             seq_violation  Falseeq_violation  Falseeq_violation  False  POS_violation +S_violation +
                                                             s s
                                                             Mseq_violation  Falseeq_violation  Falseeq_violation  False
                                                             Ms
                                                                                     s
                                                             Ms                      seq_violation +eq_violation +
                                                                                     Ms
                                                     !
                                                     !POS_violation *POS_violation *  Mseq_violationeq_violation
                                                     ! !seq_violation *seq_violation *
                                                     !Mseq_violationMseq_violation
                                                     !
                                                               V V V V
                               Figure F.2 – Receive state machine for the 512B/513B code blocks
                                             including lane alignment markers
            The trans-decode state machine for a series of 66-bit blocks shown in Figure F.3 checks the block type
            sequence of recovered 66-bit blocks.
            The PCS lane alignment marker state machine for a series of 66-bit blocks shown in Figure F.4 detects the
            alignment markers every p  16384 blocks and checks whether the marker is in ascendant order or not.
                                                                                                        1269
   1274   1275   1276   1277   1278   1279   1280   1281   1282   1283   1284