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 **********************************************************************/