[Task-ID: ODUHIGH-485] Memory Leak Detector Tool
[o-du/l2.git] / src / 5gnrrlc / rlc_dl.h
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18
19 /********************************************************************20**
20   
21         Name:     NR RLC file for downlink and non real time tasks 
22     
23         Type:     C include file
24   
25         Desc:     This file contains helper macros for RLC downlink
26                   and non real time task
27  
28         File:     rlc_dl.h
29   
30 *********************************************************************21*/
31 /** @file rlc_dl.h
32 @brief RLC Downlink helper macros 
33 */
34
35 #ifndef __RLC_DLH__
36 #define __RLC_DLH__
37
38 #ifdef __cplusplus
39 extern "C" {
40 #endif /* __cplusplus */
41 #ifdef TENB_STATS
42 #ifndef L2_l3_SPLIT
43 #include "pj_tenb_stats.x"
44 #else
45 #include "l2_tenb_stats.x"
46 #endif
47 #endif
48
49 #define RLC_DL_INST 1
50 #define RLC_MAX_RNG_DEQ_INDX 8
51
52 /* Below are the status used within RLC */
53 #define RLC_SDU_OPAT_NOUPDATE 0
54 #define RLC_SDU_OPAT_UPD_TX 1
55 #define RLC_SDU_OPAT_UPD_RETX   2
56
57 /* Below are the status which needs to be updated to MAC */
58 #define RLC_RGU_SDU_OPAT_NOUPDATE 0
59 #define RLC_RGU_SDU_OPAT_UPDATE   1
60 #define RLC_RGU_SDU_OPAT_BREACH   2
61
62 /* PDB Values for various QCI bearers : This value is considered 
63    after taking into account a 20ms delay at the network */
64 #define RLC_PDB_VALUE_FOR_QCI1    80
65 #define RLC_PDB_VALUE_FOR_QCI2    130
66 #define RLC_PDB_VALUE_FOR_QCI3    30
67 #define RLC_PDB_VALUE_FOR_QCI4    280
68 #define RLC_PDB_VALUE_FOR_QCI5    80
69 #define RLC_PDB_VALUE_FOR_QCI6    280
70 #define RLC_PDB_VALUE_FOR_QCI7    80
71 #define RLC_PDB_VALUE_FOR_QCI8    280
72 #define RLC_PDB_VALUE_FOR_QCI9    280
73
74 #define RLC_DATA_BITMASK          0x80 /* Data bitmask is used to fill D/C bit for data*/
75 /**
76  * @def RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB
77  *
78  *    This macro is used to check if DL IP throughput measurement is ON
79  *    or off for the passed rb
80  *
81  *    Returns TRUE (non-zero) if measurement is ON else FALSE (zero)
82  *
83  * @param[in] _gCb     RLC DL Cb
84  * @param[in] _rbCb    RLC downlink control block
85  *
86 */ 
87 #ifdef LTE_L2_MEAS
88 #define RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
89      ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
90             (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci]))
91
92 #define RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
93      ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
94       (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_IP) && \
95       (_rbCb->rbL2Cb.measOn & LKW_L2MEAS_DL_IP))
96
97 #define RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
98      ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
99             (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_DL_DELAY))
100
101 #define RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(_gCb, _rbCb)  \
102      ((_rbCb->rlcId.rbType == CM_LTE_DRB) && \
103             (_gCb->u.dlCb->rlcL2Cb.measOn[_rbCb->qci] & LKW_L2MEAS_UU_LOSS))
104 #define RLC_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _rlcRbCb, _delay)                     \
105 {                                                                              \
106    if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                               \
107       ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DELAY))    \
108    {                                                                           \
109       (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DELAY]->dlPjSduDelay.sduDelay += _delay; \
110       (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DELAY]->dlPjSduDelay.numSdus++; \
111    }                                                                    \
112 }
113
114 #define RLC_UPD_L2_UU_LOSS_PKTS(_rlcCb, _rlcRbCb, _val)                         \
115 {                                                                 \
116    if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
117       ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_UU_LOSS))              \
118    {                                                              \
119       (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_UU_LOSS]->uuLoss.dLoss += _val;     \
120    }                                                              \
121 }
122 #define RLC_UPD_L2_UU_LOSS_POS_PKTS(_rlcCb,_rlcRbCb,_val)                         \
123 {                                                                 \
124    if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
125       ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_UU_LOSS))              \
126    {                                                              \
127       (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_UU_LOSS]->uuLoss.posPkts += _val;     \
128    }                                                              \
129 }
130 /* Discard new changes starts */
131 #define RLC_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_rlcRbCb)                         \
132 {                                                                 \
133    if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
134       ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC))              \
135    {                                                              \
136       (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DISC]->dlDisc.discSdus++;     \
137    }                                                              \
138 }                                              
139
140 #define RLC_UPD_L2_DL_TOT_SDU_STS(_rlcCb,_rlcRbCb)                             \
141 {                                                                 \
142    if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                              \
143       ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC))   \
144    {                                                              \
145       (_rlcRbCb)->rbL2Cb.l2Sts[RLC_L2MEAS_DL_DISC]->dlDisc.totSdus++;      \
146    }                                                              \
147 }
148
149 #define RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _rlcRbCb)                 \
150 {                                                                 \
151    if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) &&                    \
152       ((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC))   \
153    {                                                              \
154       uint32_t idx1;                                                    \
155       for (idx1 = 0; idx1 < LKW_MAX_L2MEAS; idx1++)                  \
156       {                                                           \
157          if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC)                 \
158          {                                                        \
159             if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci > 0) \
160             {                                                                                               \
161                _rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci--;   \
162                if (_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci].totDrbsPerQci == 0) \
163                {                                                                                                 \
164                   _rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.qci[(_rlcRbCb)->qci] = 0;                      \
165                   memset(&_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci], 0,  \
166                      sizeof(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.val.nonIpThMeas.measData[(_rlcRbCb)->qci]));            \
167                }                                                                                                 \
168             }                                                                                                    \
169          }                                                                                                       \
170       }                                                                                                          \
171    }                                                                                                             \
172 }
173 #else
174 #define RLC_UPD_PDCP_L2_DLDELAY_STS(_rlcCb, _rlcRbCb, _delay)
175 #define RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(_gCb, _rbCb)
176 #define RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(_gCb, _rbCb)
177 #define RLC_UPD_L2_DL_DISC_SDU_STS(_rlcCb,_rlcRbCb)
178 #define RLC_UPD_L2_DL_TOT_SDU_STS(_rlcCb, _rlcRbCb)
179 #define RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(_rlcCb, _rlcRbCb)
180 #endif
181
182
183 typedef struct rlcDlUeCb RlcDlUeCb;
184
185 /** 
186  * @brief  Structure to hold the SN of the PDU onto which a SDU is mapped
187  *
188  * @details
189  *    - sn : Sequence number of the AM pdu
190 */
191 typedef struct rlcPduMap
192 {
193   RlcSn   sn;     /*!< Mapped PDU's SN */
194 }RlcPduMap;
195
196 /** 
197  * @brief  Structure to hold information regarding a SDU received from PDCP
198  *
199  * @details
200  *    - lstEnt : Used for linking ( we have linked list of SDUs) which forms
201  *               the SDU queue
202  *    - mBuf   : Pointer to the SDU data
203  *    - sduSz  : Size of the mBuf above
204  *    - actSz  : Length of the SDU when received from PDCP, this might be 
205  *               different from sduSz, in case when the SDU is split
206  *    - mode   : Depending on the type, holds AM, UM or TM mode information
207  *      - tm
208  *        - sfn      : System Frame number for BCCH/PCCH
209  *        - subframe : Subframe number
210  *        - rnti     : RNTI for CCCH
211  *      - um
212  *        - sduId       : Unique identity for the SDU
213  *        - isSegmented : Whether this SDU is segmented into multiple PDUs
214  *      - am
215  *        - sduId       : Unique identity for the SDU
216  *        - rcvdSz      : Length of this SDU which is received by the peer
217  *        - isSegmented : Whether this SDU is segmented into multiple PDUs
218 */
219 typedef struct rlcSdu                        
220 {
221    CmLList   lstEnt;     /*!< List entry for SDU */
222    Buffer    *mBuf;      /*!< SDU buffer */ 
223    MsgLen    sduSz;      /*!< Buffer Size */
224    MsgLen    actSz;      /*!< Actual buffer Size */
225 /* kw005.201 added support for L2 Measurement */
226 #ifdef LTE_L2_MEAS
227    RlcSduSnMap  *snMap;   /*!< Sdu and the list of SN it maps to */
228 #endif /* LTE_L2_MEAS */
229
230    union
231    {
232       struct   _t 
233       {
234          uint16_t    sfn;        /*!< Sub frame number for BCCH/PCCH */
235          uint16_t    slot;   /*!< Subframe number */
236          CmLteRnti   rnti;       /*!< RNTI for CCCH */
237 #ifdef EMTC_ENABLE
238          uint8_t          emtcDiReason; /*!< DI reason */
239          uint8_t          pnb;       /*!<narrow band on which Ue performs Paging*/
240 #endif
241       }tm;   /*!< SDU for TM mode */
242
243       struct   _u
244       {
245          uint32_t  sduId;         /*!< SDU Identifier */
246          Bool      isSegmented;   /*!< Flag to indicate if the SDU is segmented */
247       }um;   /*!< SDU for UM mode */
248
249       struct   _a
250       {
251          uint32_t   sduId;                    /*!< SDU Identifier */
252          MsgLen     rcvdSz;                   /*!< Recvd SDU Size from peer */
253          Bool       isSegmented;              /*!< Is SDU segmented */
254          RlcSn        sn;                       /*!< SN assigned to this SDU*/
255       }am;   /*!< SDU for AM mode */
256    }mode;   /*!< RLC mode specific SDUs */
257    /* Discard new changes starts */
258    Ticks               arrTime;     /*!< Arrival time of the PDCP PDU at RLC */
259    /* Discard new changes ends */
260
261 }RlcSdu;
262
263 /** @addtogroup tmmode */
264 /*@{*/
265
266 /** 
267  * @brief  Structure to hold Transparent Mode information for a RB
268  *
269  * @details
270  *    - sduQ : Queue of SDUs
271 */
272 typedef struct rlcTm
273 {
274    CmLListCp sduQ; /*!< SDU queue for TM */
275 }RlcTm;
276 /*@}*/
277
278 /** 
279  * @brief  Structure to hold buffer occupancy report sent to MAC
280  *
281  * @details
282  *    - bo         : Size of the buffers at RLC
283  *    - estHdrSz   : Size for all the headers as estimated by RLC
284  *    - staPduPrst : Whether RLC wants to send a STATUS PDU or not
285 */
286 typedef struct rlcBoRep
287 {
288    int32_t  bo;            /*!< Buffer occupancy */
289    uint16_t estHdrSz;      /*!< Estimated header size for the bo */
290    bool     staPduPrsnt;   /*!< Indicate control bo present or not */
291    uint32_t staPduBo;     /*!< Indicate bo for control PDU */
292    uint32_t oldestSduArrTime;
293 } RlcBoRep;
294
295 /** 
296  * @brief  Structure to hold information sent to MAC in a Data Request
297  *
298  * @details
299  *    - pduSz   : Sum total of sizes of all the PDUs being sent
300  *    - pduInfo : Information about each PDU
301  *    - boRep   : Current buffer occupancy report
302 */
303 typedef struct rlcDatReq
304 {
305    MsgLen      pduSz;         /*!< PDU(s) size indicated by MAC */ 
306    KwPduInfo   pduInfo;       /*!< PDU Information for lChs within UE */
307    RlcBoRep     boRep;         /*!< BO report */ 
308 /* kw005.201 added support for L2 Measurement */
309 #ifdef LTE_L2_MEAS
310    KwLchMapInfo lchMapInfo;   /*!< Logical channel mapping info */
311    uint32_t          totMacGrant;
312 #endif /* LTE_L2_MEAS */
313 }RlcDatReq;
314
315 /** @defgroup ummode UM Module Info 
316 */
317
318 /** @addtogroup ummode */
319 /*@{*/
320 /** 
321  * @brief  Structure to hold Unacknowledged mode downlink information for a RB
322  *
323  * @details
324  *    - sduQ        : Control point for the queue of SDUs
325  *    - snLen       : length of the squence number. Here it is stored 
326  *                    as 1 for 5 bit sequence numbers and 
327  *                    2 for 10 bit sequence numbers
328  *    - bo          : Current buffer occupancy for this RB
329  *    - TX_Next     : SN to be allocated to next SDU
330  *    - modBitMask  : Bitmask used to do modulus operations to wrap around 
331  *                    state variables, value is 0x3f or 
332  *                    0xfff for 6-bit and 12-bit sequence numbers respectively
333 */
334 typedef struct rlcUmDl
335 {
336    CmLListCp   sduQ;            /*!< SDU queue for UM */
337    uint8_t     snLen;           /*!< Sequence number length */
338    int32_t     bo;              /*!< Buffer occupancy */
339    RlcSn       txNext;          /*!< TX_Next */
340    uint16_t    modBitMask;      /*!< Bitmask for modulus to wrap around vars*/   
341 }RlcUmDl;
342
343 /** 
344  * @brief  Structure to hold information about which SDUs a PDU/segment carries
345  *
346  * @details
347  *    - sduSz  : Size of the SDU or part of it
348  *    - sdu    : Pointer to the SDU
349 */
350 typedef struct rlcSduMap
351 {
352    /*MsgLen   actSz;*/         /*!< SDU Size */
353    MsgLen   sduSz;         /*!< SDU Size */
354    /*Bool     isSegmented;*/   /*!< Flag to indicate if the SDU is segmented */
355    RlcSdu*   sdu;           /*!< Pointer to the associated SDU */
356 }RlcSduMap;
357
358 /** 
359  * @brief  Structure to hold info about a PDU/segment to be re-transmitted
360  *
361  * @details
362  *    - lstEnt           : Control point to link the re-transmit (the 
363  *                         re-transmit PDUs  ,segments are stored as a 
364  *                         link list) nodes
365  *    - seg              : Pointer to the data
366  *    - segSz            : Size of the PDU/segment including the header
367  *    - hdrSz            : Size of the AM header for this in bytes
368  *    - amHdr            : The header for this PDU/segment
369  *    - soEnd            : SO End
370  *    - retxCnt          : Number of times this has been re-transmitted
371  *    - yetToConst       : Whether the PDU/segment has been constructed (headers
372  *                         appended) or not
373  *    - pendingReTrans   : TRUE if this node is to be re-transmitted else FALSE
374  *    - numSdu           : Number of SDUs this PDU/segment carries
375  *    - sduMap           : Infomation about the SDUs this node carries
376 */
377 typedef struct rlcRetx
378 {
379    CmLList    lstEnt;              /*!< List entry for Retransmission PDU */
380    Buffer     *seg;                /*!< Buffer of PDU or Segment */
381    MsgLen     segSz;               /*!< Segment Size */
382    MsgLen     hdrSz;               /*!< Header size for the segment */
383    RlcAmHdr   amHdr;               /*!< AM header Info */
384    uint16_t   soEnd;               /*!< Segment Offset End */
385    RlcSn      retxCnt;             /*!< Retransmission count */
386    Bool       yetToConst;          /*!< Yet to construct seg flag */
387    Bool       pendingReTrans;      /*!< Is node waiting for re-transmission */
388    RlcSduMap  sduMap;              /*!< SDU mapped with PDU */
389 }RlcRetx;
390
391 /** 
392  * @brief  Structure to hold a RLC AM PDU Information
393  *
394  * @details
395  *    - lstEnt : This is required for the linked list in which pdu is stored
396  *    - pdu    : Holds the pdu
397  *    - pduSz  : The length of the segment in bytes
398  *    - hdrSz  : Header size of this PDU
399  *    - amHdr  : The AM Header for the PDU segment
400  *    - RlcSduMap :SDU map info for this PDU 
401  *
402 */
403 typedef struct rlcDlPduInfo
404 {
405    CmLList   lstEnt;               /*!< List entry for PDU list */
406    Buffer     *pdu;                /*!< Buffer of PDU */
407    MsgLen     pduSz;               /*!< PDU Size */
408    MsgLen     hdrSz;               /*!< Header size for the segment */
409    RlcAmHdr    amHdr;               /*!< AM header Info */
410    RlcSduMap   sduMap;              /*!< SDU info for this PDU */
411
412 }RlcDlPduInfo;
413
414 /** 
415  * @brief  Structure to hold info about a PDU that has been transmitted
416  *
417  * @details
418  *    - lnk    : Link to the TX buffer list
419  *    - sn     : SN of this RLC SDU
420  *    - rlsLnk : Link to store on release list, used for
421  *    - pduLst : It contains all PDUs of a particular SN
422 */
423 typedef struct rlcTx
424 {
425    CmLList     lnk;                /**< Link to the TX buffer list*/
426    RlcSn        sn;                /*!< SN of this RLC SDU */
427    CmLList    rlsLnk;             /*!< Lnk to store on release lst */
428    CmLListCp  pduLst;             /*!< It contains all PDUs of a particular SN*/
429 }RlcTx;
430
431 /** @addtogroup ammode */
432 /*@{*/
433
434 /** 
435  * @brief  Structure to hold Acknowledged Mode Downlink information for a RB
436  *
437  * @details
438  *    - sduQ           : SDU queue
439  *    - nxtTx          : Pointer to the next SDU to be transmitted
440  *    - pollRetxTmr    : Poll re-transmission timer
441  *    - pollRetxTmrInt : Timer interval (?? secs) of poll re-transmission timer
442  *    - pollPdu        : Number of PDUs to send before sending a poll bit
443  *    - pollByte       : Number of bytes to send before sending a poll bit
444  *    - maxRetx        : Maximum number of re-transmissions to be done for a 
445  *                       PDU/segment
446  *    - cntrlBo        : Size of the STATUS PDU if it is to be sent, else 0
447  *    - retxBo         : Bo of the PDUs/segments to be re-transmitted
448  *    - estHdrSz       : Extimated header size of all the SDUs in the queue
449  *    - bo             : Bo of the PDUs in the transmission buffer
450  *    - txBufLst       : Transmission buffer lists. It's contiguous index by sequence
451  *                       number
452  *    - rextLst        : Re-transmission buffer. It is a doubly linked list
453  *    - nxtRetx        : Next node to be re-transmitted
454  *    - txNext         : 5GNR - TX_Next - Send state variable,( in LTE VT(S)) 
455  *    - txNextAck      : 5GNR - TX_Next_Ack- Acknowledgement state variable
456                        : (in LTE VT(A))     
457  *    - pduWoPoll      : Number of PDUs sent without sending a poll bit
458  *    - byteWoPoll     : Number of bytes sent without sending a poll bit
459  *    - pollSn         : The sequence number on which the last poll bit was sent
460  *    - mBuf           : The encoded STATUS pdu to be sent
461  *    - maxReTxReached : Whether maximum number of re-transmissions has been
462  *                       reached or not
463  *    - pStaPdu        : Stores the control pdu (information required to
464  *                       create the STATUS PDU) passed from AM uplink
465 */
466 typedef struct rlcAmDl
467 {
468    CmLListCp        sduQ;             /*!< SDU queue */
469    RlcSdu           *nxtTx;           /*!< Next SDU to be transmitted */
470    CmTimer          pollRetxTmr;      /*!< T_poll_retransmit Timer */
471    uint16_t         pollRetxTmrInt;   /*!< Timer Interval */
472    int16_t          pollPdu;          /*!< Poll_PDU */
473    int32_t          pollByte;         /*!< Poll_Byte */
474    uint8_t          maxRetx;          /*!< Max_Retx_Threshold */
475    int32_t          cntrlBo;          /*!< BO of control pdu */ 
476    int32_t          retxBo;           /*!< BO of Retransmission PDUs */ 
477    uint32_t         estHdrSz;         /*!< Estimated header size for the BO */
478    int32_t          bo;               /*!< BO of new PDUs */
479 #ifndef LTE_TDD 
480    CmLListCp        *txBufLst;       /*!< Transmission buffer list of type RlcTx */
481 #else
482 //   RlcTx             *txBuf[1024];          /*!< Transmission buffer */
483 #endif
484    CmLListCp        retxLst;          /*!< Retransmission PDU list */
485    RlcRetx          *nxtRetx;         /*!< Next node to be retransmitted */
486    RlcSn            txNext;           /*!< 5GNR: TX_Next, in LTE  VT(S) */
487    RlcSn            txNextAck;        /*!< 5GNR: TX_Next_Ack, in LTE VT(A)*/ 
488    int16_t          pduWoPoll;        /*!< PDU without poll bit counter */
489    int32_t          byteWoPoll;       /*!< Byte without poll bit counter */
490    RlcSn            pollSn;           /*!< Poll SN */
491    Buffer           *mBuf;            /*!< this can be removed later 
492                                            Stores the Control Pdu */
493    Bool             maxReTxReached;   /*!< Set when the DL MAX Retx exceeded */
494    RlcUdxDlStaPdu*  pStaPdu;          /*!< The Control Pdu passed from UL*/
495    uint8_t          snLen;           /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
496    uint32_t         snModMask;       /*!< (2 Pwr SnLen - 1): 5GNR RLC */
497 }RlcAmDl;
498
499 /*@}*/
500
501 /** 
502  * @brief  Structure to hold information about a Radio Bearer as required by RLC
503  *
504  * @details
505  *    - rlcId          : RLC identifier, uniquely identifies a Radio Bearer
506  *    - lch            : Information (type and id) of the logical channel 
507  *                       associated with this Radio  Bearer.
508  *    - mode           : The mode of the Radio Bearer TM or UM or AM
509  *    - dir            : The direction of the Radio Bearer, downlink or 
510  *                       uplink or both
511  *    - inst           : Id of RLC instance where this Radio Bearer is present. 
512  *                       Used to find the instance from the Radio Bearer for 
513  *                       memory needs as different instances might have 
514  *                       different memory.
515  *    - k1wuSapId       : KWU SAP identifier
516  *    - udxSapId       : UDX SAP idenrifier
517  *    - transId        : Stores the transaction identifier used to communicate 
518  *                       with MAC, the same value as sent by MAC is passed back 
519  *                       for it to be able to corelate
520  *    - reestInProgress: Whether re-establishment is going on for this RB
521  *    - m              : Mode of the RB (TM/UM/AM)
522  *      - tm           : Transparent Mode information
523  *      - umDl         : Unacknowledged Mode downlink information
524  *      - amDl         : Acknowledged Mode downlink information
525  *    - rlsLnk         : Link list used to free the RbCb
526  *    - cleanupStarted : Whether cleanup of RB is in progress or not
527 */
528 typedef struct _rlcDlRbCb
529 {
530    uint8_t              qci;                /*!< qci of the RB */
531 #ifdef LTE_L2_MEAS
532    RlcDlUeCb        *ueCb;              /*!< Pointer to UeCb  */
533    RlcL2MeasRbCb    rbL2Cb;             /*!< RB measurement L2 Cb */
534    CmLListCp       sduSnMapQ;          /*!< SDU SN map queue for UM */
535
536    RlcL2MeasIpThruput l2MeasIpThruput;  /*!< Holds related parameter for
537                                                  DL/UL ip throughput>*/
538 #endif                                                 
539
540    /* Discard new changes starts */
541    S16             discTmrInt;        /*!< The discard time in milli 
542                                            seconds for an PDCP SDU for this RB */
543    /* Discard new changes ends */
544    CmLteRlcId     rlcId;           /*!< RLC Identifier */
545    RlcLchInfo     lch;             /*!< Logical Channel Info  */
546    Snssai         *snssai;
547    CmLteRlcMode   mode;            /*!< Entity Mode */
548    uint8_t        dir;             /*!< Direction for UL/DL */
549    Inst           inst;            /*!< Tapa Instance where rb created */
550    SpId           k1wuSapId;        /*!< KWU sap Id, to get the KwuSapCb */
551    SpId           udxSapId;        /*!< UDX sap Id, to get the UdxSapCb */
552    uint32_t       transId;         /*!< Transaction Id for RLC */
553    Bool           reestInProgress; /*!< Is reestablishment in progress */
554    SpId           rguSapId;        /*!< RGU Instance SAP corresponding to this RB */
555    union          
556    {
557       RlcTm     tm;     /*!< TM mode specific elements */
558       RlcUmDl   umDl;   /*!< UM downlink elements */
559       RlcAmDl   amDl;   /*!< AM downlink elements */
560    }m;   /*!< RLC mode specific Info */
561    CmLList   rlsLnk;   /*!< Link to add to release list */
562    Bool      cleanupStarted; /*!< Whether cleanup of RB is in progress or not */
563    uint32_t  lastRprtdBoToMac; /*!< Last Reported BO to MAC Layer */
564    uint32_t  boUnRprtdCnt; /*!< Count to keep track of periodic BO Update */
565 }RlcDlRbCb;
566
567 /** 
568  * @brief  Structure to hold mapping between logical channel and Radio Bearer
569  *
570  * @details
571  *    - dlRbCb   : Pointer to the downlink Radio Bearer
572 */
573 typedef struct rlcDlLch
574 {
575    RlcDlRbCb *dlRbCb;   /*!< Pointer to Downlink RbCb */
576 }RlcDlLch;                                  
577
578 /** 
579  * @brief  Structure to hold information about the Cells
580  *
581  * @details
582  *    - cellHlEnt : Information about cells are stored in a hash table. This is
583  *                  required for that.
584  *    - cellId    : Identity of the cell
585  *    - rbCb      : Radio Bearers in the cell
586  *    - lCh       : Logical Channels in the cell
587 */
588 typedef struct rlcDlCellCb
589 {
590    CmHashListEnt   cellHlEnt;                 /*!< Hash list entry for CellCb */
591    CmLteCellId     cellId;                    /*!< Cell Id */
592    RlcDlRbCb        *rbCb[RLC_MAX_RB_PER_CELL]; /*!< RbCbs within a Cell */
593    RlcDlLch         lCh[RLC_MAX_LCH_PER_CELL];  /*!< Array of Logical channels */
594 }RlcDlCellCb;
595
596 #ifdef LTE_L2_MEAS
597 /** @struct RlcContSduLst
598  * Structure contains list of rbId and index to KwOutStngSduLst
599  */
600 typedef struct rlcContSduLst
601 {
602    CmLteLcId   lcId;    /*!< Holds the lcId of rbCb */
603    uint8_t     numSdus; /*!< Number sdus in sduIdx array */
604    uint8_t     sduIdx[RLC_L2MEAS_MAX_OUTSTNGSDU];  /*!< Hold the index to KwOutStngSduLst */
605 }RlcContSduLst;
606 typedef struct rlcSduInfo
607 {
608    Bool  isRetxPdu;
609    Ticks arvlTime; /* stores the the arrival time of each PDCP PDU */
610 }RlcSduInfo;
611
612 typedef struct rlclchInfo
613 {
614    CmLteLcId   lcId;    /*!< Holds the lcId of rbCb */
615    uint8_t     numSdus; /*!< Number sdus belonged to the this LC */
616    RlcSduInfo  sduInfo[RLC_L2MEAS_SDUIDX];
617 }RlclchInfo;
618
619 /** @struct RlcL2MeasTb
620  * Structure containes list of rbId and  index to KwOutStngSduLst
621  */
622 typedef struct rlcL2MeasTb
623 {
624    uint8_t          numLcId;       /* number of logical channels in this TbCb */
625    RlcContSduLst    sduInfo[RLC_MAX_ACTV_DRB]; /*!< Contained sduLst for 
626                                                outstanding sdu */
627    uint8_t          numLchInfo;
628    RlclchInfo       lchInfo[RLC_MAX_ACTV_DRB]; /* Holds the LC info details 
629                                                   used for DL delay L2 Meas*/
630    uint32_t         txSegSduCnt; /*!< This holds the no.of partially 
631                                      transmitted SDU per TB which can be used for UU loss Meas*/
632 }RlcL2MeasTb;
633 #endif
634
635 /** 
636  * @brief  Structure to hold information about the UEs
637  *
638  * @details
639  *    - ueHlEnt : Information about cells are stored in a hash table. This is
640  *                required for that.
641  *    - key     : Key to store/find the UE in the hashtable
642  *    - srbCb   : Signaling Radio Bearers configured for the UE
643  *    - drbCb   : Data Radio Bearers configured for the UE
644  *    - lCh     : Logical Channels in the UE
645 */
646 struct rlcDlUeCb
647 {
648    CmHashListEnt     ueHlEnt;                   /*!< Hash list entry for UeCb */
649    CmLteRnti         ueId;     /*!< UE Id */
650    CmLteCellId       cellId;   /*!< Cell Id */
651    RlcDlRbCb         *srbCb[RLC_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */ 
652    RlcDlRbCb         *drbCb[RLC_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */ 
653    RlcDlLch          lCh[RLC_MAX_LCH_PER_UE];    /*!< Array of Logical channels */
654 /* kw005.201 added support for L2 Measurement */
655 #ifdef LTE_L2_MEAS
656    uint16_t           numActRb[LKW_MAX_QCI];     /*!< number of RBs Active */
657    uint8_t            tbIdx;                /*!< TBIDx for  measTbCb */
658    RlcL2MeasTb        *l2MeasTbCb[RLC_MAX_TB_PER_UE]; /*!< Array of Measurement tbCb */
659 #endif /* LTE_L2_MEAS */
660 #ifdef TENB_STATS
661    TSL2UeStatsCb   *tenbStats; /*!< UE Stats Holder */
662 #endif
663 };
664
665 /****************************************************************************
666  *                      Declarations
667  ***************************************************************************/
668 /****************************************************************************
669  *                    Configuration Functions 
670  ***************************************************************************/ 
671 S16 rlcCfgAddDlRb ARGS ((RlcCb *gCb, 
672                               CmLteRnti ueId, 
673                               CmLteCellId cellId, 
674                               RlcEntCfgInfo *entCfg, 
675                               RlcEntCfgCfmInfo *entCfm));
676
677 S16 rlcCfgReCfgDlRb ARGS ((RlcCb *gCb, 
678                                  CmLteRnti ueId, 
679                                  CmLteCellId cellId, 
680                                  RlcEntCfgInfo *entCfg, 
681                                  RlcEntCfgCfmInfo *entCfm));
682
683 S16 rlcCfgDelDlRb ARGS ((RlcCb *gCb, 
684                                CmLteRnti ueId, 
685                                CmLteCellId cellId, 
686                                RlcEntCfgInfo *entCfg, 
687                                RlcEntCfgCfmInfo *entCfm));
688
689 S16 rlcCfgDelDlUe ARGS ((RlcCb *gCb, 
690                                CmLteRnti ueId, 
691                                CmLteCellId cellId, 
692                                RlcEntCfgInfo *entCfg, 
693                                RlcEntCfgCfmInfo *entCfm));
694
695 S16 rlcCfgReEstDlRb ARGS ((RlcCb *gCb, 
696                                  CmLteRnti ueId, 
697                                  CmLteCellId cellId, 
698                                  Bool sndReEst,
699                                  RlcEntCfgInfo *entCfg, 
700                                  RlcEntCfgCfmInfo *entCfm));
701
702 S16 rlcCfgDelDlCell ARGS ((RlcCb *gCb, 
703                                  CmLteCellId cellId, 
704                                  RlcEntCfgInfo *entCfg,
705                                  RlcEntCfgCfmInfo *entCfm));
706
707 S16 rlcCfgDlUeIdChng ARGS ((RlcCb *gCb, 
708                                   CkwUeInfo *ueInfo, 
709                                   CkwUeInfo *newUeInfo, 
710                                   CmStatus  *status));
711
712 /****************************************************************************
713  *                    DBM module Functions 
714  ***************************************************************************/
715 S16 rlcDbmDlInit ARGS ((RlcCb *gCb));
716
717 Void rlcDbmDlDeInit ARGS ((RlcCb *gCb));
718
719 S16 rlcDbmCreateDlUeCb ARGS ((RlcCb *gCb,     
720                                     CmLteRnti ueId,   
721                                     CmLteCellId cellId,
722                                     RlcDlUeCb **ueCb));
723
724 uint8_t rlcDbmFetchDlUeCb ARGS ((RlcCb *gCb,        
725                                    CmLteRnti ueId,      
726                                    CmLteCellId cellId,     
727                                    RlcDlUeCb **ueCb));
728
729 Void rlcDbmDelDlUeCb ARGS ((RlcCb *gCb,       
730                                   RlcDlUeCb *ueCb, 
731                                   Bool abortFlag));
732
733 Void rlcDbmDelAllDlUe ARGS ((RlcCb *gCb));
734
735 S16 rlcDbmCreateDlCellCb ARGS ((RlcCb *gCb,      
736                                     CmLteCellId cellId,   
737                                     RlcDlCellCb **cellCb));
738
739 uint8_t rlcDbmFetchDlCellCb ARGS ((RlcCb *gCb, 
740                                      CmLteCellId cellId, 
741                                      RlcDlCellCb **cellCb));
742
743 Void rlcDbmDelDlCellCb ARGS ((RlcCb *gCb, RlcDlCellCb *cellCb));
744
745 Void rlcDbmDelAllDlCell ARGS ((RlcCb *gCb));
746
747 Void rlcDbmFetchDlRbCbByRbId ARGS ((RlcCb *gCb, 
748                                           CmLteRlcId *rlcId, 
749                                           RlcDlRbCb **rbCb));
750
751 Void rlcDbmFetchDlRbCbFromLchId ARGS ((RlcCb *gCb,       
752                                              CmLteRnti ueId,     
753                                              CmLteCellId cellId,    
754                                              CmLteLcId lcId,      
755                                              RlcDlRbCb **rbCb));
756
757 Void rlcDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, uint8_t numRbCb));
758
759 S16 rlcDbmDlShutdown ARGS ((RlcCb *gCb));
760
761 Void rlcUtlGetCurrTime ARGS((uint32_t *time));
762 Void rlcUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t pktAdmitCnt ));
763 #ifdef LTE_L2_MEAS
764 Void rlcDbmDelAllDlL2MeasTbFrmUe ARGS ((RlcCb *gCb, RlcDlUeCb *ueCb));
765
766 #endif
767
768 /****************************************************************************
769  *                    Transparent Mode Functions 
770  ***************************************************************************/
771 Void rlcTmmQSdu ARGS ((RlcCb *gCb,
772                             RlcDlRbCb *rbCb,
773                             RlcDatReqInfo *datReqInfo,
774                             Buffer *mBuf));
775 Void rlcTmmSendToMac ARGS ((RlcCb     *gCb,
776                                 SuId     suId,
777                                 RlcDlRbCb *rbCb, 
778                                 RguCStaIndInfo *staInd));
779
780 Void rlcDlTmmReEstablish ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
781
782 /****************************************************************************
783  *                    Unacknowledged Mode Functions 
784  ***************************************************************************/
785 Void rlcUmmQSdu ARGS ((RlcCb *gCb, 
786                              RlcDlRbCb *rbCb,
787                              RlcDatReqInfo *datReq, 
788                              Buffer *mBuf));
789
790 Void rlcUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t sduId));
791
792 Void rlcDlUmmReEstablish ARGS ((RlcCb *gCb, 
793                                       CmLteRlcId rlcId, 
794                                       Bool sndReEst,
795                                       RlcDlRbCb *rbCb));
796
797 Void rlcUmmProcessSdus ARGS ((RlcCb *gCb,RlcDlRbCb *rbCb,RlcDatReq *datReq));
798
799 Void rlcUmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
800
801 /****************************************************************************
802  *                    Acknowledged Mode Functions 
803  ***************************************************************************/
804
805 S32 rlcAmmCalculateBo ARGS ((RlcAmDl *amDl));
806
807 Void rlcAmmSendDedLcBoStatus ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, RlcAmDl *amDl));
808
809 Void rlcAmmQSdu ARGS((RlcCb *gCb,
810                             RlcDlRbCb *rbCb,
811                             Buffer *mBuf, 
812                             RlcDatReqInfo *datReq));
813
814 void rlcAmmProcessSdus ARGS((RlcCb *gCb, 
815                                    RlcDlRbCb *rbCb, 
816                                    RlcDatReq *rlcDatReq,
817                                    bool staPduPres));
818
819 Void rlcAmmDlReEstablish ARGS((RlcCb *gCb, 
820                                      CmLteRlcId rlcId, 
821                                      RlcDlRbCb *rbCb));
822
823 Void rlcAmmDlHndlStatusPdu ARGS ((RlcCb  *gCb,
824                                         RlcDlRbCb  *rbCb,
825                                         RlcUdxStaPdu *pStaPdu));
826
827 S16 rlcAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t sduId));
828
829 Void rlcAmmPollRetxTmrExp ARGS((RlcCb *gCB, RlcDlRbCb *rbCb));
830
831 Void rlcAmmFreeDlRbCb ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb));
832
833 /****************************************************************************
834  *                    Utility Functions 
835  ***************************************************************************/
836
837 Void rlcUtlStoreTxBuf ARGS ((CmLListCp        *txBufLst,
838                                     RlcTx       *txBuf,
839                                     RlcSn              sn
840                                    ));
841 RlcTx* rlcUtlGetTxBuf ARGS ((CmLListCp        *txBufLst,
842                                   RlcSn              sn
843                                   ));
844 Void rlcUtlDelTxBuf ARGS ((CmLListCp        *txBufLst,
845                                   RlcTx            *txBuf,
846                                   RlcCb              *gCb
847                                   ));
848 Void rlcUtlRemovTxBuf ARGS ((CmLListCp      *txBufLst,
849                                   RlcTx            *txBuf,
850                                   RlcCb              *gCb
851                                   ));
852
853 uint8_t rlcUtlSendDedLcBoStatus ARGS ((RlcCb *gCb,
854                                   RlcDlRbCb *rbCb,
855                                   int32_t bo,
856                                   int32_t estHdrSz,
857                                   bool staPduPrsnt,
858                                   uint32_t staPduBo));
859
860 #ifdef LTE_L2_MEAS_RLC
861 Void rlcUtlEmptySduQ ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, CmLListCp *sduQ));
862 #else /* LTE_L2_MEAS */
863 Void rlcUtlEmptySduQ ARGS ((RlcCb *gCb,CmLListCp *sduQ));
864 #endif /* LTE_L2_MEAS */
865
866 uint8_t rlcUtlSendToMac ARGS ((RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo));
867
868 Void rlcUtlIncrementKwuStsSduTx ARGS((RlcKwuSapCb *rlckwuSap));
869
870 Void rlcUtlIncrementGenStsBytesAndPdusSent ARGS((RlcGenSts *genSts, 
871                                                        Buffer *pdu));
872
873 Void rlcUtlFreeDlMemory ARGS ((RlcCb *gCb));
874
875 Void rlcUtlInitToBeFreed ARGS ((RlcCb *gCb, RlcDlDataToBeFreed *toBeFreed));
876
877 Void rlcUtlInitializeSelfPst ARGS((RlcCb *gCb));
878
879 Void rlcUtlRaiseDlCleanupEvent ARGS((RlcCb *gCb));
880
881 Void rlcUtlAddSduToBeFreedQueue ARGS((RlcCb *gCb, RlcSdu *sdu));
882
883 Void rlcUtlAddReTxPduToBeFreedQueue ARGS((RlcCb *gCb, RlcRetx *retx));
884
885 Void rlcUtlAddTxPduToBeFreedQueue ARGS((RlcCb *gCb, RlcTx *pdu));
886
887 #ifdef LTE_L2_MEAS
888 S16 rlcUtlL2MeasDlInit ARGS((RlcCb *gCb));
889 #endif
890
891 /****************************************************************************
892  *                    Debug Functions 
893  ***************************************************************************/
894 Void ResetRLCStats ARGS((Void));
895
896 Void PrintRLCStats ARGS((Void));
897
898 Void DumpRLCDlDebugInformation ARGS((Void));
899
900 /****************************************************************************
901  *                    Activation Functions 
902  ***************************************************************************/
903 S16 rlcDlActvInit ARGS ((Ent ent,Inst inst,Region region,Reason reason)); 
904
905 S16 rlcDlActvTsk ARGS ((Pst *pst, Buffer *mBuf));
906
907 bool rlcDlUtlIsReestInProgress ARGS ((RlcDlRbCb *rbCb));
908
909 Void rlcDlUtlResetReestInProgress ARGS ((RlcDlRbCb *rbCb));
910
911 Void rlcDlUtlResetReestInProgress ARGS (( RlcDlRbCb *rbCb));
912
913 Void rlcDlUtlSetReestInProgressForAllRBs ARGS ((RlcCb *gCb, RlcDlUeCb
914          *ueCb));
915 Void rlcDlUtlSetReestInProgressForRB ARGS (( RlcCb *gCb, RlcDlRbCb *rbCb));
916
917 #ifdef LTE_L2_MEAS
918 Void rlcUtlUpdateContainedSduLst ARGS ((
919 uint8_t  sduIdx, 
920 RlcContSduLst  *contSduLst
921 ));
922 Void rlcUtlUpdateOutStandingSduLst ARGS ((
923 RlcL2MeasDlIpTh   *dlIpThPut, 
924 uint8_t           sduIdx, 
925 MsgLen            sduLen, 
926 uint32_t          sduId,
927 Bool              newIdx
928 ));
929 Void rlcUtlUpdateBurstSdus ARGS((
930 RlcCb            *gCb,         
931 RlcDlRbCb        *rbCb,
932 RlcContSduLst    *contSduLst,
933 S32              dataVol,
934 uint32_t         schPduSz
935 ));
936
937 RlcL2MeasTb * rlcUtlGetCurMeasTb ARGS((
938 RlcCb     *gCb,
939 RlcDlRbCb *rbCb
940 ));
941
942 S16 rlcUtlSndDlL2MeasNCfm ARGS((RlcCb *gCb,
943                                       RlcL2MeasReqEvt *measReqEvt,
944                                       RlcL2MeasCfmEvt *measCfmEvt));
945
946 S16 rlcUtlSndDlL2MeasCfm  ARGS ((RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));
947
948 S16 rlcUtlProcHarqInd  ARGS (( RlcCb *gCb, RguHarqStatusInd *staInd, RlcDlUeCb *ueCb, 
949                                      uint8_t tbIdx));
950 Void rlcUtlResetDlL2MeasInRlcRb ARGS ((RlcCb *gCb,
951                                             RlcL2MeasCb *measCb,
952                                             uint8_t measType));
953
954 S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, uint8_t  measType,uint8_t  status));
955
956 S16 rlcUtlValidateIpThL2Meas ARGS((RlcL2MeasReqEvt *measReqEvt, 
957                                      RlcL2MeasCfmEvt *measCfmEvt)); 
958                                     
959 S16 rlcFetchLchInfo ARGS ((RlcL2MeasReqEvt *measReqEvt,
960                                  RlcL2MeasCfmEvt *measCfmEvt,
961                                  uint16_t             ueId,
962                                  CmLteLcId *lChId,
963                                  uint8_t *numLch));
964
965 S16 rlcUtlNotifyMacUlIp ARGS ((RlcL2MeasCb *measCb,uint16_t ueIdx, Bool enable,
966                                     CmLteLcId  *lChId, uint8_t *numLCh));
967 #endif
968
969 uint8_t rlcProcDlData(Pst *pst, RlcDatReqInfo* datReq, Buffer *buf);
970 uint8_t rlcProcCommLcSchedRpt(Pst *pst, SuId suId, RguCStaIndInfo  *staInd);
971 uint8_t rlcProcDedLcSchedRpt(Pst *pst, SuId suId, RguDStaIndInfo  *staInd);
972
973 Void rlcUtlFreeDlMem ARGS(( Void));
974 #ifdef __cplusplus
975 }
976 #endif /* __cplusplus */
977
978 #endif /* __RLC_DLH__ */
979 \f  
980 /********************************************************************30**
981   
982          End of file
983 **********************************************************************/