/*******************************************************************************
################################################################################
#   Copyright (c) [2017-2019] [Radisys]                                        #
#                                                                              #
#   Licensed under the Apache License, Version 2.0 (the "License");            #
#   you may not use this file except in compliance with the License.           #
#   You may obtain a copy of the License at                                    #
#                                                                              #
#       http://www.apache.org/licenses/LICENSE-2.0                             #
#                                                                              #
#   Unless required by applicable law or agreed to in writing, software        #
#   distributed under the License is distributed on an "AS IS" BASIS,          #
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
#   See the License for the specific language governing permissions and        #
#   limitations under the License.                                             #
################################################################################
*******************************************************************************/

/********************************************************************20**
  
        Name:     NR RLC file for downlink and non real time tasks 
    
        Type:     C include file
  
        Desc:     This file contains helper macros for RLC downlink
                  and non real time task
 
        File:     rlc_dl.h
  
*********************************************************************21*/
/** @file rlc_dl.h
@brief RLC Downlink helper macros 
*/

#ifndef __RLC_DLH__
#define __RLC_DLH__

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#ifdef TENB_STATS
#ifndef L2_l3_SPLIT
#include "pj_tenb_stats.x"
#else
#include "l2_tenb_stats.x"
#endif
#endif

#define RLC_DL_INST 1
#define RLC_MAX_RNG_DEQ_INDX 8

/* Below are the status used within RLC */
#define RLC_SDU_OPAT_NOUPDATE 0
#define RLC_SDU_OPAT_UPD_TX 1
#define RLC_SDU_OPAT_UPD_RETX   2

/* Below are the status which needs to be updated to MAC */
#define RLC_RGU_SDU_OPAT_NOUPDATE 0
#define RLC_RGU_SDU_OPAT_UPDATE   1
#define RLC_RGU_SDU_OPAT_BREACH   2

/* PDB Values for various QCI bearers : This value is considered 
   after taking into account a 20ms delay at the network */
#define RLC_PDB_VALUE_FOR_QCI1    80
#define RLC_PDB_VALUE_FOR_QCI2    130
#define RLC_PDB_VALUE_FOR_QCI3    30
#define RLC_PDB_VALUE_FOR_QCI4    280
#define RLC_PDB_VALUE_FOR_QCI5    80
#define RLC_PDB_VALUE_FOR_QCI6    280
#define RLC_PDB_VALUE_FOR_QCI7    80
#define RLC_PDB_VALUE_FOR_QCI8    280
#define RLC_PDB_VALUE_FOR_QCI9    280

#define RLC_DATA_BITMASK          0x80 /* Data bitmask is used to fill D/C bit for data*/
/**
 * @def RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB
 *
 *    This macro is used to check if DL IP throughput measurement is ON
 *    or off for the passed rb
 *
 *    Returns TRUE (non-zero) if measurement is ON else FALSE (zero)
 *
 * @param[in] _gCb     RLC DL Cb
 * @param[in] _rbCb    RLC downlink control block
 *
*/ 
#ifdef LTE_L2_MEAS
#define RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
     ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
            (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci]))

#define RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
     ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
      (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_IP) && \
      (_rbCb->rbL2Cb.measOn & LKW_L2MEAS_DL_IP))

#define RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
     ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
            (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_DELAY))

#define RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
     ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
            (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UU_LOSS))
#define RLC_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _rlcRbCb, _delay)                     \
{                                                                              \
   if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                               \
      ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DELAY))    \
   {                                                                           \
      (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DELAY]->dlPjSduDelay.sduDelay += _delay; \
      (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DELAY]->dlPjSduDelay.numSdus++; \
   }                                                                    \
}

#define RLC_UPD_L2_UU_LOSS_PKTS(_rlcCb, _rlcRbCb, _val)                         \
{                                                                 \
   if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
      ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_UU_LOSS))              \
   {                                                              \
      (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_UU_LOSS]->uuLoss.dLoss += _val;     \
   }                                                              \
}
#define RLC_UPD_L2_UU_LOSS_POS_PKTS(_rlcCb,_rlcRbCb,_val)                         \
{                                                                 \
   if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
      ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_UU_LOSS))              \
   {                                                              \
      (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_UU_LOSS]->uuLoss.posPkts += _val;     \
   }                                                              \
}
/* Discard new changes starts */
#define RLC_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_rlcRbCb)                         \
{                                                                 \
   if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
      ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC))              \
   {                                                              \
      (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DISC]->dlDisc.discSdus++;     \
   }                                                              \
}                                              

#define RLC_UPD_L2_DL_TOT_SDU_STS(_rlcCb,_rlcRbCb)                             \
{                                                                 \
   if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
      ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC))   \
   {                                                              \
      (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DISC]->dlDisc.totSdus++;      \
   }                                                              \
}

