1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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 *******************************************************************************/
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 */
29 /* header/extern include files (.x) */
31 #include "lkw.x" /* LKW */
32 #include "ckw.x" /* CKW */
33 #include "kwu.x" /* KWU */
35 #include "rlc_utils.h" /* RLC defines */
36 #include "rlc_dl_ul_inf.h"
39 #include "rlc_mac_inf.h"
40 #include "du_app_rlc_inf.h"
41 #include "rlc_upr_inf_api.h"
43 /*******************************************************************
45 * @brief Fills RLC UL UE Cfg Rsp from RlcCRsp
49 * Function : fillRlcUeCfgRsp
52 * Fills RLC UL UE Cfg Rsp from RlcCRsp
54 * @params[in] Pointer to RlcCfgCfm
55 * Pointer to RlcUeCfgRsp
59 *****************************************************************/
61 uint8_t fillRlcUeCfgRsp(RlcUeCfgRsp *rlcCfgRsp, RlcCfgCfmInfo *rlcCRsp)
66 rlcCfgRsp->cellId = rlcCRsp->cellId;
67 rlcCfgRsp->ueIdx = rlcCRsp->ueId;
68 for(idx = 0; idx < rlcCRsp->numEnt; idx++)
70 if(rlcCRsp->entCfgCfm[idx].status.status == CKW_CFG_CFM_OK)
72 rlcCfgRsp->result = RLC_DU_APP_RSP_OK;
73 rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason;
78 rlcCfgRsp->result = RLC_DU_APP_RSP_NOK;
79 rlcCfgRsp->reason = rlcCRsp->entCfgCfm[idx].status.reason;
87 /*******************************************************************
89 * @brief Fills the entity mode and direction compiling to seed code
93 * Function : fillEntModeAndDir
96 * Fills the entity mode and direction compiling to seed code
98 * @params[in] Pointer to entMode
99 * Pointer to direction
102 * ****************************************************************/
104 void fillEntModeAndDir(uint8_t *entMode, uint8_t *direction, RlcMode rlcMode)
109 *entMode = RLC_MODE_AM;
110 *direction = RLC_CFG_DIR_BOTH;
112 case RLC_UM_BI_DIRECTIONAL:
113 *entMode = RLC_MODE_UM;
114 *direction = RLC_CFG_DIR_BOTH;
116 case RLC_UM_UNI_DIRECTIONAL_UL:
117 *entMode = RLC_MODE_UM;
118 *direction = RLC_CFG_DIR_UL;
120 case RLC_UM_UNI_DIRECTIONAL_DL:
121 *entMode = RLC_MODE_UM;
122 *direction = RLC_CFG_DIR_DL;
125 DU_LOG("\nERROR --> RLC: Rlc Mode invalid %d", rlcMode);
130 /*******************************************************************
132 * @brief fills LC Cfgs to be Added in RLC
136 * Function : fillLcCfg
139 * fills LC Cfgs to be Added in RLC
142 * RlcEntCfgInfo pointer
143 * RlcBearerCfg pointer
147 * ****************************************************************/
148 void fillLcCfg(RlcEntCfgInfo *rlcUeCfg, RlcBearerCfg *duRlcUeCfg, uint8_t cfgType)
150 uint8_t lChRbIdx = 0;
152 rlcUeCfg->rbId = duRlcUeCfg->rbId;
153 rlcUeCfg->rbType = duRlcUeCfg->rbType; // SRB or DRB
154 rlcUeCfg->lCh[lChRbIdx].lChId = duRlcUeCfg->lcId;
155 rlcUeCfg->lCh[lChRbIdx].type = duRlcUeCfg->lcType;
156 fillEntModeAndDir(&rlcUeCfg->entMode, &rlcUeCfg->dir, duRlcUeCfg->rlcMode);
157 rlcUeCfg->cfgType = cfgType;
158 switch(rlcUeCfg->entMode)
164 rlcUeCfg->m.amInfo.dl.snLen = duRlcUeCfg->u.amCfg->dlAmCfg.snLenDl;
165 rlcUeCfg->m.amInfo.dl.pollRetxTmr = duRlcUeCfg->u.amCfg->dlAmCfg.pollRetxTmr;
166 rlcUeCfg->m.amInfo.dl.pollPdu = duRlcUeCfg->u.amCfg->dlAmCfg.pollPdu;
167 rlcUeCfg->m.amInfo.dl.pollByte = duRlcUeCfg->u.amCfg->dlAmCfg.pollByte;
168 rlcUeCfg->m.amInfo.dl.maxRetx = duRlcUeCfg->u.amCfg->dlAmCfg.maxRetxTh;
171 lChRbIdx++; //lChRbIdx = 1, indicates UL AM
172 rlcUeCfg->lCh[lChRbIdx].lChId = duRlcUeCfg->lcId;
173 rlcUeCfg->lCh[lChRbIdx].type = duRlcUeCfg->lcType;
174 rlcUeCfg->m.amInfo.ul.snLen = duRlcUeCfg->u.amCfg->ulAmCfg.snLenUl;
175 rlcUeCfg->m.amInfo.ul.staProhTmr = duRlcUeCfg->u.amCfg->ulAmCfg.statProhTmr;
176 rlcUeCfg->m.amInfo.ul.reAsmblTmr = duRlcUeCfg->u.amCfg->ulAmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE;
182 rlcUeCfg->m.umInfo.ul.snLen = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
183 rlcUeCfg->m.umInfo.ul.reAsmblTmr = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE;
186 rlcUeCfg->m.umInfo.dl.snLen = duRlcUeCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm;
191 }/* End of switch(entMode) */
194 /*******************************************************************
196 * @brief fills LC Cfgs to be Added in RLC
200 * Function : fillRlcCfg
203 * fills LC Cfgs to be Add/Mod/Del in RLC
206 * RlcEntCfgInfo pointer
207 * RlcBearerCfg pointer
210 ******************************************************************/
212 void fillRlcCfg(RlcCfgInfo *rlcUeCfg, RlcUeCfg *ueCfg)
216 rlcUeCfg->ueId = ueCfg->ueIdx;
217 rlcUeCfg->cellId = ueCfg->cellId;
218 rlcUeCfg->numEnt = ueCfg->numLcs;
219 rlcUeCfg->transId = getTransId();
221 for(lcIdx = 0; lcIdx < rlcUeCfg->numEnt; lcIdx++)
223 fillLcCfg(&rlcUeCfg->entCfg[lcIdx], &ueCfg->rlcLcCfg[lcIdx], ueCfg->rlcLcCfg[lcIdx].configType);
227 /*******************************************************************
229 * @brief Handles Ue Create Request from DU APP
233 * Function : RlcProcUeCreateReq
236 * Handles Ue create Request from DU APP
238 * @params[in] Post structure pointer
240 * @return ROK - success
243 * ****************************************************************/
244 uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg)
247 RlcCfgInfo *rlcUeCfg = NULLP;
250 gCb = RLC_GET_RLCCB(pst->dstInst);
251 RLC_ALLOC(gCb, rlcUeCfg, sizeof(RlcCfgInfo));
252 if(rlcUeCfg == NULLP)
254 DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeCreateReq()");
259 memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
260 fillRlcCfg(rlcUeCfg, ueCfg);
261 ret = RlcProcCfgReq(pst, rlcUeCfg);
263 DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()");
266 RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
270 /*******************************************************************
272 * @brief filling the structure of rrc delivery msg info
276 * Function : BuildAndSendRrcDeliveryReportToDu
278 * Functionality: filling the structure of rrc delivery msg info
280 * @return ROK - success
283 * ****************************************************************/
284 uint8_t BuildAndSendRrcDeliveryReportToDu( RlcDlRrcMsgInfo *dlRrcMsgInfo )
287 RrcDeliveryReport *rrcDelivery;
289 DU_LOG("\nINFO --> RLC : Filling RRC Delivery Report");
290 RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, rrcDelivery, sizeof(RrcDeliveryReport));
294 rrcDelivery->cellId = dlRrcMsgInfo->cellId;
295 rrcDelivery->ueIdx = dlRrcMsgInfo->ueIdx;
296 rrcDelivery->srbId = dlRrcMsgInfo->lcId ;
297 rrcDelivery->rrcDeliveryStatus.deliveryStatus = PDCP_SN;
298 rrcDelivery->rrcDeliveryStatus.triggeringMessage = PDCP_SN;
300 /* Sending UL RRC Message transfeer to DU APP */
301 memset(&pst, 0, sizeof(Pst));
302 FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RRC_DELIVERY_MSG_TRANS_TO_DU);
303 rlcSendRrcDeliveryReportToDu(&pst, rrcDelivery);
307 DU_LOG("\nERROR --> RLC : Memory allocation failed");
312 /* ****************************************************************
314 * @brief Process the DL RRC Message from DU APP
318 * Function : RlcProcDlRrcMsgTransfer
320 * Functionality: Process the DL RRC Message from DU APP
322 * @params[in] Post structure
323 * DL RRC Message info
324 * @return ROK - success
327 * ****************************************************************/
328 uint8_t RlcProcDlRrcMsgTransfer(Pst *pst, RlcDlRrcMsgInfo *dlRrcMsgInfo)
331 RlcDatReqInfo *datReqInfo;
333 RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
336 DU_LOG("\nERROR --> RLC : Memory allocation failed in RlcProcDlRrcMsgTransfer");
337 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
338 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
342 datReqInfo->rlcId.rbType = dlRrcMsgInfo->rbType;
343 datReqInfo->rlcId.rbId = dlRrcMsgInfo->rbId;
344 datReqInfo->rlcId.ueId = dlRrcMsgInfo->ueIdx;
345 datReqInfo->rlcId.cellId = dlRrcMsgInfo->cellId;
346 datReqInfo->lcType = dlRrcMsgInfo->lcType;
347 datReqInfo->sduId = ++(rlcCb[pst->dstInst]->dlSduId);
349 /* Copy fixed buffer to message */
350 if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &mBuf) != ROK)
352 DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
353 RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
354 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
355 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
358 oduCpyFixBufToMsg(dlRrcMsgInfo->rrcMsg, mBuf, dlRrcMsgInfo->msgLen);
360 if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK)
365 /* RRC Delivery report is only send when RRC Delivery status report is true in DL RRC Message */
366 if(dlRrcMsgInfo->deliveryStaRpt)
368 BuildAndSendRrcDeliveryReportToDu(dlRrcMsgInfo);
371 /* Free memory allocated by du app */
372 RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
373 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
374 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
378 /*******************************************************************
380 * @brief Process UL data from UE
384 * Function : RlcProcUlData
387 * This function receives the PDU from MAC.
388 * seggregates common and dedicated logical channel
389 * PDU and call respective handler.
392 * @return ROK - success
395 * ****************************************************************/
396 uint8_t RlcProcUlData(Pst *pst, RlcData *ulData)
400 uint8_t lcId; /* Logical Channel */
401 uint8_t numDLch = 0; /* Number of dedicated logical channel */
402 bool dLchPduPres; /* PDU received on dedicated logical channel */
403 RguLchDatInd dLchData[MAX_NUM_LC]; /* PDU info on dedicated logical channel */
404 RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */
405 RguCDatIndInfo *cLchUlDat; /* UL data on common logical channel */
407 /* Initializing dedicated logical channel Database */
408 DU_LOG("\nDEBUG --> RLC: Received UL Data request from MAC");
409 for(idx = 0; idx < MAX_NUM_LC; idx++)
411 dLchData[idx].lcId = idx;
412 dLchData[idx].pdu.numPdu = 0;
416 /* Seggregate PDUs received on common and dedicated channels
417 * and call common channel's handler */
418 for(idx = 0; idx< ulData->numPdu; idx++)
420 if(ulData->pduInfo[idx].commCh)
422 RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \
423 sizeof(RguCDatIndInfo));
426 DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData");
430 memset(cLchUlDat, 0, sizeof(RguCDatIndInfo));
432 cLchUlDat->cellId = ulData->cellId;
433 GET_UE_IDX(ulData->rnti, cLchUlDat->rnti);
434 cLchUlDat->lcId = ulData->pduInfo[idx].lcId;
436 /* Copy fixed buffer to message */
437 if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &cLchUlDat->pdu) != ROK)
439 DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData");
440 RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \
441 sizeof(RguCDatIndInfo));
445 oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, \
446 ulData->pduInfo[idx].pduLen);
448 rlcProcCommLcUlData(pst, 0, cLchUlDat);
454 RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \
455 sizeof(RguDDatIndInfo));
458 DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
465 /* Copy fixed buffer to message */
466 lcId = ulData->pduInfo[idx].lcId;
467 if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \
468 &dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK)
470 DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
471 for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++)
473 ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]);
475 RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \
476 sizeof(RguDDatIndInfo));
480 oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, \
481 dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu],\
482 ulData->pduInfo[idx].pduLen);
484 dLchData[lcId].pdu.numPdu++;
488 /* If any PDU received on dedicated logical channel, copy into RguDDatIndInfo
489 * and call its handler */
494 dLchUlDat->cellId = ulData->cellId;
495 GET_UE_IDX(ulData->rnti, dLchUlDat->rnti);
497 for(idx = 0; idx < MAX_NUM_LC; idx++)
499 if(dLchData[idx].pdu.numPdu)
501 memcpy(&dLchUlDat->lchData[numDLch], &dLchData[idx], sizeof(RguLchDatInd));
505 dLchUlDat->numLch = numDLch;
506 rlcProcDedLcUlData(pst, 0, dLchUlDat);
510 for(pduIdx = 0; pduIdx < ulData->numPdu; pduIdx++)
512 RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData->pduInfo[pduIdx].pduBuf, \
513 ulData->pduInfo[pduIdx].pduLen);
515 RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcData));
518 }/* End of RlcProcUlData */
520 /*******************************************************************
522 * @brief Handler for extracting common and dedicated channel
523 * Scheduling result report.
527 * Function : RlcProcSchedResultRpt
530 * Handler for extracting common and dedicated channel
531 * Scheduling result report
534 * @return ROK - success
537 * ****************************************************************/
538 uint8_t RlcProcSchedResultRpt(Pst *pst, RlcSchedResultRpt *schRep)
541 uint8_t idx; /* Iterator */
542 uint8_t nmbDLch = 0; /* Number of dedicated logical channles */
543 RguCStaIndInfo *cLchSchInfo; /* Common logical channel scheduling result */
544 RguDStaIndInfo *dLchSchInfo; /* Dedicated logical channel scheduling result */
546 DU_LOG("\nDEBUG --> RLC : Received scheduling report from MAC");
547 for(idx=0; idx < schRep->numLc; idx++)
549 /* If it is common channel, fill status indication information
550 * and trigger the handler for each common lch separately */
551 if(schRep->lcSch[idx].commCh)
553 RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, cLchSchInfo, \
554 sizeof(RguCStaIndInfo));
557 DU_LOG("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for cLchSchInfo");
561 memset(cLchSchInfo, 0, sizeof(RguCStaIndInfo));
563 cLchSchInfo->cellId = schRep->cellId;
564 cLchSchInfo->lcId = schRep->lcSch[idx].lcId;
565 cLchSchInfo->transId = schRep->slotInfo.sfn;
566 cLchSchInfo->transId = (cLchSchInfo->transId << 16) | schRep->slotInfo.slot;
567 cLchSchInfo->rnti = schRep->rnti;
568 rlcProcCommLcSchedRpt(pst, 0, cLchSchInfo);
573 /* Fill status info structure if at least one dedicated channel
574 * scheduling report is received */
577 RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, dLchSchInfo, \
578 sizeof(RguDStaIndInfo));
581 DU_LOG("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo");
586 dLchSchInfo->cellId = schRep->cellId;
587 dLchSchInfo->nmbOfUeGrantPerTti = 1;
588 /* MAC sends Scheduling report for one UE at a time. Hence filling
589 only the 0th index of staInd */
590 dLchSchInfo->staInd[0].rnti = schRep->rnti;
592 /* Storing sfn/slot into a single 32-bit variable to be used later*/
593 dLchSchInfo->staInd[0].transId = schRep->slotInfo.sfn;
594 dLchSchInfo->staInd[0].transId = \
595 (dLchSchInfo->staInd[0].transId << 16) | schRep->slotInfo.slot;
596 dLchSchInfo->staInd[0].nmbOfTbs = 1;
597 dLchSchInfo->staInd[0].fillCtrlPdu = true;
600 /* Fill logical channel scheduling info */
601 dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].lcId = \
602 schRep->lcSch[idx].lcId;
603 dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch].totBufSize = \
604 schRep->lcSch[idx].bufSize;
609 /* Calling handler for all dedicated channels scheduling*/
614 dLchSchInfo->staInd[0].staIndTb[0].nmbLch = nmbDLch;
615 rlcProcDedLcSchedRpt(pst, 0, dLchSchInfo);
619 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcSchedResultRpt));
624 /*******************************************************************
626 * @brief Handles Ue Reconfig Request from DU APP
630 * Function : RlcProcUeReconfigReq
633 * Handles Ue Reconfig Request from DU APP
635 * @params[in] Post structure pointer
637 * @return ROK - success
640 * ****************************************************************/
641 uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg)
644 RlcCfgInfo *rlcUeCfg = NULLP; //Seed code Rlc cfg struct
645 RlcCb *rlcUeCb = NULLP;
647 DU_LOG("\nDEBUG --> RLC: UE reconfig request received. CellID[%d] UEIDX[%d]",ueCfg->cellId, ueCfg->ueIdx);
649 rlcUeCb = RLC_GET_RLCCB(pst->dstInst);
650 RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
651 if(rlcUeCfg == NULLP)
653 DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeReconfigReq()");
658 memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
659 fillRlcCfg(rlcUeCfg, ueCfg);
660 ret = RlcProcCfgReq(pst, rlcUeCfg);
662 DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()");
665 RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
669 /* ****************************************************************
671 * @brief Process the DL Data transfer from DU APP
675 * Function : RlcProcDlUserDataTransfer
677 * Functionality: Process the DL transfer from DU APP
679 * @params[in] Post structure
680 * DL RRC Message info
681 * @return ROK - success
684 * ****************************************************************/
685 uint8_t RlcProcDlUserDataTransfer(Pst *pst, RlcDlUserDataInfo *dlDataMsgInfo)
687 Buffer *mBuf = NULLP;
688 RlcDatReqInfo *datReqInfo = NULLP;
690 if(dlDataMsgInfo->dlMsg == NULLP)
692 DU_LOG("\nERROR --> RLC_DL : Received DL message is NULLP in RlcProcDlUserDataTransfer()");
695 RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
698 DU_LOG("\nERROR --> RLC_DL : Memory allocation failed for DatReq in RlcProcDlUserDataTransfer()");
699 ODU_PUT_MSG_BUF(dlDataMsgInfo->dlMsg);
700 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
704 datReqInfo->rlcId.rbType = RB_TYPE_DRB;
705 datReqInfo->rlcId.rbId = dlDataMsgInfo->rbId;
706 datReqInfo->rlcId.ueId = dlDataMsgInfo->ueIdx;
707 datReqInfo->rlcId.cellId = dlDataMsgInfo->cellId;
708 datReqInfo->lcType = LCH_DTCH;
709 datReqInfo->sduId = ++(rlcCb[pst->dstInst]->dlSduId);
710 mBuf = dlDataMsgInfo->dlMsg;
711 if(rlcProcDlData(pst, datReqInfo, mBuf) != ROK)
716 /* Free memory allocated by du app */
717 RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(RlcDatReqInfo));
718 RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlDataMsgInfo, sizeof(RlcDlUserDataInfo));
722 /*******************************************************************
724 * @brief sending UE delete response to DU
728 * Function : sendRlcUeDeleteRspToDu
731 * sending UE delete response to DU
733 * @params[in] uint8_t cellId, uint8_t ueIdx, UeDeleteResult result
735 * @return ROK - success
738 * ****************************************************************/
739 uint8_t sendRlcUeDeleteRspToDu(uint16_t cellId,uint8_t ueId, UeDeleteResult result)
742 RlcUeDeleteRsp *ueDeleteRsp = NULLP;
744 FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_RLC_UE_DELETE_RSP);
746 RLC_ALLOC_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp));
749 DU_LOG("\nERROR --> RLC: sendRlcUeDeleteRspToDu(): Memory allocation failed ");
754 ueDeleteRsp->cellId = cellId;
755 ueDeleteRsp->ueId = ueId;
756 ueDeleteRsp->result = result;
758 if(rlcSendUeDeleteRspToDu(&pst, ueDeleteRsp) == ROK)
760 DU_LOG("\nDEBUG --> RLC: UE Delete response send successfully");
764 DU_LOG("\nERROR --> RLC: SendRlcUeDeleteRspToDu():Failed to send UE Delete response to DU");
765 RLC_FREE_SHRABL_BUF(pst.region, pst.pool, ueDeleteRsp, sizeof(RlcUeDeleteRsp));
772 /*******************************************************************
774 * @brief Handles Ue delete Request from DU APP
778 * Function : RlcProcUeDeleteReq
781 * Handles Ue delete Request from DU APP
783 * @params[in] Post structure pointer
784 * RlcUeDelete pointer
785 * @return ROK - success
788 * ****************************************************************/
790 uint8_t RlcProcUeDeleteReq(Pst *pst, RlcUeDelete *ueDelete)
793 RlcCb *gRlcCb = NULLP;
794 RlcUlUeCb *ueCb = NULLP;
795 UeDeleteResult result=SUCCESSFUL;
797 DU_LOG("\nDEBUG --> RLC: UE Delete request received. CellID[%d] UEID[%d]",ueDelete->cellId, ueDelete->ueId);
799 if(ueDelete != NULLP)
801 gRlcCb = RLC_GET_RLCCB(pst->dstInst);
802 rlcDbmFetchUlUeCb(gRlcCb,ueDelete->ueId, ueDelete->cellId, &ueCb);
805 if(ueDelete->cellId == ueCb->cellId)
807 memcpy(&ueCb->ueDeleteInfo.pst, pst, sizeof(Pst));
808 if((rlcChkTmr(gRlcCb, (PTR)ueCb, EVENT_RLC_UE_DELETE_TMR)) == FALSE)
810 rlcStartTmr(gRlcCb,(PTR)ueCb, EVENT_RLC_UE_DELETE_TMR);
815 result = INVALID_CELLID;
820 result = INVALID_UEID;
823 if(result != SUCCESSFUL)
825 ret = sendRlcUeDeleteRspToDu(ueDelete->cellId, ueDelete->ueId, result);
828 DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq():Failed to send UE Delete response to DU");
831 RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueDelete, sizeof(RlcUeDelete));
835 DU_LOG("\nERROR --> RLC: RlcProcUeDeleteReq(): Recieved NULL pointer UE Delete ");
841 /**********************************************************************
843 **********************************************************************/