Merge "VES PNF Registration Request changes."
[o-du/l2.git] / src / 5gnrrlc / rlc_utl_ul.c
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
21      Name:     NR RLC Layer 
22   
23      Type:     C file
24   
25      Desc:     Source code for RLC Utility Module
26                This file contains following functions
27
28                   --rlcUtlSendToMac
29                   --rlcUtlRcvFrmMac
30                   --rlcUtlEmptySduQ
31                   --rlcUtlSendUlDataToDu 
32                   --kwUtlShutDown
33
34      File:     rlc_utl_ul.c
35
36 **********************************************************************/
37
38 /** @file rlc_utl_ul.c
39 @brief RLC Utility Module 
40 */
41
42 /* header (.h) include files */
43 #include "common_def.h"
44 /* kw005.201 added support for L2 Measurement */
45 #ifdef LTE_L2_MEAS
46 #include <sys/time.h>
47 #endif
48
49 #include "ckw.h"           /* CKW defines */
50 #include "kwu.h"           /* KWU defines */
51 #include "lkw.h"           /* LKW defines */
52 #include "rgu.h"           /* RGU defines */
53 #include "rlc_env.h"        /* RLC environment options */
54 #include "rlc_err.h"        /* Error defines */
55
56
57 /* extern (.x) include files */
58 #include "ckw.x"           /* CKW includes */
59 #include "kwu.x"           /* KWU includes */
60 #include "lkw.x"           /* LKW includes */
61 #include "rgu.x"           /* RGU includes */
62
63 #include "rlc_utils.h"            /* RLC defines */
64 #include "rlc_ul.h"         /* RLC Uplink defines */
65 #include "du_app_rlc_inf.h"
66 #include "rlc_upr_inf_api.h"
67
68 #ifdef SS_RBUF
69 S16 SMrkUlPkt(Buffer *mbuf);
70 #endif
71 RlcAmRecBuf* rlcUtlGetRecBuf(CmLListCp *recBufLst, RlcSn sn);
72 #define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_UL) /* for debugging purpose */
73
74
75 /**
76  *
77  * @brief 
78  *        Handler for receiving data for multiple logical channels from MAC.
79  *
80  * @details
81  *        This function receives the data sent by MAC for one or more 
82  *        logical channels.It calls the UMM or AMM functions to process
83  *        the PDUs and send them to the uppper layer.  
84  *
85  * @param[in] gCb          - RLC instance control block 
86  * @param[in] datIndInfo   - Data Indication Information containing the PDU(s)
87  *                            for one or more logical channels  
88  *
89  * @return  S16
90  *      -# ROK 
91  *      -# RFAILED
92  *
93  */
94 uint8_t rlcUtlRcvFrmMac(RlcCb *gCb, KwDatIndInfo  *datIndInfo)
95 {
96    uint32_t    count;      /* Loop Counter */
97    KwPduInfo   *pduInfo;   /* PDU Information */
98    RlcUlRbCb    *rbCb;      /* RB Control Block */
99    RlcUlUeCb    *ueCb;      /* UE Control Block */
100
101    ueCb = NULLP;
102    
103    /* fetch UeCb  */
104    if( ROK != rlcDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
105    {
106       /* Fetch UeCb failed */
107       DU_LOG("\nERROR  -->  RLC_UL : rlcUtlRcvFrmMac : UEID:%d UeCb not found",
108                datIndInfo->rnti);
109       /* free the buffers inside the datIndInfo */
110       uint32_t i,j;
111       for(i = 0; i< datIndInfo->numLch; i++)
112       {
113          for(j = 0; j < datIndInfo->lchData[i].pdu.numPdu; j++)
114          {
115             if(datIndInfo->lchData[i].pdu.mBuf[j])
116             {
117                ODU_PUT_MSG_BUF(datIndInfo->lchData[i].pdu.mBuf[j]);
118             }
119          }
120       }
121       
122       return RFAILED;
123    }
124
125 #ifdef LTE_L2_MEAS
126
127    if (RGU_L2M_UL_BURST_START == datIndInfo->burstInd)
128    {
129       ueCb->isUlBurstActive = TRUE;
130    }
131    else
132    {
133       ueCb->firstPacketTTI = 0;
134       ueCb->isUlBurstActive = FALSE;
135    }
136 #endif
137    for ( count = 0;count < datIndInfo->numLch; count++ )
138    {
139       rbCb = ueCb->lCh[datIndInfo->lchData[count].lcId - 1].ulRbCb;
140       /* kw002.201 Removed allocation of pduInfo */ 
141       pduInfo = &(datIndInfo->lchData[count].pdu);
142       /* Fix for CR ccpu00138374,sometimes rbCb is NULL in UL path,
143        * So inorder to avoid the crash, added this preventive check
144        */
145       if(rbCb == NULLP)
146       {
147          uint32_t j;
148          for(j = 0; j < pduInfo->numPdu; j++)
149          {
150             if(pduInfo->mBuf[j])
151             {
152                ODU_PUT_MSG_BUF(pduInfo->mBuf[j]);
153             }
154          }
155          continue;
156       }
157
158 #ifdef SS_RBUF
159       SMrkUlPkt(pduInfo->mBuf[0]);
160 #endif
161       if ( rbCb->mode == RLC_MODE_UM )
162       {
163 /* kw005.201 added support for L2 Measurement */
164 #ifdef LTE_L2_MEAS
165          rlcUmmProcessPdus(gCb,rbCb, pduInfo, datIndInfo->ttiCnt);
166 #else
167          rlcUmmProcessPdus(gCb,rbCb,pduInfo);
168 #endif
169       }
170       else if (rbCb->mode == RLC_MODE_AM )
171       {
172 /* kw005.201 added support for L2 Measurement */
173 #ifdef LTE_L2_MEAS
174          rlcAmmProcessPdus(gCb,rbCb,  pduInfo, datIndInfo->ttiCnt);
175 #else
176          rlcAmmProcessPdus(gCb,rbCb,pduInfo);
177 #endif
178       }
179    }
180    return ROK;
181 }
182
183 /**
184  *
185  * @brief 
186  *    Handler for sending Data Indication to the upper layer. 
187  * 
188  * @Details
189  *    This function is used to send re-assembled SDU to the upper layer.
190  *
191  * @param[in]  gCb    - RLC instance Control Block 
192  * @param[in]  rbCb   - RB Control Block 
193  * @param[in]  sdu    - SDU to be sent to upper layer 
194  *
195  * @return  S16
196  *      -# ROK 
197  */
198 uint8_t rlcUtlSendUlDataToDu(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *sdu)
199 {
200 #ifndef KW_PDCP
201    KwuDatIndInfo   *datIndInfo;   /* Data Indication Information */
202    KwuDatIndInfo datIndInfoTmp;
203 #endif
204    RlcUlRrcMsgInfo  *ulRrcMsgInfo;
205    RlcUlUserDatInfo *ulUserDatInfo;
206    uint16_t        msgLen, copyLen;
207    Pst             pst;
208
209 #ifndef KW_PDCP
210    /* Creating static memory for KwuDatIndInfo. #else will be 
211     * removed once the testing is done on all platforms */
212    datIndInfo = &datIndInfoTmp;
213    if (datIndInfo == NULLP)
214    {
215       DU_LOG("\nERROR  -->  RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
216          CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
217       ODU_PUT_MSG_BUF(sdu);
218       return RFAILED;
219    }
220
221    RLC_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
222    /* Set the "isOutofSeq" flag for each packet 
223     * If packets are in-sequence set flag as TRUE else FALSE */
224    datIndInfo->isOutOfSeq = rbCb->m.amUl.isOutOfSeq; 
225 #endif /* KW_PDCP */
226    
227    if(rbCb->rlcId.rbType == RB_TYPE_SRB)
228    {
229       /* Filling UL RRC Message Info if UL msg is not received on SRBs*/
230       RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
231             ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
232       if (ulRrcMsgInfo)
233       {
234          ulRrcMsgInfo->cellId = rbCb->rlcId.cellId;
235          ulRrcMsgInfo->ueIdx = rbCb->rlcId.ueId;
236          ulRrcMsgInfo->lcId = rbCb->lch.lChId;
237          RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
238                ulRrcMsgInfo->rrcMsg, msgLen);
239          if (ulRrcMsgInfo->rrcMsg)
240          {
241             ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
242             ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulRrcMsgInfo->rrcMsg, (MsgLen *)&copyLen);
243             ulRrcMsgInfo->msgLen = msgLen;
244
245             /* Sending UL RRC Message transfeer to DU APP */
246             memset(&pst, 0, sizeof(Pst));
247             FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_RRC_MSG_TRANS_TO_DU);
248             rlcSendUlRrcMsgToDu(&pst, ulRrcMsgInfo);
249          }
250          else
251          {
252             DU_LOG("\nERROR  -->  RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
253             RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
254             return RFAILED;
255          }
256       }
257       else
258       {
259          DU_LOG("\nERROR  -->  RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
260          return RFAILED;
261       }
262    }
263    else if(rbCb->rlcId.rbType == RB_TYPE_DRB)
264    {
265       /* Filling UL User Data Info if UL msg is received on a DRB */
266       RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
267       if (ulUserDatInfo)
268       {
269          ulUserDatInfo->cellId = rbCb->rlcId.cellId;
270          ulUserDatInfo->ueIdx = rbCb->rlcId.ueId;
271          ulUserDatInfo->rbId = rbCb->rlcId.rbId;
272          RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo->userData, msgLen);
273          if (ulUserDatInfo->userData)
274          {
275             ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
276             ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulUserDatInfo->userData, (MsgLen *)&copyLen);
277             ulUserDatInfo->msgLen = msgLen;
278
279             /* Sending UL RRC Message transfeer to DU APP */
280             memset(&pst, 0, sizeof(Pst));
281             FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_USER_DATA_TRANS_TO_DU);
282             rlcSendUlUserDataToDu(&pst, ulUserDatInfo);
283          }
284          else
285          {
286             DU_LOG("\nERROR  -->  RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for user data");
287             RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
288             return RFAILED;
289          }
290       }
291       else
292       {
293          DU_LOG("\nERROR  -->  RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulUserDatInfo");
294          return RFAILED;
295       }
296    }
297    return ROK;
298 } /* rlcUtlSendUlDataToDu */
299
300
301 static Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
302 {
303    if(ulRbCb->mode == RLC_MODE_UM)
304    {
305       uint32_t i;
306       uint32_t pdusInReceptionBuffer = 0;
307       uint32_t totalSegs = 0;
308
309       for(i = 0; i< RLC_RCV_BUF_BIN_SIZE; i++)
310       {
311          RlcUmRecBuf *recBuf = rlcUtlGetUmRecBuf(ulRbCb->m.umUl.recBufLst, i);
312          if(recBuf != NULLP)
313          {
314              pdusInReceptionBuffer++;
315              totalSegs += (recBuf->segLst.count);
316          }
317       }
318       
319       DU_LOG("\nDEBUG  -->  RLC_UL: UM UL UEID:%d CELLID:%d Reception Buffer size = %d Total segs = %d", 
320          ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
321    }
322    else if(ulRbCb->mode == RLC_MODE_AM)
323    {
324       uint32_t i;
325       uint32_t pdusInReceptionBuffer = 0;
326       uint32_t totalSegs = 0;
327       uint32_t windSz  = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
328       
329       for(i = 0; i< windSz; i++)
330       {
331          RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(ulRbCb->m.amUl.recBufLst, i);
332          if(recBuf != NULLP)
333          {
334             pdusInReceptionBuffer++;
335             totalSegs += (recBuf->segLst.count);
336          }
337       }
338
339       DU_LOG("\nDEBUG  -->  RLC_UL: AM UL UEID:%d CELLID:%d Reception Buf size = %d total segs = %d", 
340          ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
341    }
342 }
343
344 Void DumpRLCUlDebugInformation(Void)
345 {
346    RlcCb* ulInst = rlcCb[0]; /* TODO : Check whether UL is 0 or 1 */
347    RlcUlCb* ulCb = ulInst->u.ulCb;
348    RlcUlUeCb *ueCb = NULLP; 
349
350    /* Until no more ueCb is ueLstCp hash list get and delete ueCb */
351    while (ROK == cmHashListGetNext(&ulCb->ueLstCp, 
352                                    (PTR) ueCb, 
353                                    (PTR *)&ueCb))
354    {
355       uint32_t i;
356       for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
357       {
358          RlcUlRbCb* ulRbCb = ueCb->srbCb[i]; 
359          if(ulRbCb != NULLP)
360          {
361             dumpRLCUlRbInformation(ulRbCb);
362          }
363       }
364       for(i = 0; i< RLC_MAX_DRB_PER_UE; i++)
365       {
366          RlcUlRbCb* ulRbCb = ueCb->drbCb[i]; 
367          if(ulRbCb != NULLP)
368          {
369             dumpRLCUlRbInformation(ulRbCb);
370          }
371       }
372    }
373 }
374
375
376 /*
377  * kwUtlFreeUlRbCb() function is split into two functions 
378  *  -  rlcAmmFreeUlRbCb() ---> gp_amm_ul.c 
379  *  -  rlcUmmFreeUlRbCb() ---> gp_umm_ul.c
380  * and placed in respective files mentioned above
381  */
382
383
384
385 /* kw005.201 added support for L2 Measurement */
386 #ifdef LTE_L2_MEAS
387
388 /**
389  *
390  * @brief 
391  *    Handler for initialisation of measurement 
392  * 
393  * @param[in]  gCb    - RLC instance Control Block 
394  *
395  * @return  S16
396  *      -# ROK 
397  */
398 S16 rlcUtlL2MeasUlInit(RlcCb *gCb)
399 {
400    uint16_t             cntr;
401
402    gCb->u.ulCb->rlcL2Cb.rlcNumMeas=0;
403    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
404    {
405       memset(&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
406    }
407    gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
408    return ROK;
409 }
410 /**
411  *
412  * @brief
413  *
414  *        Handler to calculate the Ul Ip throughput for a LCH
415  *
416  * @b Description:
417  *
418  *
419  * @param[in] rbCb         RB control block
420  * @param[in] pdu          Pdu of LCH
421  *
422  *  @return  Void
423  *
424  */
425 Void rlcUtlCalUlIpThrPutIncTTI(RlcCb *gCb,RlcUlRbCb *rbCb,uint32_t ttiCnt)
426 {
427    volatile uint32_t     startTime = 0;
428
429       /*starting Task*/
430       SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
431 #ifndef ALIGN_64BIT
432    DU_LOG("\nDEBUG  -->  RLC_UL : Log for ul ip throughput:"
433          "RB_MeasOn:%d ttiCnt :%ld UEID:%d CELLID:%d", 
434          rbCb->rbL2Cb.measOn,ttiCnt,
435          rbCb->rlcId.ueId,
436          rbCb->rlcId.cellId);
437 #else
438    DU_LOG("\nDEBUG  -->  RLC_UL : Log for ul ip throughput:"
439          "RB_MeasOn:%d ttiCnt :%d UEID:%d CELLID:%d", 
440          rbCb->rbL2Cb.measOn,ttiCnt,
441          rbCb->rlcId.ueId,
442          rbCb->rlcId.cellId);
443 #endif
444
445    /*Check if UL IP throughput measurement is ON for this RB or not*/
446    if(RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb,rbCb))              
447    {
448       if (TRUE  == rbCb->ueCb->isUlBurstActive)
449       {
450          if (ttiCnt < rbCb->l2MeasIpThruput.prevTtiCnt)
451          {
452             /*Removed Error Print*/
453          }
454          if (rbCb->l2MeasIpThruput.prevTtiCnt != 0)
455          {
456             rbCb->rbL2Cb.l2Sts[RLC_L2MEAS_UL_IP]->ulIpThruput.timeSummation += 
457                (ttiCnt - rbCb->l2MeasIpThruput.prevTtiCnt);
458          }
459          else
460          {
461             rbCb->ueCb->firstPacketTTI = ttiCnt;
462          }
463          rbCb->l2MeasIpThruput.prevTtiCnt = ttiCnt;
464       }
465       else
466       {
467          rbCb->l2MeasIpThruput.prevTtiCnt = 0;
468       }
469    }   
470
471    /*stopping Task*/
472    SStopTask(startTime, PID_RLC_IP_TPT_INCTTI);
473 } /* rlcUtlCalUlIpThrPutIncTTI */
474
475
476 /**
477  *
478  * @brief
479  *
480  *        Handler to calculate the Ul Ip throughput for a LCH
481  *
482  * @b Description:
483  *
484  *
485  * @param[in] rbCb         RB control block
486  * @param[in] pdu          Pdu of LCH
487  *
488  *  @return  Void
489  *
490  */
491 Void rlcUtlCalUlIpThrPut
492 (
493 RlcCb        *gCb,
494 RlcUlRbCb    *rbCb,
495 Buffer       *pdu,
496 uint32_t     ttiCnt
497 )
498 {
499    MsgLen        rlcSduSz = 0;  /*Holds length of Rlc Sdu*/
500    volatile uint32_t     startTime = 0;
501
502    /*starting Task*/
503    SStartTask(&startTime, PID_RLC_IP_TPT_INCVOL);
504
505    /*Check if UL IP throughput measurement is ON for this RB or not*/
506    if(RLC_MEAS_IS_UL_IP_MEAS_ON_FOR_RB(gCb, rbCb) &&              
507          (TRUE  == rbCb->ueCb->isUlBurstActive) &&
508          (rbCb->ueCb->firstPacketTTI) &&
509          (ttiCnt != rbCb->ueCb->firstPacketTTI))
510    {
511       SFndLenMsg(pdu, &rlcSduSz);
512
513       rbCb->rbL2Cb.l2Sts[RLC_L2MEAS_UL_IP]->ulIpThruput.volSummation += rlcSduSz;
514
515    }
516    /*stopping Task*/
517    SStopTask(startTime, PID_RLC_IP_TPT_INCVOL);
518 } /* rlcUtlCalUlIpThrPut */
519
520 \f
521 /**
522  *
523  * @brief Handler for L2 Measurement timer expiry.
524  *
525  *
526  * @b Description
527  *        This function is called when the l2 measurement timer expires. 
528  *        This function sends a consolidates the mesaurements taken during
529  *        this time and sends the confirm .
530  *
531  *  @param[in] measEvtCb    Measurement Event Control Block.
532  *
533  *
534  *  @return  S16
535  *      -# ROK
536  */
537
538 S16 rlcUtlHdlL2TmrExp(RlcCb *gCb,RlcL2MeasEvtCb *measEvtCb)
539 {
540
541 #ifdef LTE_L2_MEAS_RLC
542    uint16_t             qciIdx;
543    RlcL2MeasCb     *measCb;
544    
545    /* Clean up the RB data structures */
546    if((measEvtCb->measCb.measType & LKW_L2MEAS_ACT_UE) &&
547       (measEvtCb->measCb.val.nonIpThMeas.numSamples))
548    {
549       measCb = &measEvtCb->measCb;
550
551       for(qciIdx = 0; qciIdx < measCb->val.nonIpThMeas.numQci;qciIdx++)
552       {
553          measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.numActvUe   +=   
554                      rlcCb.rlcL2Cb.numActUe[measCb->val.nonIpThMeas.qci[qciIdx]];
555          measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.sampOc++;
556       }
557       measEvtCb->val.nonIpThMeas.measCb.numSamples--;
558       rlcStartTmr(gCb, (PTR)measEvtCb, EVENT_RLC_L2_TMR); 
559       return (ROK);
560    }
561 #endif
562
563    rlcUtlSndUlL2MeasCfm(gCb, measEvtCb);
564
565    return (ROK);
566 } /* rlcUtlHdlL2TmrExp */
567 /**
568  *
569  * @brief Handler for Sending L2 Measurement confirm.
570  *
571  *
572  * @b Description
573  *        This function sends a consolidates the mesaurements taken during
574  *        this time and sends the confirm .
575  *
576  *  @param[in] measEvtCb    Measurement Event Control Block.
577  *
578  *
579  *  @return  S16
580  *      -# ROK
581  */
582
583 S16 rlcUtlSndUlL2MeasCfm(RlcCb *gCb,RlcL2MeasEvtCb  *measEvtCb)
584 {
585    uint32_t            qciIdx;
586    RlcL2MeasCb         *measCb;
587    RlcL2MeasCfmEvt     measCfmEvt;
588    uint64_t            ulDataVol;
589    uint64_t            ulTime;
590    uint16_t            cntr;
591    /* Discard new changes starts */
592    uint8_t             qci = 0;
593    uint32_t            cfmIdx =0;
594    /* Discard new changes ends */
595
596    /* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
597 #ifndef ALIGN_64BIT
598    DU_LOG("\nDEBUG  -->  RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
599 #else
600    DU_LOG("\nDEBUG  -->  RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
601 #endif
602
603    /* Clean up the RB data structures */
604    measCb = &measEvtCb->measCb;
605    
606    memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
607    measCfmEvt.transId = measEvtCb->transId;
608
609    measCfmEvt.measType = measCb->measType;
610    measCfmEvt.status.status = LCM_PRIM_OK;
611    measCfmEvt.status.reason = LCM_REASON_NOT_APPL;
612    
613    if( measCb->measType & LKW_L2MEAS_UL_IP)
614    {
615       RlcL2MeasCbUeMeasInfo *pUeInfoLstCb  = measCb->val.ipThMeas.ueInfoLst;
616       RlcL2MeasCfmUeInfoLst *pUeInfoLstCfm = measCfmEvt.val.ipThMeas.ueInfoLst;
617       for(cntr = 0;(cntr < measCb->val.ipThMeas.numUes) && (cntr < gCb->genCfg.maxUe);cntr++)        
618       {
619          pUeInfoLstCfm[cfmIdx].numCfm = 0;
620          if (pUeInfoLstCb[cntr].isValid == TRUE)
621          {
622             pUeInfoLstCfm[cfmIdx].ueId = pUeInfoLstCb[cntr].ueId;
623             pUeInfoLstCfm[cfmIdx].cellId = pUeInfoLstCb[cntr].cellId;
624
625             for(qciIdx = 0; qciIdx < pUeInfoLstCb[cntr].numQci; qciIdx++)
626             {
627                qci = pUeInfoLstCb[cntr].qci[qciIdx];
628                pUeInfoLstCfm[cfmIdx].measCfm[pUeInfoLstCfm[cfmIdx].numCfm].qci = qci;
629
630                if(measCb->measType & LKW_L2MEAS_UL_IP)
631                {
632                   ulDataVol = pUeInfoLstCb[cntr].measData[qci].ulIpThruput.volSummation;
633                   ulTime = pUeInfoLstCb[cntr].measData[qci].ulIpThruput.timeSummation;
634                   if(0 == ulTime)
635                   {
636                      pUeInfoLstCfm[cfmIdx].measCfm[pUeInfoLstCfm[cfmIdx].numCfm].val.ipThrput.ulIpThPut = 0;
637                   }
638                   else
639                   {
640                      pUeInfoLstCfm[cfmIdx].measCfm[pUeInfoLstCfm[cfmIdx].numCfm].val.ipThrput.ulIpThPut = (ulDataVol / ulTime);
641
642                      /* Converting it to kbps */
643                      pUeInfoLstCfm[cfmIdx].measCfm[pUeInfoLstCfm[cfmIdx].numCfm].val.ipThrput.ulIpThPut *= 8;
644
645                   }
646                   /* Reset the values after reporting to Application */
647                   pUeInfoLstCb[cntr].measData[qci].ulIpThruput.volSummation = 0;
648                   pUeInfoLstCb[cntr].measData[qci].ulIpThruput.timeSummation = 0;
649                }
650                pUeInfoLstCfm[cfmIdx].numCfm++;
651             }
652             cfmIdx++;
653          }
654       }
655       measCfmEvt.val.ipThMeas.numUes = cfmIdx; 
656    }
657    RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, &measCfmEvt);
658    return (ROK);
659 } /* rlcUtlSndUlL2MeasCfm */
660 /**
661  *
662  * @brief Handler for Sending Negative confirm .
663  *
664  *
665   @b Description
666  *        This function is called when the l2 measurement cannot be started
667  *        This function sends  negative confirm for all the requests
668  *
669  * @param[in] gCb - RLC instance control block
670  * @param[in] measReqEvt    Measurement Req Structure
671  * @param[in] measCfmEvt  Confirmation to be sent to layer manager
672  *
673  *
674  *  @return  S16
675  *      -# ROK
676  */
677
678 S16 rlcUtlSndUlL2MeasNCfm(RlcCb *gCb,RlcL2MeasReqEvt *measReqEvt,RlcL2MeasCfmEvt *measCfmEvt)
679 {
680
681    RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
682    return ROK;
683 } /* kwUtlSndL2MeasNCfm */
684
685 #ifdef LTE_L2_MEAS_RLC
686 /**
687  * @brief  Validates the measurement request parameters. 
688  *
689  * @details
690  *
691  *     Function :rlcUtlValidateL2Meas 
692  *
693  *  @param[in]  measReqEvt L2 measurement request received from layer manager.
694  *  @param[out] measCfmEvt L2 measurement confirm to be prepared.
695  *  @param[out] lChId      List of LCh for the given Ue corresponding to QCIs
696                            given in measurement request.
697  *  @param[out] numLCh     Number of LCh in array lChId.
698  **/
699
700 S16 rlcUtlValidateL2Meas
701 (
702 RlcL2MeasReqEvt *measReqEvt,
703 RlcL2MeasCfmEvt *measCfmEvt,
704 CmLteLcId       *lChId,
705 uint8_t         *numLCh
706 )
707 {
708    uint8_t    measType;
709    S16        ret;
710    uint8_t    qciIdx;
711    uint8_t    qci;
712    uint8_t    idx;
713    uint8_t    *qciVal;
714    uint8_t    numQci;
715    RlcUlRbCb  *rbCb;
716    RlcUlUeCb  *ueCb;
717    RbCb       **rbCbLst;
718    uint8_t    rbIdx;
719    uint8_t    lsbNibble = 0;
720    uint8_t    msbNibble = 0;
721    uint8_t    numFaild = 0;
722
723    idx = 0;
724    rbCb = NULLP;
725    ret = ROK;
726    measType = measReqEvt->measReq.measType;
727    /* Check for the range of measType */
728    /* LKW_L2MEAS_DL_IP+ LKW_L2MEAS_UL_IP = 0x0030*/
729    if((measType == 0x00) ||
730        measType > 0x30)
731    {
732       measCfmEvt->transId = measReqEvt->transId;
733       measCfmEvt->measType = measType;
734       measCfmEvt->status.status = LCM_PRIM_NOK;
735       measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
736       return RFAILED;
737    }
738    /*User can either request for Active UE,*
739     *Dl delay, Dl discard, Uu Loss OR Dl ip throughput, Ul ip throughput. */
740    lsbNibble = measType & 0x0F;
741    msbNibble = measType & 0xF0;
742
743    if( (lsbNibble != 0) && (msbNibble != 0) )
744    {
745       measCfmEvt->transId = measReqEvt->transId;
746       measCfmEvt->measType = measType;
747       measCfmEvt->status.status = LCM_PRIM_NOK;
748       measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
749       return RFAILED;
750    }
751
752    /* Check for total maximum number of Measurement Control Block */
753    if(rlcCb.rlcL2Cb.rlcNumMeas >= LKW_MAX_L2MEAS )
754    {
755       measCfmEvt->transId = measReqEvt->transId;
756       measCfmEvt->measType = measType;
757       measCfmEvt->status.status = LCM_PRIM_NOK;
758       measCfmEvt->status.reason = LKW_CAUSE_EXCEED_NUMMEAS;
759       return RFAILED;
760    }
761
762    /* Check that number of samples should be a non-zero value */
763    if(((measType & LKW_L2MEAS_ACT_UE) &&
764       (measReqEvt->measReq.val.nonIpThMeas.numSamples == 0)))
765    {
766       measCfmEvt->transId = measReqEvt->transId;
767       measCfmEvt->measType = measType;
768       measCfmEvt->status.status = LCM_PRIM_NOK;
769       measCfmEvt->status.reason = LKW_CAUSE_ZERO_NUMSAM;
770       return RFAILED;
771    }
772    /* Check that measurement period  should be completely divisible *
773     * number of sample.                                             */
774    if(((measType & LKW_L2MEAS_ACT_UE) &&
775       ((measReqEvt->measPeriod % 
776         measReqEvt->measReq.val.nonIpThMeas.numSamples) != 0)))
777    {
778       measCfmEvt->transId = measReqEvt->transId;
779       measCfmEvt->measType = measType;
780       measCfmEvt->status.status = LCM_PRIM_NOK;
781       measCfmEvt->status.reason = LKW_CAUSE_INVALID_NUMSAM;
782       return RFAILED;
783    }
784    {
785       numQci = measReqEvt->measReq.val.nonIpThMeas.numQci;
786       qciVal = measReqEvt->measReq.val.nonIpThMeas.qci;
787    }
788    /* Check whether qci is configured or not */
789    for(qciIdx = 0; qciIdx < numQci; qciIdx++)
790    {
791       qci = qciVal[qciIdx];
792       ret = cmHashListFind(&(rlcCb.rlcL2Cb.qciHlCp), 
793             (uint8_t *)&qci, (uint16_t)sizeof(qci), 0, (PTR *)&rbCb);
794       if(ret != ROK)
795       {
796          measCfmEvt->val.nonIpThMeas.measCfm[measCfmEvt->val.nonIpThMeas.numCfm].qci = qci;
797          measCfmEvt->val.nonIpThMeas.numCfm++;
798
799       }
800    }
801    if(measCfmEvt->val.nonIpThMeas.numCfm > 0)
802    {
803       measCfmEvt->status.status = LCM_PRIM_NOK;
804       measCfmEvt->status.reason = LKW_CAUSE_INVALID_QCI;
805       measCfmEvt->measType = measType;
806       measCfmEvt->transId = measReqEvt->transId;
807       return RFAILED;
808    }
809    {
810       for(qciIdx = 0; qciIdx < numQci; qciIdx++)
811       {
812          if(rlcCb.rlcL2Cb.measOn[qci] & measReqEvt->measReq.measType)
813          {
814             /* measurement is already ongoing */
815             measCfmEvt->status.status = LCM_PRIM_NOK;
816             measCfmEvt->status.reason = LKW_CAUSE_MEAS_ALREADY_ENA;
817             measCfmEvt->val.nonIpThMeas.measCfm[measCfmEvt->val.nonIpThMeas.numCfm].qci = qci;
818             measCfmEvt->measType = measType;
819             measCfmEvt->val.nonIpThMeas.numCfm++;
820          }
821       }
822    }
823    if(measCfmEvt->val.nonIpThMeas.numCfm > 0)
824    {
825       measCfmEvt->transId = measReqEvt->transId;
826       return RFAILED;
827    }
828
829    return (ROK);
830 }/* rlcUtlValidateL2Meas */
831 #endif
832
833 S16 rlcUtlValidateIpThL2Meas(RlcL2MeasReqEvt *measReqEvt,RlcL2MeasCfmEvt *measCfmEvt)
834 {
835    uint8_t      measType;
836    uint8_t         lsbNibble = 0;
837    uint8_t         msbNibble = 0;
838
839    measType = measReqEvt->measReq.measType;
840    /* Check for the range of measType */
841    /* LKW_L2MEAS_DL_IP+ LKW_L2MEAS_UL_IP = 0x0030*/
842    if((measType == 0x00) ||
843        measType > 0x30)
844    {
845       measCfmEvt->transId = measReqEvt->transId;
846       measCfmEvt->measType = measType;
847       measCfmEvt->status.status = LCM_PRIM_NOK;
848       measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
849       return RFAILED;
850    }
851    /*User can either request for Active UE,*
852     *Dl delay, Dl discard, Uu Loss OR Dl ip throughput, Ul ip throughput. */
853    lsbNibble = measType & 0x0F;
854    msbNibble = measType & 0xF0;
855
856    if( (lsbNibble != 0) && (msbNibble != 0) )
857    {
858       measCfmEvt->transId = measReqEvt->transId;
859       measCfmEvt->measType = measType;
860       measCfmEvt->status.status = LCM_PRIM_NOK;
861       measCfmEvt->status.reason = LKW_CAUSE_INVALID_MEASTYPE;
862       return RFAILED;
863    }
864    return (ROK);
865 }/* rlcUtlValidateL2Meas */
866
867 /**
868  *
869  * @brief Handler for resetting the RB data structures
870  *
871  *
872  * @b Description
873  *        This function resets the RB data structure after the expiry of 
874  *        measurement timer.
875  *
876  *  @param[in] measCb    Measurement Control Block.
877  *
878  *
879  *  @return  Void
880  */
881
882 Void rlcUtlResetUlL2MeasInRlcRb(RlcCb *gCb,RlcL2MeasCb *measCb,uint8_t measType)
883 {
884    uint32_t           rbIdx;
885    uint32_t           ueIdx;
886    uint32_t           qciIdx;
887    RlcUlUeCb         *ueCb = NULL;
888
889
890
891    if (measCb->measType & LKW_L2MEAS_UL_IP)
892    {
893       for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
894       {           
895          if (measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid == TRUE)
896          {
897             for (qciIdx =0; qciIdx < measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci; qciIdx++)
898             {
899                if (measType & LKW_L2MEAS_UL_IP)
900                {
901                   measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[qciIdx].ulIpThruput.volSummation = 0;
902                   measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[qciIdx].ulIpThruput.timeSummation = 0;
903                }
904             }
905
906             if(ROK  != rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId,
907                      measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId, &ueCb))
908             {
909                continue;
910             }
911
912             for (rbIdx = 0; rbIdx < RLC_MAX_DRB_PER_UE; rbIdx++)
913             {
914                if (ueCb->drbCb[rbIdx])
915                {
916                   ueCb->drbCb[rbIdx]->rbL2Cb.measOn &= ~measType;
917                }
918             }
919          }
920       }
921    }
922 } /* rlcUtlResetUlL2MeasInRlcRb */
923
924 /**
925  *
926  * @brief Handler for storing address of MeasData in rbCb at right index
927  *
928  *
929  * @b Description
930  *        This function is called when LM sends measReq message to RLC.
931  *
932  *  @param[in] 
933  *  @param[out] 
934  *  @param[in] 
935  *
936  *
937  *  @return  S16
938  *      -# ROK
939  */
940 Void rlcUtlPlcMeasDatInL2Sts(RlcL2Cntr *measData,RlcL2MeasRbCb *rbL2Cb,uint8_t measType)
941 {
942    /* We should check the number of measType in the request. This can be done 
943     * by looking at each bit in the measType. Also store the measData in the 
944     * correct index of l2Sts in RbCb.
945     * */
946
947     if(measType & LKW_L2MEAS_ACT_UE)
948     {
949          rbL2Cb->l2Sts[RLC_L2MEAS_ACT_UE] = measData;
950     }
951     if(measType & LKW_L2MEAS_UU_LOSS)
952     {
953          rbL2Cb->l2Sts[RLC_L2MEAS_UU_LOSS] = measData;
954     }
955     if(measType & LKW_L2MEAS_DL_IP )
956     {
957          rbL2Cb->l2Sts[RLC_L2MEAS_DL_IP] = measData;
958     }
959     if(measType & LKW_L2MEAS_UL_IP)
960     {
961          rbL2Cb->l2Sts[RLC_L2MEAS_UL_IP] = measData;
962     }
963     if(measType & LKW_L2MEAS_DL_DISC)
964     {
965          rbL2Cb->l2Sts[RLC_L2MEAS_DL_DISC] = measData;
966     }
967     if(measType & LKW_L2MEAS_DL_DELAY)
968     {
969          rbL2Cb->l2Sts[RLC_L2MEAS_DL_DELAY] = measData;
970     }
971 }/* End of rlcUtlPlcMeasDatInL2Sts */
972 #endif /* LTE_L2_MEAS */
973
974 /**
975  *
976  * @brief Store the UL buffer in hashList  
977  *
978  *
979  * @b Description
980  *
981  *   Use the SN % binSize as key and store the received UL buffer
982  *  @param[in] recBufLst       List CP array
983  *  @param[in] recBuf          received buffer
984  *  @param[in] sn              sn of the received buffer 
985  *
986  *
987  *  @return  Void
988  */
989 void rlcUtlStoreRecBuf(CmLListCp *recBufLst, RlcAmRecBuf *recBuf, RlcSn sn)
990 {
991    uint32_t    hashKey; 
992    
993    hashKey = (sn % RLC_RCV_BUF_BIN_SIZE ); 
994    recBuf->lnk.node = (PTR)recBuf;
995    cmLListAdd2Tail(&(recBufLst[hashKey]), &recBuf->lnk);
996
997    return;
998 } /* rlcUtlStoreRecBuf */
999
1000 /**
1001  *
1002  * @brief Retrieve the UL buffer from the list
1003  *
1004  *
1005  * @Description
1006  *
1007  *   Use the SN % binSize as key and retrieve the UL buffer
1008  *  @param[in] recBufLst       List CP array
1009  *  @param[in] sn              sn of the received buffer 
1010  *
1011  *
1012  *  @return  Void
1013  */
1014 RlcAmRecBuf* rlcUtlGetRecBuf(CmLListCp *recBufLst, RlcSn sn)
1015 {
1016    uint32_t            hashKey; 
1017    CmLListCp           *recBufLstCp;
1018    RlcAmRecBuf         *recBuf;
1019    CmLList             *node = NULLP;
1020
1021    hashKey = (sn % RLC_RCV_BUF_BIN_SIZE ); 
1022  
1023    recBufLstCp = &recBufLst[hashKey];
1024    CM_LLIST_FIRST_NODE(recBufLstCp, node);
1025    while(node)
1026    {
1027       recBuf = (RlcAmRecBuf *) node->node;
1028       if(recBuf->amHdr.sn == sn)
1029       {
1030          return recBuf;
1031       }
1032       CM_LLIST_NEXT_NODE(recBufLstCp, node);
1033    }
1034    return NULLP;
1035 } /* rlcUtlGetRecBuf */
1036 /**
1037  *
1038  * @brief Delete the UL buffer from the list
1039  *
1040  *
1041  * @Description
1042  *
1043  *   Use the SN % binSize as key and retrieve the UL buffer
1044  *  @param[in] recBufLst       List CP array
1045  *  @param[in] sn              sn of the received buffer 
1046  *
1047  *
1048  *  @return  Void
1049  */
1050 void rlcUtlDelRecBuf(CmLListCp *recBufLst, RlcAmRecBuf *recBuf, RlcCb *gCb)
1051 {
1052    uint32_t            hashKey; 
1053    CmLListCp           *recBufLstCp;
1054
1055    hashKey = (recBuf->amHdr.sn % RLC_RCV_BUF_BIN_SIZE ); 
1056  
1057    recBufLstCp = &recBufLst[hashKey];
1058    cmLListDelFrm(recBufLstCp, &recBuf->lnk);
1059    RLC_FREE(gCb, recBuf, sizeof(RlcAmRecBuf));
1060
1061    return;
1062 } /* rlcUtlDelRecBuf */
1063
1064 /**
1065  *
1066  * @brief Store the UL buffer in hashList  
1067  *
1068  * @b Description
1069  *
1070  *  Use the SN % binSize as key and store the received UL buffer
1071  *  @param[in] recBufLst       List CP array
1072  *  @param[in] recBuf          received buffer
1073  *  @param[in] sn              sn of the received buffer 
1074  *
1075  *  @return  Void
1076  */
1077 void rlcUtlStoreUmRecBuf(CmLListCp *recBufLst, RlcUmRecBuf *recBuf, RlcSn sn)
1078 {
1079    uint32_t    hashKey; 
1080    
1081    hashKey = (sn % RLC_RCV_BUF_BIN_SIZE ); 
1082    recBuf->lnk.node = (PTR)recBuf;
1083    cmLListAdd2Tail(&(recBufLst[hashKey]), &recBuf->lnk);
1084
1085    return;
1086 } /* rlcUtlStoreUmRecBuf */
1087
1088 /**
1089  *
1090  * @brief Retrieve the UL buffer from the list
1091  *
1092  * @Description
1093  *
1094  *   Use the SN % binSize as key and retrieve the UL buffer
1095  *  @param[in] recBufLst       List CP array
1096  *  @param[in] sn              sn of the received buffer 
1097  *
1098  *  @return  Void
1099  */
1100 RlcUmRecBuf* rlcUtlGetUmRecBuf(CmLListCp *recBufLst, RlcSn sn)
1101 {
1102    uint32_t            hashKey; 
1103    CmLListCp           *recBufLstCp;
1104    RlcUmRecBuf         *recBuf;
1105    CmLList             *node = NULLP;
1106
1107    hashKey = (sn % RLC_RCV_BUF_BIN_SIZE ); 
1108  
1109    recBufLstCp = &recBufLst[hashKey];
1110    CM_LLIST_FIRST_NODE(recBufLstCp, node);
1111    while(node)
1112    {
1113       recBuf = (RlcUmRecBuf *) node->node;
1114       if(recBuf->umHdr.sn == sn)
1115       {
1116          return recBuf;
1117       }
1118       CM_LLIST_NEXT_NODE(recBufLstCp, node);
1119    }
1120    return NULLP;
1121 } /* rlcUtlGetUmRecBuf */
1122
1123 /**
1124  *
1125  * @brief Delete the UM Mode UL buffer from the list
1126  *
1127  *
1128  * @details
1129  *   Use the SN % binSize as key and retrieve the UL buffer
1130  *
1131  *  @param[in] *recBufLst       List CP array
1132  *  @param[in] *recBuf          Received buffer
1133  *
1134  *  @return  Void
1135  */
1136 void rlcUtlDelUmRecBuf(RlcCb *gCb, CmLListCp *recBufLst, RlcUmRecBuf  *recBuf)
1137 {
1138    uint32_t   hashKey;
1139    CmLListCp  *recBufLstCp;
1140
1141    hashKey = (recBuf->sn % RLC_RCV_BUF_BIN_SIZE );
1142    recBufLstCp = &recBufLst[hashKey];
1143    cmLListDelFrm(recBufLstCp, &recBuf->lnk);
1144    RLC_FREE(gCb, recBuf, sizeof(RlcUmRecBuf));
1145
1146    return;
1147 } /* rlcUtlDelUmRecBuf */
1148
1149 /********************************************************************30**
1150          End of file
1151 **********************************************************************/