#define RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _rlcRbCb)                 \
{                                                                 \
   if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                    \
      ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC))   \
   {                                                              \
      uint32_t idx1;                                                    \
      for (idx1 = 0; idx1 < LKW_MAX_L2MEAS; idx1++)                  \
      {                                                           \
         if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC)                 \
         {                                                        \
            if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci > 0) \
            {                                                                                               \
               _rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci--;   \
               if (_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci == 0) \
               {                                                                                                 \
                  _rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.qci[(_rlcRbCb)->qci] = 0;                      \
                  memset(&_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci], 0,  \
                     sizeof(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci]));            \
               }                                                                                                 \
            }                                                                                                    \
         }                                                                                                       \
      }                                                                                                          \
   }                                                                                                             \
}
#else
#define RLC_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _rlcRbCb, _delay)
#define RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)
#define RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)
#define RLC_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_rlcRbCb)
#define RLC_UPD_L2_DL_TOT_SDU_STS(_rlcCb, _rlcRbCb)
#define RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _rlcRbCb)
#endif


typedef struct rlcDlUeCb RlcDlUeCb;

/** 
 * @brief  Structure to hold the SN of the PDU onto which a SDU is mapped
 *
 * @details
 *    - sn : Sequence number of the AM pdu
*/
typedef struct rlcPduMap
{
  RlcSn   sn;     /*!< Mapped PDU's SN */
}RlcPduMap;

/** 
 * @brief  Structure to hold information regarding a SDU received from PDCP
 *
 * @details
 *    - lstEnt : Used for linking ( we have linked list of SDUs) which forms
 *               the SDU queue
 *    - mBuf   : Pointer to the SDU data
 *    - sduSz  : Size of the mBuf above
 *    - actSz  : Length of the SDU when received from PDCP, this might be 
 *               different from sduSz, in case when the SDU is split
 *    - mode   : Depending on the type, holds AM, UM or TM mode information
 *      - tm
 *        - sfn      : System Frame number for BCCH/PCCH
 *        - subframe : Subframe number
 *        - rnti     : RNTI for CCCH
 *      - um
 *        - sduId       : Unique identity for the SDU
 *        - isSegmented : Whether this SDU is segmented into multiple PDUs
 *      - am
 *        - sduId       : Unique identity for the SDU
 *        - rcvdSz      : Length of this SDU which is received by the peer
 *        - isSegmented : Whether this SDU is segmented into multiple PDUs
*/
typedef struct rlcSdu                        
{
   CmLList   lstEnt;     /*!< List entry for SDU */
   Buffer    *mBuf;      /*!< SDU buffer */ 
   MsgLen    sduSz;      /*!< Buffer Size */
   MsgLen    actSz;      /*!< Actual buffer Size */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
   RlcSduSnMap  *snMap;   /*!< Sdu and the list of SN it maps to */
#endif /* LTE_L2_MEAS */

   union
   {
      struct   _t 
      {
         uint16_t    sfn;        /*!< Sub frame number for BCCH/PCCH */
         uint16_t    slot;   /*!< Subframe number */
         CmLteRnti   rnti;       /*!< RNTI for CCCH */
#ifdef EMTC_ENABLE
         uint8_t          emtcDiReason; /*!< DI reason */
         uint8_t          pnb;       /*!<narrow band on which Ue performs Paging*/
#endif
      }tm;   /*!< SDU for TM mode */

      struct   _u
      {
         uint32_t  sduId;         /*!< SDU Identifier */
         Bool      isSegmented;   /*!< Flag to indicate if the SDU is segmented */
      }um;   /*!< SDU for UM mode */

      struct   _a
      {
         uint32_t   sduId;                    /*!< SDU Identifier */
         MsgLen     rcvdSz;                   /*!< Recvd SDU Size from peer */
         Bool       isSegmented;              /*!< Is SDU segmented */
         RlcSn        sn;                       /*!< SN assigned to this SDU*/
      }am;   /*!< SDU for AM mode */
   }mode;   /*!< RLC mode specific SDUs */
   /* Discard new changes starts */
   Ticks               arrTime;     /*!< Arrival time of the PDCP PDU at RLC */
   /* Discard new changes ends */

}RlcSdu;

/** @addtogroup tmmode */
/*@{*/

/** 
 * @brief  Structure to hold Transparent Mode information for a RB
 *
 * @details
 *    - sduQ : Queue of SDUs
*/
typedef struct rlcTm
{
   CmLListCp sduQ; /*!< SDU queue for TM */
}RlcTm;
/*@}*/

/** 
 * @brief  Structure to hold buffer occupancy report sent to MAC
 *
 * @details
 *    - bo         : Size of the buffers at RLC
 *    - estHdrSz   : Size for all the headers as estimated by RLC
 *    - staPduPrst : Whether RLC wants to send a STATUS PDU or not
*/
typedef struct rlcBoRep
{
   int32_t  bo;            /*!< Buffer occupancy */
   uint16_t estHdrSz;      /*!< Estimated header size for the bo */
   bool     staPduPrsnt;   /*!< Indicate control bo present or not */
   uint32_t staPduBo;     /*!< Indicate bo for control PDU */
   uint32_t oldestSduArrTime;
} RlcBoRep;

