90cfcd22f946b882db7a0c1924528675951bce27
[o-du/l2.git] / src / 5gnrrlc / rlc_msg_hdl.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 /* header include files (.h) */
20 #include "common_def.h"
21 #include "rgu.h"           /* RGU interface includes*/
22 #include "lkw.h"           /* LKW defines */
23 #include "ckw.h"           /* CKW defines */
24 #include "kwu.h"           /* KWU defines */
25 #include "rlc_env.h"        /* RLC environment options */
26 #include "rlc_err.h"
27
28
29 /* header/extern include files (.x) */
30 #include "rgu.x"           
31 #include "lkw.x"           /* LKW */
32 #include "ckw.x"           /* CKW */
33 #include "kwu.x"           /* KWU */
34
35 #include "rlc_utils.h"            /* RLC defines */
36 #include "rlc_dl_ul_inf.h"
37 #include "rlc_dl.h"
38 #include "rlc_ul.h"
39 #include "rlc_mac_inf.h"
40 #include "du_app_rlc_inf.h"
41 #include "rlc_upr_inf_api.h"
42 #include "rlc_mgr.h"
43 /*******************************************************************
44  *
45  * @brief Fills RLC UL UE Cfg Rsp from RlcCRsp 
46  *
47  * @details
48  *
49  *    Function : fillRlcUeCfgRsp
50  *
51  *    Functionality: 
52  *     Fills RLC UL UE Cfg Rsp from RlcCRsp
53  * 
54  *  @params[in]  Pointer to RlcCfgCfm
55  *               Pointer to RlcUeCfgRsp
56  *
57  *  @return ROK/RFAILED
58  * 
59  *****************************************************************/
60
61 uint8_t fillRlcUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp)
62 {
63    uint8_t idx;
64    uint8_t ret = ROK;
65  
66    rlcCfgRsp->cellId = rlcCRsp->cellId;
67    rlcCfgRsp->ueIdx  = rlcCRsp->ueId;
68    for(idx = 0; idx < rlcCRsp->numEnt; idx++)
69    {
70       if(rlcCRsp->entCfgCfm[idx].status.status == CKW_CFG_CFM_OK)
71       {
72          rlcCfgRsp->result = RLC_DU_APP_RSP_OK;
73          rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason;
74          ret = ROK;
75       }
76       else
77       {
78          rlcCfgRsp->result = RLC_DU_APP_RSP_NOK;
79          rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason;
80          ret = RFAILED;
81          break;
82       }
83    }
84    return ret;
85 }
86
87 /*******************************************************************
88  *
89  * @brief Fills the entity mode and direction compiling to seed code
90  *
91  * @details
92  *
93  *    Function : fillEntModeAndDir
94  *
95  *    Functionality:
96  *      Fills the entity mode and direction compiling to seed code
97  *
98  * @params[in] Pointer to entMode
99  *             Pointer to direction
100  *             RlcMode Param 
101  * @return void
102  * ****************************************************************/
103
104 void fillEntModeAndDir(uint8_t *entMode, uint8_t *direction, RlcMode rlcMode)
105 {
106    switch(rlcMode)
107    {
108       case RLC_AM:
109          *entMode   = RLC_MODE_AM;
110          *direction = RLC_CFG_DIR_BOTH;
111          break;
112       case RLC_UM_BI_DIRECTIONAL:
113          *entMode = RLC_MODE_UM;
114          *direction = RLC_CFG_DIR_BOTH;
115          break;
116       case RLC_UM_UNI_DIRECTIONAL_UL:
117          *entMode = RLC_MODE_UM;
118          *direction = RLC_CFG_DIR_UL;
119          break;
120       case RLC_UM_UNI_DIRECTIONAL_DL:
121          *entMode = RLC_MODE_UM;
122          *direction = RLC_CFG_DIR_DL;
123          break;
124       default : 
125          DU_LOG("\nERROR  -->  RLC: Rlc Mode invalid %d", rlcMode);
126     break;
127    }
128 }
129
130 /*******************************************************************
131  *
132  * @brief fills LC Cfgs to be Added in RLC
133  *
134  * @details
135  *
136  *    Function : fillLcCfg
137  *
138  *    Functionality:
139  *      fills LC Cfgs to be Added in RLC
140  *
141  * @params[in] 
142  *             RlcEntCfgInfo pointer
143  *             RlcBearerCfg pointer
144  *             Config Type 
145  * @return ROK -  SUCCESS
146  *         RFAILED - FAILURE
147  *
148  * ****************************************************************/
149 uint8_t fillLcCfg(RlcCb *gCb, RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg)
150 {
151    uint8_t lChRbIdx = 0;
152
153    rlcUeCfg->rbId                  = duRlcUeCfg->rbId;
154    rlcUeCfg->rbType                = duRlcUeCfg->rbType;   // SRB or DRB
155    rlcUeCfg->lCh[lChRbIdx].lChId   = duRlcUeCfg->lcId;   
156    rlcUeCfg->lCh[lChRbIdx].type    = duRlcUeCfg->lcType;
157    if(duRlcUeCfg->snssai)
158    {
159       RLC_ALLOC(gCb, rlcUeCfg->snssai, sizeof(Snssai));
160       if(rlcUeCfg->snssai == NULLP)
161       {
162          DU_LOG("\nERROR  --> RLC : fillLcCfg(): Failed to allocate memory for snssai");
163          return RFAILED;
164       }
165       memcpy(rlcUeCfg->snssai, duRlcUeCfg->snssai, sizeof(Snssai));
166    }
167    fillEntModeAndDir(&rlcUeCfg->entMode, &rlcUeCfg->dir, duRlcUeCfg->rlcMode);
168    rlcUeCfg->cfgType               = duRlcUeCfg->configType;
169    switch(rlcUeCfg->entMode)
170    {
171
172       case RLC_MODE_AM:
173          {
174             /* DL AM INFO */
175             rlcUeCfg->m.amInfo.dl.snLen       = duRlcUeCfg->u.amCfg->dlAmCfg.snLenDl; 
176             rlcUeCfg->m.amInfo.dl.pollRetxTmr = duRlcUeCfg->u.amCfg->dlAmCfg.pollRetxTmr;
177             rlcUeCfg->m.amInfo.dl.pollPdu     = duRlcUeCfg->u.amCfg->dlAmCfg.pollPdu; 
178             rlcUeCfg->m.amInfo.dl.pollByte    = duRlcUeCfg->u.amCfg->dlAmCfg.pollByte; 
179             rlcUeCfg->m.amInfo.dl.maxRetx     = duRlcUeCfg->u.amCfg->dlAmCfg.maxRetxTh;
180
181             /* UL AM INFO */
182             lChRbIdx++;   //lChRbIdx = 1, indicates UL AM
183             rlcUeCfg->lCh[lChRbIdx].lChId    = duRlcUeCfg->lcId;   
184             rlcUeCfg->lCh[lChRbIdx].type     = duRlcUeCfg->lcType;
185             rlcUeCfg->m.amInfo.ul.snLen      = duRlcUeCfg->u.amCfg->ulAmCfg.snLenUl; 
186             rlcUeCfg->m.amInfo.ul.staProhTmr = duRlcUeCfg->u.amCfg->ulAmCfg.statProhTmr;
187             rlcUeCfg->m.amInfo.ul.reAsmblTmr   = duRlcUeCfg->u.amCfg->ulAmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE;
188             break;
189          }
190       case RLC_MODE_UM:
191          {
192             /* UL UM CONFIG */
193             rlcUeCfg->m.umInfo.ul.snLen      = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm; 
194             rlcUeCfg->m.umInfo.ul.reAsmblTmr = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE;
195
196             /* DL UM CONFIG */
197             rlcUeCfg->m.umInfo.dl.snLen = duRlcUeCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm; 
198             break;
199          }
200       default:
201          break;
202    }/* End of switch(entMode) */
203    return ROK;
204 }
205
206 /*******************************************************************
207  *
208  * @brief fills LC Cfgs to be Added in RLC
209  *
210  * @details
211  *
212  *    Function : fillRlcCfg
213  *
214  *    Functionality:
215  *      fills LC Cfgs to be Add/Mod/Del in RLC
216  *
217  * @params[in] 
218  *             RlcEntCfgInfo pointer
219  *             RlcBearerCfg pointer
220  * @return ROK - Success
221  *          RFAILED - Failure
222  *
223  ******************************************************************/
224
225 uint8_t fillRlcCfg(RlcCb *gCb, RlcCfgInfo *rlcUeCfg, RlcUeCfg *ueCfg)
226 {
227    uint8_t lcIdx;
228    
229    rlcUeCfg->ueId    = ueCfg->ueIdx;
230    rlcUeCfg->cellId  = ueCfg->cellId;
231    rlcUeCfg->numEnt  = ueCfg->numLcs;
232    rlcUeCfg->transId = getTransId();
233
234    for(lcIdx = 0; lcIdx < rlcUeCfg->numEnt; lcIdx++)
235    {
236       if(fillLcCfg(gCb, &rlcUeCfg->entCfg[lcIdx], &ueCfg->rlcLcCfg[lcIdx]) != ROK)
237       {
238           DU_LOG("\nERROR  --> RLC : fillRlcCfg(): Failed to fill LC configuration");
239           return RFAILED;
240       }
241    }
242    return ROK;
243 }
244
245 /*******************************************************************
246  *
247  * @brief Fill RlcCfgCfmInfo structure for sending failure response to DU
248  *
249  * @details
250  *
251  *    Function : fillRlcCfgFailureRsp
252  *
253  *    Functionality:
254  *      Fill RlcCfgCfmInfo structure for sending failure response to DU
255  *
256  * @params[in] RlcCfgCfmInfo *cfgRsp, RlcUeCfg *ueCfg
257  *             
258  * @return void 
259  *
260  * ****************************************************************/
261 void fillRlcCfgFailureRsp(RlcCfgCfmInfo *cfgRsp, RlcUeCfg *ueCfg)
262 {
263    uint8_t cfgIdx =0;
264
265    cfgRsp->ueId = ueCfg->ueIdx;
266    cfgRsp->cellId = ueCfg->cellId;
267    cfgRsp->numEnt = ueCfg->numLcs;
268    for(cfgIdx =0; cfgIdx<ueCfg->numLcs; cfgIdx++)
269    {
270       cfgRsp->entCfgCfm[cfgIdx].rbId = ueCfg->rlcLcCfg[cfgIdx].rbId;
271       cfgRsp->entCfgCfm[cfgIdx].rbType = ueCfg->rlcLcCfg[cfgIdx].rbType;
272       cfgRsp->entCfgCfm[cfgIdx].status.status = RLC_DU_APP_RSP_NOK;
273       cfgRsp->entCfgCfm[cfgIdx].status.reason = CKW_CFG_REAS_NONE;
274    }
275 }
276 /*******************************************************************
277  *
278  * @brief Handles Ue Create Request from DU APP
279  *
280  * @details
281  *
282  *    Function : RlcProcUeCreateReq
283  *
284  *    Functionality:
285  *      Handles Ue create Request from DU APP
286  *
287  * @params[in] Post structure pointer
288  *             RlcUeCfg pointer 
289  * @return ROK     - success
290  *         RFAILED - failure
291  *
292  * ****************************************************************/
293 uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg)
294 {
295    uint8_t ret = ROK;
296    RlcCb *gCb;
297    RlcCfgInfo *rlcUeCfg = NULLP;
298    RlcCfgCfmInfo cfgRsp;
299    Pst rspPst;
300
301    gCb = RLC_GET_RLCCB(pst->dstInst);
302    RLC_ALLOC(gCb, rlcUeCfg, sizeof(RlcCfgInfo));
303    if(rlcUeCfg == NULLP)
304    {
305       DU_LOG("\nERROR  -->  RLC: Failed to allocate memory at RlcProcUeCreateReq()");
306       ret = RFAILED;
307    }
308    else
309    {
310       memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
311       ret = fillRlcCfg(gCb, rlcUeCfg, ueCfg); 
312       if(ret != ROK)
313       {
314          DU_LOG("\nERROR  -->  RLC: Failed to fill configuration at RlcProcUeCreateReq()");
315          FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_CREATE_RSP);
316          fillRlcCfgFailureRsp(&cfgRsp, ueCfg);
317          SendRlcUeCfgRspToDu(&rspPst, &cfgRsp);
318
319       }
320       else
321       {
322          ret = RlcProcCfgReq(pst, rlcUeCfg);
323          if(ret != ROK)
324             DU_LOG("\nERROR  -->  RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()");
325       }
326    }
327    RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
328    return ret;
329 }
330
331 /*******************************************************************
332 *
333 * @brief filling the structure of rrc delivery msg info
334 *
335 * @details
336 *
337 *    Function : BuildAndSendRrcDeliveryReportToDu
338 *
339 *    Functionality: filling the structure of rrc delivery msg info
340 *
341 * @return ROK     - success
342 *         RFAILED - failure
343 *
344 * ****************************************************************/
345 uint8_t BuildAndSendRrcDeliveryReportToDu( RlcDlRrcMsgInfo *dlRrcMsgInfo )
346 {
347     Pst             pst;
348     RrcDeliveryReport *rrcDelivery;
349
350     DU_LOG("\nINFO  -->  RLC : Filling RRC Delivery Report");
351     RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, rrcDelivery, sizeof(RrcDeliveryReport));
352
353     if(rrcDelivery)
354     {
355        rrcDelivery->cellId = dlRrcMsgInfo->cellId;
356        rrcDelivery->ueIdx  = dlRrcMsgInfo->ueIdx;
357        rrcDelivery->srbId  = dlRrcMsgInfo->lcId ;
358        rrcDelivery->rrcDeliveryStatus.deliveryStatus    = PDCP_SN;
359        rrcDelivery->rrcDeliveryStatus.triggeringMessage = PDCP_SN;
360
361        /* Sending UL RRC Message transfeer to DU APP */
362        memset(&pst, 0, sizeof(Pst));
363        FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RRC_DELIVERY_MSG_TRANS_TO_DU);
364        rlcSendRrcDeliveryReportToDu(&pst, rrcDelivery);
365     }
366     else
367     {
368        DU_LOG("\nERROR  -->  RLC : Memory allocation failed");
369     }
370
371    return ROK;
372 }
373 /* ****************************************************************
374  *
375  * @brief Process the DL RRC Message from DU APP
376  *
377  * @details
378  *
379  *    Function : RlcProcDlRrcMsgTransfer
380  *
381  *    Functionality: Process the DL RRC Message from DU APP
382  *
383  * @params[in] Post structure
384  *             DL RRC Message info
385  * @return ROK     - success
386  *         RFAILED - failure
387  *
388  * ****************************************************************/
389 uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo)
390 {
391    Buffer        *mBuf;
392    RlcDatReqInfo *datReqInfo;
393
394    RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
395    if(!datReqInfo)
396    {
397       DU_LOG("\nERROR  -->  RLC : Memory allocation failed in RlcProcDlRrcMsgTransfer");
398       RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
399       RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
400       return RFAILED;
401    }
402
403    datReqInfo->rlcId.rbType = dlRrcMsgInfo->rbType;
404    datReqInfo->rlcId.rbId = dlRrcMsgInfo->rbId;
405    datReqInfo->rlcId.ueId = dlRrcMsgInfo->ueIdx;
406    datReqInfo->rlcId.cellId = dlRrcMsgInfo->cellId;
407    datReqInfo->lcType = dlRrcMsgInfo->lcType;
408    datReqInfo->sduId = ++(rlcCb[pst->dstInst]->dlSduId);
409
410    /* Copy fixed buffer to message */
411    if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &mBuf) != ROK)
412    {
413       DU_LOG("\nERROR  -->  RLC : Memory allocation failed at RlcMacProcUlData");
414       RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
415       RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
416       RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
417       return RFAILED;
418    }
419    oduCpyFixBufToMsg(dlRrcMsgInfo->rrcMsg, mBuf, dlRrcMsgInfo->msgLen);
420
421    if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK)
422    {
423       return RFAILED;
424    }
425
426    /* RRC Delivery report is only send when RRC Delivery status report is true in DL RRC Message */
427    if(dlRrcMsgInfo->deliveryStaRpt)
428    {
429       BuildAndSendRrcDeliveryReportToDu(dlRrcMsgInfo);
430    }
431
432    /* Free memory allocated by du app */
433    RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
434    RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
435    RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
436    return ROK;
437 }
438
439 /*******************************************************************
440  *
441  * @brief Process UL data from UE
442  *
443  * @details
444  *
445  *    Function : RlcProcUlData
446  *
447  *    Functionality:
448  *       This function receives the PDU from MAC.
449  *       seggregates common and dedicated logical channel
450  *       PDU and call respective handler.
451  *
452  * @params[in]
453  * @return ROK     - success
454  *         RFAILED - failure
455  *
456  * ****************************************************************/
457 uint8_t RlcProcUlData(Pst *pst, RlcData *ulData)
458 {
459    uint8_t         ret = ROK;
460    uint8_t         idx, pduIdx;
461    uint8_t         lcId;                    /* Logical Channel */
462    uint8_t         numDLch = 0;             /* Number of dedicated logical channel */
463    bool            dLchPduPres;             /* PDU received on dedicated logical channel */
464    RguLchDatInd    dLchData[MAX_NUM_LC];    /* PDU info on dedicated logical channel */
465    RguDDatIndInfo  *dLchUlDat;              /* UL data on dedicated logical channel */
466    RguCDatIndInfo  *cLchUlDat;              /* UL data on common logical channel */
467
468    /* Initializing dedicated logical channel Database */
469    DU_LOG("\nDEBUG  -->  RLC: Received UL Data request from MAC");
470    for(idx = 0; idx < MAX_NUM_LC; idx++)
471    {
472       dLchData[idx].lcId = idx;
473       dLchData[idx].pdu.numPdu = 0;
474    }
475    dLchPduPres = FALSE;
476
477    /* Seggregate PDUs received on common and dedicated channels
478     * and call common channel's handler */
479    for(idx = 0; idx< ulData->numPdu; idx++)
480    {
481       if(ulData->pduInfo[idx].commCh)
482       {
483          RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \
484                sizeof(RguCDatIndInfo));
485          if(!cLchUlDat)
486          {
487             DU_LOG("\nERROR  -->  RLC : Memory allocation failed at RlcProcUlData");
488             ret = RFAILED;
489             break;
490          }
491          memset(cLchUlDat, 0, sizeof(RguCDatIndInfo));
492
493          cLchUlDat->cellId = ulData->cellId;
494          GET_UE_IDX(ulData->rnti, cLchUlDat->rnti);
495          cLchUlDat->lcId   = ulData->pduInfo[idx].lcId;
496
497          /* Copy fixed buffer to message */
498          if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &cLchUlDat->pdu) != ROK)
499          {
500             DU_LOG("\nERROR  -->  RLC : Memory allocation failed at RlcProcUlData");
501             RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \
502                   sizeof(RguCDatIndInfo));
503             ret = RFAILED;
504             break;
505          }
506          oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, \
507                ulData->pduInfo[idx].pduLen);
508
509          rlcProcCommLcUlData(pst, 0, cLchUlDat);
510       }
511       else
512       {
513          if(!dLchPduPres)
514          {
515             RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \
516                   sizeof(RguDDatIndInfo));
517             if(!dLchUlDat)
518             {
519                DU_LOG("\nERROR  -->  RLC : Memory allocation failed at RlcMacProcUlData");
520                ret = RFAILED;
521                break;
522             }
523             dLchPduPres = TRUE;
524          }
525
526          /* Copy fixed buffer to message */
527          lcId = ulData->pduInfo[idx].lcId;
528          if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \
529                   &dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK)
530          {
531             DU_LOG("\nERROR  -->  RLC : Memory allocation failed at RlcMacProcUlData");
532             for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++)
533             {
534                ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]);
535             }
536             RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \
537                   sizeof(RguDDatIndInfo));
538             ret = RFAILED;
539             break;
540          }
541          oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, \
542                dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu],\
543                ulData->pduInfo[idx].pduLen);
544
545          dLchData[lcId].pdu.numPdu++;
546       }
547    }
548
549    /* If any PDU received on dedicated logical channel, copy into RguDDatIndInfo
550     * and call its handler */
551    if(ret == ROK)
552    {
553       if(dLchPduPres)
554       {
555          dLchUlDat->cellId = ulData->cellId;
556          GET_UE_IDX(ulData->rnti, dLchUlDat->rnti);
557
558          for(idx = 0; idx < MAX_NUM_LC; idx++)
559          {
560             if(dLchData[idx].pdu.numPdu)
561             {
562                memcpy(&dLchUlDat->lchData[numDLch], &dLchData[idx], sizeof(RguLchDatInd));
563                numDLch++;
564             }
565          }
566          dLchUlDat->numLch = numDLch;
567          rlcProcDedLcUlData(pst, 0, dLchUlDat);
568       }
569    }
570
571    for(pduIdx = 0; pduIdx < ulData->numPdu; pduIdx++)
572    {
573       RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData->pduInfo[pduIdx].pduBuf, \
574             ulData->pduInfo[pduIdx].pduLen);
575    }
576    RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcData));
577    return ROK;
578
579 }/* End of RlcProcUlData */
580
581 /*******************************************************************
582  *
583  * @brief Handler for extracting common and dedicated channel
584  *      Scheduling result report.
585  *
586  * @details
587  *
588  *    Function : RlcProcSchedResultRpt
589  *
590  *    Functionality:
591  *     Handler for extracting common and dedicated channel
592  *      Scheduling result report
593  *
594  * @params[in]
595  * @return ROK     - success
596  *         RFAILED - failure
597  *
598  * ****************************************************************/
599 uint8_t RlcProcSchedResultRpt(Pst *pst, RlcSchedResultRpt *schRep)
600 {
601    uint8_t ret = ROK;
602    uint8_t idx;                     /* Iterator */
603    uint8_t nmbDLch = 0;                 /* Number of dedicated logical channles */
604    RguCStaIndInfo   *cLchSchInfo;    /* Common logical channel scheduling result */
605    RguDStaIndInfo   *dLchSchInfo;  /* Dedicated logical channel scheduling result */
606
607    DU_LOG("\nDEBUG  -->  RLC : Received scheduling report from MAC");
608    for(idx=0; idx < schRep->numLc; idx++)
609    {
610       /* If it is common channel, fill status indication information
611        * and trigger the handler for each common lch separately */
612       if(schRep->lcSch[idx].commCh)
613       {
614           RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, cLchSchInfo, \
615              sizeof(RguCStaIndInfo));
616           if(!cLchSchInfo)
617           {
618              DU_LOG("\nERROR  -->  RLC: RlcProcSchedResultRpt: Memory allocation failed for cLchSchInfo");
619              ret = RFAILED;
620              break;
621           }
622           memset(cLchSchInfo, 0, sizeof(RguCStaIndInfo));
623
624           cLchSchInfo->cellId  = schRep->cellId;
625           cLchSchInfo->lcId    = schRep->lcSch[idx].lcId;
626           cLchSchInfo->transId = schRep->slotInfo.sfn;
627           cLchSchInfo->transId = (cLchSchInfo->transId << 16) | schRep->slotInfo.slot;
628           cLchSchInfo->rnti = schRep->rnti;
629           rlcProcCommLcSchedRpt(pst, 0, cLchSchInfo);
630
631       }
632       else
633       {
634           /* Fill status info structure if at least one dedicated channel
635            * scheduling report is received */
636           if(nmbDLch == 0)
637           {
638              RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, dLchSchInfo, \
639                 sizeof(RguDStaIndInfo));
640              if(!dLchSchInfo)
641              {
642                 DU_LOG("\nERROR  -->  RLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo");
643                 ret = RFAILED;
644                 break;
645              }
646
647              dLchSchInfo->cellId = schRep->cellId;
648              dLchSchInfo->nmbOfUeGrantPerTti = 1;
649              /* MAC sends Scheduling report for one UE at a time. Hence filling
650              only the 0th index of staInd */
651              dLchSchInfo->staInd[0].rnti = schRep->rnti;
652
653              /* Storing sfn/slot into a single 32-bit variable to be used later*/
654              dLchSchInfo->staInd[0].transId = schRep->slotInfo.sfn;
655              dLchSchInfo->staInd[0].transId = \
656                 (dLchSchInfo->staInd[0].transId << 16) | schRep->slotInfo.slot; 
657              dLchSchInfo->staInd[0].nmbOfTbs = 1;
658              dLchSchInfo->staInd[0].fillCtrlPdu = true; 
659           }
660
661           /* Fill logical channel scheduling info */
662           dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].lcId = \
663              schRep->lcSch[idx].lcId;
664           dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].totBufSize = \
665              schRep->lcSch[idx].bufSize;
666           nmbDLch++;
667       }
668    }
669
670    /* Calling handler for all dedicated channels scheduling*/
671    if(ret == ROK)
672    {
673       if(nmbDLch)
674       {
675          dLchSchInfo->staInd[0].staIndTb[0].nmbLch = nmbDLch;
676          rlcProcDedLcSchedRpt(pst, 0, dLchSchInfo);
677       }
678    }
679
680    RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcSchedResultRpt));
681    return ret;
682 }
683
684
685 /*******************************************************************
686  *
687  * @brief Handles Ue Reconfig Request from DU APP
688  *
689  * @details
690  *
691  *    Function : RlcProcUeReconfigReq
692  *
693  *    Functionality:
694  *      Handles Ue Reconfig Request from DU APP
695  *
696  * @params[in] Post structure pointer
697  *             RlcUeCfg pointer 
698  * @return ROK     - success
699  *         RFAILED - failure
700  *
701  * ****************************************************************/
702 uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg)
703 {
704    uint8_t ret = ROK;
705    RlcCfgInfo *rlcUeCfg = NULLP; //Seed code Rlc cfg struct
706    RlcCb *rlcUeCb = NULLP;
707    RlcCfgCfmInfo *cfgRsp; 
708    Pst rspPst;
709
710    DU_LOG("\nDEBUG  -->  RLC: UE reconfig request received. CellID[%d] UEIDX[%d]",ueCfg->cellId, ueCfg->ueIdx);
711
712    rlcUeCb = RLC_GET_RLCCB(pst->dstInst);
713    RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
714    if(rlcUeCfg == NULLP)
715    {
716       DU_LOG("\nERROR  -->  RLC: Failed to allocate memory at RlcProcUeReconfigReq()");
717       ret = RFAILED;
718    }
719    else
720    {
721       memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
722       ret = fillRlcCfg(rlcUeCb, rlcUeCfg, ueCfg);
723       if(ret != ROK)
724       {
725          DU_LOG("\nERROR  -->  RLC: Failed to fill configuration at RlcProcUeReconfigReq()");
726          FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_RSP);
727          memset(cfgRsp, 0, sizeof(RlcCfgCfmInfo));
728          fillRlcCfgFailureRsp(cfgRsp, ueCfg);
729          SendRlcUeCfgRspToDu(&rspPst, cfgRsp);
730       }
731       else
732       {
733          ret = RlcProcCfgReq(pst, rlcUeCfg);
734          if(ret != ROK)
735             DU_LOG("\nERROR  -->  RLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()");
736       }
737    }
738    
739    RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
740    return ret;
741 }
742
743 /* ****************************************************************
744  *
745  * @brief Process the DL Data transfer from DU APP
746  *
747  * @details
748  *
749  *    Function : RlcProcDlUserDataTransfer
750  *
751  *    Functionality: Process the DL transfer from DU APP
752  *
753  * @params[in] Post structure
754  *             DL RRC Message info
755  * @return ROK     - success
756  *         RFAILED - failure
757  *
758  * ****************************************************************/
759 uint8_t RlcProcDlUserDataTransfer(Pst *pst, RlcDlUserDataInfo *dlDataMsgInfo)
760 {
761    Buffer        *mBuf = NULLP;
762    RlcDatReqInfo *datReqInfo = NULLP;
763
764    if(dlDataMsgInfo->dlMsg == NULLP)
765    {
766       DU_LOG("\nERROR  -->  RLC_DL : Received DL message is NULLP in RlcProcDlUserDataTransfer()");
767       return RFAILED;
768    }
769    RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
770    if(!datReqInfo)
771    {
772       DU_LOG("\nERROR  -->  RLC_DL : Memory allocation failed for DatReq in RlcProcDlUserDataTransfer()");
773       ODU_PUT_MSG_BUF(dlDataMsgInfo->dlMsg);
774       RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
775       return RFAILED;
776    }
777
778    datReqInfo->rlcId.rbType = RB_TYPE_DRB;
779    datReqInfo->rlcId.rbId   = dlDataMsgInfo->rbId;
780    datReqInfo->rlcId.ueId   = dlDataMsgInfo->ueIdx;
781    datReqInfo->rlcId.cellId = dlDataMsgInfo->cellId;
782    datReqInfo->lcType       = LCH_DTCH;
783    datReqInfo->sduId        = ++(rlcCb[pst->dstInst]->dlSduId);
784    mBuf = dlDataMsgInfo->dlMsg;
785    if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK)
786    {
787       return RFAILED;
788    }
789     
790    /* Free memory allocated by du app */
791    RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
792    RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
793    return ROK;
794 }
795
796 /*******************************************************************
797  *
798  * @brief sending UE delete response to DU 
799  *
800  * @details
801  *
802  *    Function : sendRlcUeDeleteRspToDu 
803  *
804  *    Functionality:
805  *      sending UE delete response to DU 
806  *
807  * @params[in] uint8_t cellId, uint8_t ueIdx, UeDeleteResult result 
808  *
809  * @return ROK     - success
810  *         RFAILED - failure
811  *
812  * ****************************************************************/
813 uint8_t sendRlcUeDeleteRspToDu(uint16_t cellId,uint8_t ueId, UeDeleteResult result)
814 {
815    Pst pst;  
816    RlcUeDeleteRsp *ueDeleteRsp = NULLP;
817    
818    FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RLC_UE_DELETE_RSP);
819
820    RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp));
821    if(!ueDeleteRsp)
822    {
823       DU_LOG("\nERROR  -->  RLC: sendRlcUeDeleteRspToDu(): Memory allocation failed ");
824       return RFAILED;
825    }
826    else
827    {
828       ueDeleteRsp->cellId = cellId;
829       ueDeleteRsp->ueId = ueId;
830       ueDeleteRsp->result = result;
831   
832       if(rlcSendUeDeleteRspToDu(&pst, ueDeleteRsp) == ROK)
833       {
834          DU_LOG("\nDEBUG  -->  RLC: UE Delete response send successfully");
835       }
836       else
837       {
838          DU_LOG("\nERROR  -->  RLC: SendRlcUeDeleteRspToDu():Failed to send UE Delete response to DU");
839          RLC_FREE_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp));
840          return RFAILED;
841       }
842    }
843    return ROK;
844 }
845
846 /*******************************************************************
847 *
848 * @brief Handles Ue delete Request from DU APP
849 *
850 * @details
851 *
852 *    Function : RlcProcUeDeleteReq
853 *
854 *    Functionality:
855 *      Handles Ue delete Request from DU APP
856 *
857 * @params[in] Post structure pointer
858 *             RlcUeDelete pointer
859 * @return ROK     - success
860 *         RFAILED - failure
861 *
862 * ****************************************************************/
863
864 uint8_t RlcProcUeDeleteReq(Pst *pst, RlcUeDelete *ueDelete)
865 {
866    uint8_t ret = ROK;
867    RlcCb *gRlcCb = NULLP;
868    RlcUlUeCb *ueCb = NULLP;
869    UeDeleteResult result=SUCCESSFUL;
870
871    DU_LOG("\nDEBUG  -->  RLC: UE Delete request received. CellID[%d] UEID[%d]",ueDelete->cellId, ueDelete->ueId);
872
873    if(ueDelete != NULLP)
874    {
875       gRlcCb = RLC_GET_RLCCB(pst->dstInst);
876       rlcDbmFetchUlUeCb(gRlcCb,ueDelete->ueId, ueDelete->cellId, &ueCb);
877       if(ueCb != NULLP)
878       {
879          if(ueDelete->cellId == ueCb->cellId)
880          {
881             memcpy(&ueCb->ueDeleteInfo.pst, pst, sizeof(Pst));
882             if((rlcChkTmr(gRlcCb, (PTR)ueCb, EVENT_RLC_UE_DELETE_TMR)) == FALSE)
883             {
884                rlcStartTmr(gRlcCb,(PTR)ueCb, EVENT_RLC_UE_DELETE_TMR);
885             }
886          }
887          else
888          {
889             result = INVALID_CELLID;
890          }
891       }
892       else
893       {
894          result = INVALID_UEID;
895       }
896
897       if(result != SUCCESSFUL)
898       {
899          ret = sendRlcUeDeleteRspToDu(ueDelete->cellId, ueDelete->ueId, result);
900          if(ret != ROK)
901          {
902             DU_LOG("\nERROR  -->  RLC: RlcProcUeDeleteReq():Failed to send UE Delete response to DU");
903          }
904       }
905       RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(RlcUeDelete));
906    }
907    else
908    {
909       DU_LOG("\nERROR  -->  RLC: RlcProcUeDeleteReq(): Recieved NULL pointer UE Delete ");
910       ret = RFAILED;
911    }
912    return ret;
913 }
914
915 /**********************************************************************
916          End of file
917 **********************************************************************/