/** 
 * @brief  Structure to hold information sent to MAC in a Data Request
 *
 * @details
 *    - pduSz   : Sum total of sizes of all the PDUs being sent
 *    - pduInfo : Information about each PDU
 *    - boRep   : Current buffer occupancy report
*/
typedef struct rlcDatReq
{
   MsgLen      pduSz;         /*!< PDU(s) size indicated by MAC */ 
   KwPduInfo   pduInfo;       /*!< PDU Information for lChs within UE */
   RlcBoRep     boRep;         /*!< BO report */ 
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
   KwLchMapInfo lchMapInfo;   /*!< Logical channel mapping info */
   uint32_t          totMacGrant;
#endif /* LTE_L2_MEAS */
}RlcDatReq;

/** @defgroup ummode UM Module Info 
*/

/** @addtogroup ummode */
/*@{*/
/** 
 * @brief  Structure to hold Unacknowledged mode downlink information for a RB
 *
 * @details
 *    - sduQ        : Control point for the queue of SDUs
 *    - snLen       : length of the squence number. Here it is stored 
 *                    as 1 for 5 bit sequence numbers and 
 *                    2 for 10 bit sequence numbers
 *    - bo          : Current buffer occupancy for this RB
 *    - TX_Next     : SN to be allocated to next SDU
 *    - modBitMask  : Bitmask used to do modulus operations to wrap around 
 *                    state variables, value is 0x3f or 
 *                    0xfff for 6-bit and 12-bit sequence numbers respectively
*/
typedef struct rlcUmDl
{
   CmLListCp   sduQ;            /*!< SDU queue for UM */
   uint8_t     snLen;           /*!< Sequence number length */
   int32_t     bo;              /*!< Buffer occupancy */
   RlcSn       txNext;          /*!< TX_Next */
   uint16_t    modBitMask;      /*!< Bitmask for modulus to wrap around vars*/   
}RlcUmDl;

/** 
 * @brief  Structure to hold information about which SDUs a PDU/segment carries
 *
 * @details
 *    - sduSz  : Size of the SDU or part of it
 *    - sdu    : Pointer to the SDU
*/
typedef struct rlcSduMap
{
   /*MsgLen   actSz;*/         /*!< SDU Size */
   MsgLen   sduSz;         /*!< SDU Size */
   /*Bool     isSegmented;*/   /*!< Flag to indicate if the SDU is segmented */
   RlcSdu*   sdu;           /*!< Pointer to the associated SDU */
}RlcSduMap;

/** 
 * @brief  Structure to hold info about a PDU/segment to be re-transmitted
 *
 * @details
 *    - lstEnt           : Control point to link the re-transmit (the 
 *                         re-transmit PDUs  ,segments are stored as a 
 *                         link list) nodes
 *    - seg              : Pointer to the data
 *    - segSz            : Size of the PDU/segment including the header
 *    - hdrSz            : Size of the AM header for this in bytes
 *    - amHdr            : The header for this PDU/segment
 *    - soEnd            : SO End
 *    - retxCnt          : Number of times this has been re-transmitted
 *    - yetToConst       : Whether the PDU/segment has been constructed (headers
 *                         appended) or not
 *    - pendingReTrans   : TRUE if this node is to be re-transmitted else FALSE
 *    - numSdu           : Number of SDUs this PDU/segment carries
 *    - sduMap           : Infomation about the SDUs this node carries
*/
typedef struct rlcRetx
{
   CmLList    lstEnt;              /*!< List entry for Retransmission PDU */
   Buffer     *seg;                /*!< Buffer of PDU or Segment */
   MsgLen     segSz;               /*!< Segment Size */
   MsgLen     hdrSz;               /*!< Header size for the segment */
   RlcAmHdr   amHdr;               /*!< AM header Info */
   uint16_t   soEnd;               /*!< Segment Offset End */
   RlcSn      retxCnt;             /*!< Retransmission count */
   Bool       yetToConst;          /*!< Yet to construct seg flag */
   Bool       pendingReTrans;      /*!< Is node waiting for re-transmission */
   RlcSduMap  sduMap;              /*!< SDU mapped with PDU */
}RlcRetx;

/** 
 * @brief  Structure to hold a RLC AM PDU Information
 *
 * @details
 *    - lstEnt : This is required for the linked list in which pdu is stored
 *    - pdu    : Holds the pdu
 *    - pduSz  : The length of the segment in bytes
 *    - hdrSz  : Header size of this PDU
 *    - amHdr  : The AM Header for the PDU segment
 *    - RlcSduMap :SDU map info for this PDU 
 *
*/
typedef struct rlcDlPduInfo
{
   CmLList   lstEnt;               /*!< List entry for PDU list */
   Buffer     *pdu;                /*!< Buffer of PDU */
   MsgLen     pduSz;               /*!< PDU Size */
   MsgLen     hdrSz;               /*!< Header size for the segment */
   RlcAmHdr    amHdr;               /*!< AM header Info */
   RlcSduMap   sduMap;              /*!< SDU info for this PDU */

}RlcDlPduInfo;

/** 
 * @brief  Structure to hold info about a PDU that has been transmitted
 *
 * @details
 *    - lnk    : Link to the TX buffer list
 *    - sn     : SN of this RLC SDU
 *    - rlsLnk : Link to store on release list, used for
 *    - pduLst : It contains all PDUs of a particular SN
*/
typedef struct rlcTx
{
   CmLList     lnk;                /**< Link to the TX buffer list*/
   RlcSn        sn;                /*!< SN of this RLC SDU */
   CmLList    rlsLnk;             /*!< Lnk to store on release lst */
   CmLListCp  pduLst;             /*!< It contains all PDUs of a particular SN*/
}RlcTx;

/** @addtogroup ammode */
/*@{*/

/** 
 * @brief  Structure to hold Acknowledged Mode Downlink information for a RB
 *
 * @details
 *    - sduQ           : SDU queue
 *    - nxtTx          : Pointer to the next SDU to be transmitted
 *    - pollRetxTmr    : Poll re-transmission timer
 *    - pollRetxTmrInt : Timer interval (?? secs) of poll re-transmission timer
 *    - pollPdu        : Number of PDUs to send before sending a poll bit
 *    - pollByte       : Number of bytes to send before sending a poll bit
 *    - maxRetx        : Maximum number of re-transmissions to be done for a 
 *                       PDU/segment
 *    - cntrlBo        : Size of the STATUS PDU if it is to be sent, else 0
 *    - retxBo         : Bo of the PDUs/segments to be re-transmitted
 *    - estHdrSz       : Extimated header size of all the SDUs in the queue
 *    - bo             : Bo of the PDUs in the transmission buffer
 *    - txBufLst       : Transmission buffer lists. It's contiguous index by sequence
 *                       number
 *    - rextLst        : Re-transmission buffer. It is a doubly linked list
 *    - nxtRetx        : Next node to be re-transmitted
 *    - txNext         : 5GNR - TX_Next - Send state variable,( in LTE VT(S)) 
 *    - txNextAck      : 5GNR - TX_Next_Ack- Acknowledgement state variable
                       : (in LTE VT(A))     
 *    - pduWoPoll      : Number of PDUs sent without sending a poll bit
 *    - byteWoPoll     : Number of bytes sent without sending a poll bit
 *    - pollSn         : The sequence number on which the last poll bit was sent
 *    - mBuf           : The encoded STATUS pdu to be sent
 *    - maxReTxReached : Whether maximum number of re-transmissions has been
 *                       reached or not
 *    - pStaPdu        : Stores the control pdu (information required to
 *                       create the STATUS PDU) passed from AM uplink
*/
typedef struct rlcAmDl
{
   CmLListCp        sduQ;             /*!< SDU queue */
   RlcSdu           *nxtTx;           /*!< Next SDU to be transmitted */
   CmTimer          pollRetxTmr;      /*!< T_poll_retransmit Timer */
   uint16_t         pollRetxTmrInt;   /*!< Timer Interval */
   int16_t          pollPdu;          /*!< Poll_PDU */
   int32_t          pollByte;         /*!< Poll_Byte */
   uint8_t          maxRetx;          /*!< Max_Retx_Threshold */
   int32_t          cntrlBo;          /*!< BO of control pdu */ 
   int32_t          retxBo;           /*!< BO of Retransmission PDUs */ 
   uint32_t         estHdrSz;         /*!< Estimated header size for the BO */
   int32_t          bo;               /*!< BO of new PDUs */
#ifndef LTE_TDD 
   CmLListCp        *txBufLst;       /*!< Transmission buffer list of type RlcTx */
#else
//   RlcTx             *txBuf[1024];          /*!< Transmission buffer */
#endif
   CmLListCp        retxLst;          /*!< Retransmission PDU list */
   RlcRetx          *nxtRetx;         /*!< Next node to be retransmitted */
   RlcSn            txNext;           /*!< 5GNR: TX_Next, in LTE  VT(S) */
   RlcSn            txNextAck;        /*!< 5GNR: TX_Next_Ack, in LTE VT(A)*/ 
   int16_t          pduWoPoll;        /*!< PDU without poll bit counter */
   int32_t          byteWoPoll;       /*!< Byte without poll bit counter */
   RlcSn            pollSn;           /*!< Poll SN */
   Buffer           *mBuf;            /*!< this can be removed later 
                                           Stores the Control Pdu */
   Bool             maxReTxReached;   /*!< Set when the DL MAX Retx exceeded */
   RlcUdxDlStaPdu*  pStaPdu;          /*!< The Control Pdu passed from UL*/
   uint8_t          snLen;           /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
   uint32_t         snModMask;       /*!< (2 Pwr SnLen - 1): 5GNR RLC */
}RlcAmDl;

/*@}*/

/** 
 * @brief  Structure to hold information about a Radio Bearer as required by RLC
 *
 * @details
 *    - rlcId          : RLC identifier, uniquely identifies a Radio Bearer
 *    - lch            : Information (type and id) of the logical channel 
 *                       associated with this Radio  Bearer.
 *    - mode           : The mode of the Radio Bearer TM or UM or AM
 *    - dir            : The direction of the Radio Bearer, downlink or 
 *                       uplink or both
 *    - inst           : Id of RLC instance where this Radio Bearer is present. 
 *                       Used to find the instance from the Radio Bearer for 
 *                       memory needs as different instances might have 
 *                       different memory.
 *    - k1wuSapId       : KWU SAP identifier
 *    - udxSapId       : UDX SAP idenrifier
 *    - transId        : Stores the transaction identifier used to communicate 
 *                       with MAC, the same value as sent by MAC is passed back 
 *                       for it to be able to corelate
 *    - reestInProgress: Whether re-establishment is going on for this RB
 *    - m              : Mode of the RB (TM/UM/AM)
 *      - tm           : Transparent Mode information
 *      - umDl         : Unacknowledged Mode downlink information
 *      - amDl         : Acknowledged Mode downlink information
 *    - rlsLnk         : Link list used to free the RbCb
 *    - cleanupStarted : Whether cleanup of RB is in progress or not
*/
typedef struct _rlcDlRbCb
{
   uint8_t              qci;                /*!< qci of the RB */
#ifdef LTE_L2_MEAS
   RlcDlUeCb        *ueCb;              /*!< Pointer to UeCb  */
   RlcL2MeasRbCb    rbL2Cb;             /*!< RB measurement L2 Cb */
   CmLListCp       sduSnMapQ;          /*!< SDU SN map queue for UM */

   RlcL2MeasIpThruput l2MeasIpThruput;  /*!< Holds related parameter for
                                                 DL/UL ip throughput>*/
#endif                                                 

   /* Discard new changes starts */
   S16             discTmrInt;        /*!< The discard time in milli 
                                           seconds for an PDCP SDU for this RB */
   /* Discard new changes ends */
   CmLteRlcId     rlcId;           /*!< RLC Identifier */
   RlcLchInfo     lch;             /*!< Logical Channel Info  */
   Snssai         *snssai;
   CmLteRlcMode   mode;            /*!< Entity Mode */
   uint8_t        dir;             /*!< Direction for UL/DL */
   Inst           inst;            /*!< Tapa Instance where rb created */
   SpId           k1wuSapId;        /*!< KWU sap Id, to get the KwuSapCb */
   SpId           udxSapId;        /*!< UDX sap Id, to get the UdxSapCb */
   uint32_t       transId;         /*!< Transaction Id for RLC */
   Bool           reestInProgress; /*!< Is reestablishment in progress */
   SpId           rguSapId;        /*!< RGU Instance SAP corresponding to this RB */
   union          
   {
      RlcTm     tm;     /*!< TM mode specific elements */
      RlcUmDl   umDl;   /*!< UM downlink elements */
      RlcAmDl   amDl;   /*!< AM downlink elements */
   }m;   /*!< RLC mode specific Info */
   CmLList   rlsLnk;   /*!< Link to add to release list */
   Bool      cleanupStarted; /*!< Whether cleanup of RB is in progress or not */
   uint32_t  lastRprtdBoToMac; /*!< Last Reported BO to MAC Layer */
   uint32_t  boUnRprtdCnt; /*!< Count to keep track of periodic BO Update */
}RlcDlRbCb;

/** 
 * @brief  Structure to hold mapping between logical channel and Radio Bearer
 *
 * @details
 *    - dlRbCb   : Pointer to the downlink Radio Bearer
*/
typedef struct rlcDlLch
{
   RlcDlRbCb *dlRbCb;   /*!< Pointer to Downlink RbCb */
}RlcDlLch;                                  

/** 
 * @brief  Structure to hold information about the Cells
 *
 * @details
 *    - cellHlEnt : Information about cells are stored in a hash table. This is
 *                  required for that.
 *    - cellId    : Identity of the cell
 *    - rbCb      : Radio Bearers in the cell
 *    - lCh       : Logical Channels in the cell
*/
typedef struct rlcDlCellCb
{
   CmHashListEnt   cellHlEnt;                 /*!< Hash list entry for CellCb */
   CmLteCellId     cellId;                    /*!< Cell Id */
   RlcDlRbCb        *rbCb[RLC_MAX_RB_PER_CELL]; /*!< RbCbs within a Cell */
   RlcDlLch         lCh[RLC_MAX_LCH_PER_CELL];  /*!< Array of Logical channels */
}RlcDlCellCb;

#ifdef LTE_L2_MEAS
/** @struct RlcContSduLst
 * Structure contains list of rbId and index to KwOutStngSduLst
 */
typedef struct rlcContSduLst
{
   CmLteLcId   lcId;    /*!< Holds the lcId of rbCb */
   uint8_t     numSdus; /*!< Number sdus in sduIdx array */
   uint8_t     sduIdx[RLC_L2MEAS_MAX_OUTSTNGSDU];  /*!< Hold the index to KwOutStngSduLst */
}RlcContSduLst;
typedef struct rlcSduInfo
{
   Bool  isRetxPdu;
   Ticks arvlTime; /* stores the the arrival time of each PDCP PDU */
}RlcSduInfo;

typedef struct rlclchInfo
{
   CmLteLcId   lcId;    /*!< Holds the lcId of rbCb */
   uint8_t     numSdus; /*!< Number sdus belonged to the this LC */
   RlcSduInfo  sduInfo[RLC_L2MEAS_SDUIDX];
}RlclchInfo;

/** @struct RlcL2MeasTb
 * Structure containes list of rbId and  index to KwOutStngSduLst
 */
typedef struct rlcL2MeasTb
{
   uint8_t          numLcId;       /* number of logical channels in this TbCb */
   RlcContSduLst    sduInfo[RLC_MAX_ACTV_DRB]; /*!< Contained sduLst for 
                                               outstanding sdu */
   uint8_t          numLchInfo;
   RlclchInfo       lchInfo[RLC_MAX_ACTV_DRB]; /* Holds the LC info details 
                                                  used for DL delay L2 Meas*/
   uint32_t         txSegSduCnt; /*!< This holds the no.of partially 
                                     transmitted SDU per TB which can be used for UU loss Meas*/
}RlcL2MeasTb;
#endif

/** 
 * @brief  Structure to hold information about the UEs
 *
 * @details
 *    - ueHlEnt : Information about cells are stored in a hash table. This is
 *                required for that.
 *    - key     : Key to store/find the UE in the hashtable
 *    - srbCb   : Signaling Radio Bearers configured for the UE
 *    - drbCb   : Data Radio Bearers configured for the UE
 *    - lCh     : Logical Channels in the UE
*/
struct rlcDlUeCb
{
   CmHashListEnt     ueHlEnt;                   /*!< Hash list entry for UeCb */
   CmLteRnti         ueId;     /*!< UE Id */
   CmLteCellId       cellId;   /*!< Cell Id */
   RlcDlRbCb         *srbCb[RLC_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */ 
   RlcDlRbCb         *drbCb[RLC_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */ 
   RlcDlLch          lCh[RLC_MAX_LCH_PER_UE];    /*!< Array of Logical channels */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
   uint16_t           numActRb[LKW_MAX_QCI];     /*!< number of RBs Active */
   uint8_t            tbIdx;                /*!< TBIDx for  measTbCb */
   RlcL2MeasTb        *l2MeasTbCb[RLC_MAX_TB_PER_UE]; /*!< Array of Measurement tbCb */
#endif /* LTE_L2_MEAS */
#ifdef TENB_STATS
   TSL2UeStatsCb   *tenbStats; /*!< UE Stats Holder */
#endif
};

/****************************************************************************
 *                      Declarations
 ***************************************************************************/
/****************************************************************************
 *                    Configuration Functions 
 ***************************************************************************/ 
S16 rlcCfgAddDlRb ARGS ((RlcCb *gCb, 
                              CmLteRnti ueId, 
                              CmLteCellId cellId, 
                              RlcEntCfgInfo *entCfg, 
                              RlcEntCfgCfmInfo *entCfm));

S16 rlcCfgReCfgDlRb ARGS ((RlcCb *gCb, 
                                 CmLteRnti ueId, 
                                 CmLteCellId cellId, 
                                 RlcEntCfgInfo *entCfg, 
                                 RlcEntCfgCfmInfo *entCfm));

S16 rlcCfgDelDlRb ARGS ((RlcCb *gCb, 
                               CmLteRnti ueId, 
                               CmLteCellId cellId, 
                               RlcEntCfgInfo *entCfg, 
                               RlcEntCfgCfmInfo *entCfm));

S16 rlcCfgDelDlUe ARGS ((RlcCb *gCb, 
                               CmLteRnti ueId, 
                               CmLteCellId cellId, 
                               RlcEntCfgInfo *entCfg, 
                               RlcEntCfgCfmInfo *entCfm));

S16 rlcCfgReEstDlRb ARGS ((RlcCb *gCb, 
                                 CmLteRnti ueId, 
                                 CmLteCellId cellId, 
                                 Bool sndReEst,
                                 RlcEntCfgInfo *entCfg, 
                                 RlcEntCfgCfmInfo *entCfm));

S16 rlcCfgDelDlCell ARGS ((RlcCb *gCb, 
                                 CmLteCellId cellId, 
                                 RlcEntCfgInfo *entCfg,
                                 RlcEntCfgCfmInfo *entCfm));

S16 rlcCfgDlUeIdChng ARGS ((RlcCb *gCb, 
                                  CkwUeInfo *ueInfo, 
                                  CkwUeInfo *newUeInfo, 
                                  CmStatus  *status));

/****************************************************************************
 *                    DBM module Functions 
 ***************************************************************************/
S16 rlcDbmDlInit ARGS ((RlcCb *gCb));

Void rlcDbmDlDeInit ARGS ((RlcCb *gCb));

S16 rlcDbmCreateDlUeCb ARGS ((RlcCb *gCb,     
                                    CmLteRnti ueId,   
                                    CmLteCellId cellId,
                                    RlcDlUeCb **ueCb));

uint8_t rlcDbmFetchDlUeCb ARGS ((RlcCb *gCb,        
                                   CmLteRnti ueId,      
                                   CmLteCellId cellId,     
                                   RlcDlUeCb **ueCb));

Void rlcDbmDelDlUeCb ARGS ((RlcCb *gCb,       
                                  RlcDlUeCb *ueCb, 
                                  Bool abortFlag));

Void rlcDbmDelAllDlUe ARGS ((RlcCb *gCb));

S16 rlcDbmCreateDlCellCb ARGS ((RlcCb *gCb,      
                                    CmLteCellId cellId,   
                                    RlcDlCellCb **cellCb));

uint8_t rlcDbmFetchDlCellCb ARGS ((RlcCb *gCb, 
                                     CmLteCellId cellId, 
                                     RlcDlCellCb **cellCb));

Void rlcDbmDelDlCellCb ARGS ((RlcCb *gCb, RlcDlCellCb *cellCb));

Void rlcDbmDelAllDlCell ARGS ((RlcCb *gCb));

Void rlcDbmFetchDlRbCbByRbId ARGS ((RlcCb *gCb, 
                                          CmLteRlcId *rlcId, 
                                          RlcDlRbCb **rbCb));

Void rlcDbmFetchDlRbCbFromLchId ARGS ((RlcCb *gCb,       
                                             CmLteRnti ueId,     
                                             CmLteCellId cellId,    
                                             CmLteLcId lcId,      
                                             RlcDlRbCb **rbCb));

Void rlcDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, uint8_t numRbCb));

S16 rlcDbmDlShutdown ARGS ((RlcCb *gCb));

Void rlcUtlGetCurrTime ARGS((uint32_t *time));
Void rlcUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t pktAdmitCnt ));
#ifdef LTE_L2_MEAS
Void rlcDbmDelAllDlL2MeasTbFrmUe ARGS ((RlcCb *gCb, RlcDlUeCb *ueCb));

#endif

/****************************************************************************
 *                    Transparent Mode Functions 
 ***************************************************************************/
Void rlcTmmQSdu ARGS ((RlcCb *gCb,
                            RlcDlRbCb *rbCb,
                            RlcDatReqInfo *datReqInfo,
                            Buffer *mBuf));
Void rlcTmmSendToMac ARGS ((RlcCb     *gCb,
                                SuId     suId,
                                RlcDlRbCb *rbCb, 
                                RguCStaIndInfo *staInd));

Void rlcDlTmmReEstablish ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));

/****************************************************************************
 *                    Unacknowledged Mode Functions 
 ***************************************************************************/
Void rlcUmmQSdu ARGS ((RlcCb *gCb, 
                             RlcDlRbCb *rbCb,
                             RlcDatReqInfo *datReq, 
                             Buffer *mBuf));

Void rlcUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t sduId));

Void rlcDlUmmReEstablish ARGS ((RlcCb *gCb, 
                                      CmLteRlcId rlcId, 
                                      Bool sndReEst,
                                      RlcDlRbCb *rbCb));

Void rlcUmmProcessSdus ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb,RlcDatReq *datReq));

Void rlcUmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));

/****************************************************************************
 *                    Acknowledged Mode Functions 
 ***************************************************************************/

S32 rlcAmmCalculateBo ARGS ((RlcAmDl *amDl));

Void rlcAmmSendDedLcBoStatus ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmDl *amDl));

Void rlcAmmQSdu ARGS((RlcCb *gCb,
                            RlcDlRbCb *rbCb,
                            Buffer *mBuf, 
                            RlcDatReqInfo *datReq));

void rlcAmmProcessSdus ARGS((RlcCb *gCb, 
                                   RlcDlRbCb *rbCb, 
                                   RlcDatReq *rlcDatReq,
                                   bool staPduPres));

Void rlcAmmDlReEstablish ARGS((RlcCb *gCb, 
                                     CmLteRlcId rlcId, 
                                     RlcDlRbCb *rbCb));

Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb  *gCb,
                                        RlcDlRbCb  *rbCb,
                                        RlcUdxStaPdu *pStaPdu));

S16 rlcAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t sduId));

Void rlcAmmPollRetxTmrExp ARGS((RlcCb *gCB, RlcDlRbCb *rbCb));

Void rlcAmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));

/****************************************************************************
 *                    Utility Functions 
 ***************************************************************************/

Void rlcUtlStoreTxBuf ARGS ((CmLListCp        *txBufLst,
                                    RlcTx       *txBuf,
                                    RlcSn              sn
                                   ));
RlcTx* rlcUtlGetTxBuf ARGS ((CmLListCp        *txBufLst,
                                  RlcSn              sn
                                  ));
Void rlcUtlDelTxBuf ARGS ((CmLListCp        *txBufLst,
                                  RlcTx            *txBuf,
                                  RlcCb              *gCb
                                  ));
Void rlcUtlRemovTxBuf ARGS ((CmLListCp      *txBufLst,
                                  RlcTx            *txBuf,
                                  RlcCb              *gCb
                                  ));

uint8_t rlcUtlSendDedLcBoStatus ARGS ((RlcCb *gCb,
                                  RlcDlRbCb *rbCb,
                                  int32_t bo,
				  int32_t estHdrSz,
                                  bool staPduPrsnt,
                                  uint32_t staPduBo));

#ifdef LTE_L2_MEAS_RLC
Void rlcUtlEmptySduQ ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, CmLListCp *sduQ));
#else /* LTE_L2_MEAS */
Void rlcUtlEmptySduQ ARGS ((RlcCb *gCb,CmLListCp *sduQ));
#endif /* LTE_L2_MEAS */

uint8_t rlcUtlSendToMac ARGS ((RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo));

Void rlcUtlIncrementKwuStsSduTx ARGS((RlcKwuSapCb *rlckwuSap));

Void rlcUtlIncrementGenStsBytesAndPdusSent ARGS((RlcGenSts *genSts, 
                                                       Buffer *pdu));

Void rlcUtlFreeDlMemory ARGS ((RlcCb *gCb));

Void rlcUtlInitToBeFreed ARGS ((RlcCb *gCb, RlcDlDataToBeFreed *toBeFreed));

Void rlcUtlInitializeSelfPst ARGS((RlcCb *gCb));

Void rlcUtlRaiseDlCleanupEvent ARGS((RlcCb *gCb));

Void rlcUtlAddSduToBeFreedQueue ARGS((RlcCb *gCb, RlcSdu *sdu));

Void rlcUtlAddReTxPduToBeFreedQueue ARGS((RlcCb *gCb, RlcRetx *retx));

Void rlcUtlAddTxPduToBeFreedQueue ARGS((RlcCb *gCb, RlcTx *pdu));

#ifdef LTE_L2_MEAS
S16 rlcUtlL2MeasDlInit ARGS((RlcCb *gCb));
#endif

/****************************************************************************
 *                    Debug Functions 
 ***************************************************************************/
Void ResetRLCStats ARGS((Void));

Void PrintRLCStats ARGS((Void));

Void DumpRLCDlDebugInformation ARGS((Void));

/****************************************************************************
 *                    Activation Functions 
 ***************************************************************************/
S16 rlcDlActvInit ARGS ((Ent ent,Inst inst,Region region,Reason reason)); 

S16 rlcDlActvTsk ARGS ((Pst *pst, Buffer *mBuf));

bool rlcDlUtlIsReestInProgress ARGS ((RlcDlRbCb *rbCb));

Void rlcDlUtlResetReestInProgress ARGS ((RlcDlRbCb *rbCb));

Void rlcDlUtlResetReestInProgress ARGS (( RlcDlRbCb *rbCb));

Void rlcDlUtlSetReestInProgressForAllRBs ARGS ((RlcCb *gCb, RlcDlUeCb
         *ueCb));
Void rlcDlUtlSetReestInProgressForRB ARGS (( RlcCb *gCb, RlcDlRbCb *rbCb));

#ifdef LTE_L2_MEAS
Void rlcUtlUpdateContainedSduLst ARGS ((
uint8_t  sduIdx, 
RlcContSduLst  *contSduLst
));
Void rlcUtlUpdateOutStandingSduLst ARGS ((
RlcL2MeasDlIpTh   *dlIpThPut, 
uint8_t           sduIdx, 
MsgLen            sduLen, 
uint32_t          sduId,
Bool              newIdx
));
Void rlcUtlUpdateBurstSdus ARGS((
RlcCb            *gCb,         
RlcDlRbCb        *rbCb,
RlcContSduLst    *contSduLst,
S32              dataVol,
uint32_t         schPduSz
));

RlcL2MeasTb * rlcUtlGetCurMeasTb ARGS((
RlcCb     *gCb,
RlcDlRbCb *rbCb
));

S16 rlcUtlSndDlL2MeasNCfm ARGS((RlcCb *gCb,
                                      RlcL2MeasReqEvt *measReqEvt,
                                      RlcL2MeasCfmEvt *measCfmEvt));

S16 rlcUtlSndDlL2MeasCfm  ARGS ((RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));

S16 rlcUtlProcHarqInd  ARGS (( RlcCb *gCb, RguHarqStatusInd *staInd, RlcDlUeCb *ueCb, 
                                     uint8_t tbIdx));
Void rlcUtlResetDlL2MeasInRlcRb ARGS ((RlcCb *gCb,
                                            RlcL2MeasCb *measCb,
                                            uint8_t measType));

S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, uint8_t  measType,uint8_t  status));

S16 rlcUtlValidateIpThL2Meas ARGS((RlcL2MeasReqEvt *measReqEvt, 
                                     RlcL2MeasCfmEvt *measCfmEvt)); 
                                    
S16 rlcFetchLchInfo ARGS ((RlcL2MeasReqEvt *measReqEvt,
                                 RlcL2MeasCfmEvt *measCfmEvt,
                                 uint16_t             ueId,
                                 CmLteLcId *lChId,
                                 uint8_t *numLch));

S16 rlcUtlNotifyMacUlIp ARGS ((RlcL2MeasCb *measCb,uint16_t ueIdx, Bool enable,
                                    CmLteLcId  *lChId, uint8_t *numLCh));
#endif

uint8_t rlcProcDlData(Pst *pst, RlcDatReqInfo* datReq, Buffer *buf);
uint8_t rlcProcCommLcSchedRpt(Pst *pst, SuId suId, RguCStaIndInfo  *staInd);
uint8_t rlcProcDedLcSchedRpt(Pst *pst, SuId suId, RguDStaIndInfo  *staInd);

Void rlcUtlFreeDlMem ARGS(( Void));
#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* __RLC_DLH__ */
  
/********************************************************************30**
  
         End of file
**********************************************************************/