src/5gnrrlc/rlc_dl_ul_inf_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 include file
  24
  25     Desc:   Defines required by LTE MAC
  26
  27     File:   rlc_dl_ul_inf_ul.c
  28
  29 **********************************************************************/
  30
  31 /** @file rlc_dl_ul_inf_ul.c
  32 @brief  UDX Uplink Module
  33 */
  34
  35 /* header include files (.h) */
  36 #include "common_def.h"
  37 #include "lkw.h"           /* LKW defines */
  38 #include "ckw.h"           /* CKW defines */
  39 #include "kwu.h"           /* KWU defines */
  40 #include "rgu.h"           /* RGU defines */
  41 #include "rlc_err.h"        /* Err defines */
  42 #include "rlc_env.h"        /* RLC environment options */
  43
  44 /* extern (.x) include files */
  45 #include "lkw.x"           /* LKW */
  46 #include "ckw.x"           /* CKW */
  47 #include "kwu.x"           /* KWU */
  48 #include "rgu.x"           /* RGU */
  49
  50 #include "rlc_utils.h"            /* RLC defines */
  51 #include "rlc_dl_ul_inf.h"
  52 #include "rlc_dl.h"
  53 #include "rlc_ul.h"
  54 #include "du_app_rlc_inf.h"
  55 #include "rlc_mgr.h"
  56
  57 #define RLC_MODULE RLC_DBGMASK_UDX
  58 /* local defines */
  59
  60 /* local externs */
  61
  62 /* forward references */
  63
  64 /* public variable declarations */
  65 S16 rlcHdlCrlcUlCfgReq ARGS((RlcCb  *gCb,RlcUlCfgTmpData *cfgTmpData,
  66                                   RlcCfgCfmInfo *cfmInfo, RlcCfgCfmInfo *cfgCfm));
  67
  68 /**
  69   * @brief
  70   * UDX APIs
  71   */
  72 /**
  73  * @brief
  74  *    Handler for bind confirmation from DL.
  75  *
  76  * @details
  77  *    This function handles the bind confirmation received
  78  *    from DL.
  79  *
  80  * @param[in] pst     Post structure
  81  * @param[in] suId    Service User ID
  82  * @param[in] status  Status of confirmation
  83  *
  84  * @return  S16
  85  *    -# ROK
  86  *    -# RFAILED
  87  */
  88
  89 S16 rlcUlUdxBndCfm
  90 (
  91 Pst    *pst,
  92 SuId   suId,
  93 uint8_t status
  94 )
  95 {
  96    uint16_t        event;
  97    uint16_t        cause;
  98    RlcUdxUlSapCb   *udxSap;   /* RGU SAP Control Block */
  99    RlcCb           *tRlcCb;
 100
 101 #if (ERRCLASS & ERRCLS_INT_PAR)
 102    if (pst->dstInst >= MAX_RLC_INSTANCES)
 103    {
 104       return  (RFAILED);
 105    }
 106 #endif
 107    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 108
 109    RLCDBGP_BRIEF(tRlcCb, "rlcUlUdxBndCfm(post, suId(%d), status(%d)\n",
 110                 suId, status);
 111
 112 #if (ERRCLASS & ERRCLS_INT_PAR)
 113    if (tRlcCb->init.cfgDone != TRUE)
 114    {
 115       DU_LOG("\nERROR  -->  RLC_UL : General configuration not done");
 116       RLC_SEND_SAPID_ALARM(tRlcCb,suId,
 117                           LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
 118
 119       return RFAILED;
 120    }
 121
 122    if (suId < 0)
 123    {
 124       DU_LOG("\nERROR  -->  RLC_UL : Invalid suId");
 125       RLC_SEND_SAPID_ALARM(tRlcCb,suId,
 126                            LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
 127
 128       return RFAILED;
 129    }
 130 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 131
 132    udxSap = tRlcCb->u.ulCb->udxUlSap + suId;
 133
 134    RLCDBGP_DETAIL(tRlcCb, "RlcLiRguBndCfm: For RGU SAP state=%d\n",
 135                  udxSap->state);
 136
 137    /* Check rguSap state */
 138    switch (udxSap->state)
 139    {
 140       case RLC_SAP_BINDING:
 141       {
 142          if(TRUE == rlcChkTmr(tRlcCb,(PTR)udxSap,EVENT_RLC_WAIT_BNDCFM))
 143          {
 144              rlcStopTmr (tRlcCb,(PTR)udxSap, EVENT_RLC_WAIT_BNDCFM);
 145          }
 146          udxSap->retryCnt = 0;
 147
 148          if (status == CM_BND_OK)
 149          {
 150             udxSap->state = RLC_SAP_BND;
 151             event = LCM_EVENT_BND_OK;
 152             cause = LKW_CAUSE_SAP_BNDENB;
 153          }
 154          else
 155          {
 156             udxSap->state = RLC_SAP_CFG;
 157             event = LCM_EVENT_BND_FAIL;
 158             cause = LKW_CAUSE_UNKNOWN;
 159          }
 160       }
 161       break;
 162
 163      default:
 164         event = LKW_EVENT_RGU_BND_CFM;
 165         cause = LCM_CAUSE_INV_STATE;
 166         break;
 167    }
 168    /* Send an alarm with proper event and cause */
 169    RLC_SEND_SAPID_ALARM(tRlcCb,suId, event, cause);
 170
 171    return ROK;
 172 }
 173
 174 /**
 175  * @brief
 176  *    Handles UDX Configuration Confirm
 177  *
 178  * @details
 179  *    This function handles the UDX configuration Confirm from DL Instance
 180  *
 181  * @param[in] pst     Post structure
 182  * @param[in] suId    Service User ID
 183  * @param[in] cfmInfo Confirm Information
 184  *
 185  * @return  S16
 186  *    -# ROK
 187  *    -# RFAILED
 188  */
 189 S16 rlcUlUdxCfgCfm
 190 (
 191 Pst             *pst,
 192 SuId            suId,
 193 RlcCfgCfmInfo   *cfmInfo
 194 )
 195 {
 196    uint8_t cfgIdx=0;
 197    RlcCb             *tRlcCb;
 198    RlcCfgCfmInfo    *cfgCfm;
 199    RlcUlCfgTmpData   *cfgTmpData;
 200    Pst rspPst;
 201    memset(&rspPst, 0, sizeof(Pst));
 202
 203 #if (ERRCLASS & ERRCLS_INT_PAR)
 204    if (pst->dstInst >= MAX_RLC_INSTANCES)
 205    {
 206       RLC_FREE_SHRABL_BUF(pst->region,
 207                          pst->pool,
 208                          cfmInfo,
 209                          sizeof(RlcCfgCfmInfo));
 210       return  (RFAILED);
 211    }
 212 #endif
 213    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 214    RLCDBGP_BRIEF(tRlcCb, " suId(%d)\n", suId);
 215
 216 #if (ERRCLASS & ERRCLS_INT_PAR)
 217    if (suId < 0)
 218    {
 219       DU_LOG("\nERROR  -->  RLC_UL : Invalid suId");
 220       RLC_SEND_SAPID_ALARM(tRlcCb,suId,
 221                            LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
 222       RLC_FREE_SHRABL_BUF(pst->region,
 223                          pst->pool,
 224                          cfmInfo,
 225                          sizeof(RlcCfgCfmInfo));
 226       return RFAILED;
 227    }
 228 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 229
 230    if(ROK != rlcDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
 231    {
 232       DU_LOG("\nERROR  -->  RLC_UL : Invalid transId");
 233       RLC_FREE_SHRABL_BUF(pst->region,
 234                          pst->pool,
 235                          cfmInfo,
 236                          sizeof(RlcCfgCfmInfo));
 237       return  (RFAILED);
 238    }
 239
 240    if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
 241    {
 242       RLC_FREE_SHRABL_BUF(pst->region,
 243                          pst->pool,
 244                          cfmInfo,
 245                          sizeof(RlcCfgCfmInfo));
 246        return RFAILED;
 247    }
 248       /* Allocate memory and memset to 0 for cfmInfo */
 249    RLC_ALLOC(tRlcCb,cfgCfm, sizeof(RlcCfgCfmInfo));
 250 #if (ERRCLASS & ERRCLS_ADD_RES)
 251    if (cfgCfm == NULLP)
 252    {
 253       DU_LOG("\nERROR  -->  RLC_UL : Memory Allocation failed.");
 254       RLC_FREE_SHRABL_BUF(pst->region,
 255                          pst->pool,
 256                          cfmInfo,
 257                          sizeof(RlcCfgCfmInfo));
 258        return RFAILED;
 259    }
 260 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 261    rlcHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
 262    if(tRlcCb->u.ulCb->rlcUlUdxEventType == EVENT_RLC_UE_CREATE_REQ)
 263    {
 264       FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_CREATE_RSP);
 265       SendRlcUeCfgRspToDu(&rspPst, cfgCfm);
 266    }
 267    else if(tRlcCb->u.ulCb->rlcUlUdxEventType == EVENT_RLC_UE_RECONFIG_REQ)
 268    {
 269       FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_RSP);
 270       SendRlcUeCfgRspToDu(&rspPst, cfgCfm);
 271    }
 272    else if (tRlcCb->u.ulCb->rlcUlUdxEventType == EVENT_RLC_UE_DELETE_REQ)
 273    {
 274       FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_DELETE_RSP);
 275       if(sendRlcUeDeleteRspToDu(cfgCfm->cellId, cfgCfm->ueId, SUCCESSFUL) != ROK)
 276       {
 277          DU_LOG("ERROR  --> RLC_UL: rlcUlUdxCfgCfm(): Failed to send UE delete response ");
 278          RLC_FREE(tRlcCb, cfgCfm, sizeof(RlcCfgCfmInfo));
 279          return RFAILED;
 280       }
 281       RLC_FREE(tRlcCb, cfgCfm, sizeof(RlcCfgCfmInfo));
 282    }
 283
 284    /* free the memory from DL */
 285    RLC_FREE_SHRABL_BUF(pst->region, pst->pool, cfmInfo, sizeof(RlcCfgCfmInfo));
 286
 287    /* free the cfgInfo that came from LM */
 288    for(cfgIdx=0; cfgIdx<cfgTmpData->cfgInfo->numEnt; cfgIdx++)
 289    {
 290       RLC_FREE(tRlcCb, cfgTmpData->cfgInfo->entCfg[cfgIdx].snssai, sizeof(Snssai));
 291    }
 292    RLC_FREE(tRlcCb, cfgTmpData->cfgInfo, sizeof(RlcCfgInfo));
 293    RLC_FREE(tRlcCb,cfgTmpData,sizeof(RlcUlCfgTmpData));
 294
 295    return ROK;
 296 }
 297
 298 /**
 299  * @brief
 300  *    Handler for UeId change confirm
 301  *
 302  * @details
 303  *    This function handles the UeId Change Confirm from DL Instance
 304  *
 305  *  @param[in] pst     Post structure
 306  *  @param[in] suId    Service User ID
 307  *  @param[in] transId Transaction Id
 308  *  @param[in] status  Status of confirmation
 309  *  @return  S16
 310  *      -# ROK
 311  *      -# RFAILED
 312  */
 313
 314 S16 rlcUlUdxUeIdChgCfm
 315 (
 316 Pst        *pst,
 317 SuId       suId,
 318 uint32_t        transId,
 319 CmStatus   status
 320 )
 321 {
 322    RlcCb             *tRlcCb;
 323    RlcUlCfgTmpData   *cfgTmpData;
 324
 325 #if (ERRCLASS & ERRCLS_INT_PAR)
 326    if (pst->dstInst >= MAX_RLC_INSTANCES)
 327    {
 328       return  (RFAILED);
 329    }
 330 #endif
 331    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 332
 333    RLCDBGP_BRIEF(tRlcCb, " suId(%d) \n", suId);
 334
 335 #if (ERRCLASS & ERRCLS_INT_PAR)
 336    if (suId < 0)
 337    {
 338       DU_LOG("\nERROR  -->  RLC_UL : Invalid suId");
 339       return RFAILED;
 340    }
 341 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 342
 343    if(ROK != rlcDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
 344    {
 345       DU_LOG("\nERROR  -->  RLC_UL : Invalid transId");
 346       return  (RFAILED);
 347    }
 348
 349    if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
 350    {
 351       return RFAILED;
 352    }
 353
 354    if(status.status == CKW_CFG_CFM_OK)
 355    {
 356        if(cfgTmpData->ueCb != NULLP)
 357        {
 358       rlcCfgApplyUlUeIdChng(tRlcCb, cfgTmpData->ueInfo, cfgTmpData->newUeInfo, cfgTmpData);
 359    }
 360    }
 361    RlcUiCkwUeIdChgCfm(&(tRlcCb->u.ulCb->ckwSap.pst),
 362                      tRlcCb->u.ulCb->ckwSap.suId,
 363                      transId,cfgTmpData->ueInfo,status);
 364    /* only newUeInfo needs to be freed here, ueInfo would be freed at the
 365       interface or by he receipient in case of tight coupling */
 366    RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->newUeInfo, sizeof(CkwUeInfo));
 367    RLC_FREE(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
 368    return ROK;
 369 }
 370
 371 /**
 372  * @brief
 373  *    Udx Status Prohibit Timer Start
 374  *
 375  *  @param[in] pst     Post structure
 376  *  @param[in] suId    Service User ID
 377  *  @param[in] rlcId   rlc Id
 378  *  @return  S16
 379  *      -# ROK
 380  *      -# RFAILED
 381  */
 382 S16  rlcUlUdxStaProhTmrStart
 383 (
 384 Pst*         pst,
 385 SuId         suId,
 386 CmLteRlcId   *rlcId
 387 )
 388 {
 389    RlcCb       *tRlcCb= NULLP;
 390    RlcUlRbCb   *rbCb;
 391
 392 #if (ERRCLASS & ERRCLS_INT_PAR)
 393    if (pst->dstInst >= MAX_RLC_INSTANCES)
 394    {
 395       return  (RFAILED);
 396    }
 397 #endif
 398    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 399
 400    rlcDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
 401    if (rbCb == NULLP)
 402    {
 403       DU_LOG("\nERROR  -->  RLC_UL : CellId [%u]:RbId[%d] not found",
 404             rlcId->cellId,rlcId->rbId);
 405       return RFAILED;
 406    }
 407
 408    /* Start staProhTmr */
 409    rlcStartTmr(tRlcCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
 410
 411    return  (ROK);
 412 }
 413
 414 /**
 415  * @brief
 416  *    Handler for configuration confirm from DL.
 417  *
 418  * @param[in] gCb        - RLC Instance Control Block
 419  * @param[in] cfgTmpData - Configuration Temporary Data
 420  * @param[in] cfmInfo    - DL Configuration Confirm Info
 421  * @param[out] cfgCfm    - Configuration Confirm to be sent to RRC
 422  *
 423  * @return  S16
 424  *    -# ROK
 425  *    -# RFAILED
 426  */
 427 S16 rlcHdlCrlcUlCfgReq
 428 (
 429 RlcCb             *gCb,
 430 RlcUlCfgTmpData   *cfgTmpData,
 431 RlcCfgCfmInfo    *cfmInfo,
 432 RlcCfgCfmInfo    *cfgCfm
 433 )
 434 {
 435    RlcCfgInfo   *cfg;
 436    uint32_t     idx;
 437    uint32_t     maxEnt;
 438
 439    cfg = cfgTmpData->cfgInfo;
 440    maxEnt = (cfg->numEnt < CKW_MAX_ENT_CFG)? cfg->numEnt:CKW_MAX_ENT_CFG;
 441
 442    for (idx = 0; idx < maxEnt; idx++)
 443    {
 444       RlcEntCfgCfmInfo   *entCfgCfm;
 445       RlcEntCfgCfmInfo   *entDlCfgCfm;
 446       RlcEntCfgInfo      *entCfg;
 447
 448       entCfg  = &(cfg->entCfg[idx]);
 449       entCfgCfm   = &(cfgCfm->entCfgCfm[idx]);
 450       entDlCfgCfm = &(cfmInfo->entCfgCfm[idx]);
 451       switch (entCfg->cfgType)
 452       {
 453          case CKW_CFG_ADD:
 454          case CKW_CFG_MODIFY:
 455          case CKW_CFG_DELETE:
 456             {
 457                if (entCfg->dir == RLC_DIR_UL)
 458                {
 459                   RLC_MEM_CPY(entCfgCfm,
 460                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 461                              sizeof(RlcEntCfgCfmInfo));
 462                }
 463                else if (entCfg->dir == RLC_DIR_DL)
 464                {
 465                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 466                }
 467                else if(entCfg->dir == RLC_DIR_BOTH)
 468                {
 469                   if (entDlCfgCfm->status.status != CKW_CFG_CFM_OK)
 470                   {
 471                      rlcCfgRollBackUlRb(gCb,
 472                                        cfg->ueId,
 473                                        &cfg->entCfg[idx],
 474                                        &cfgTmpData->cfgEntData[idx]);
 475                   }
 476                   else
 477                   {
 478                      rlcCfgApplyUlRb(gCb,
 479                                     &cfg->entCfg[idx],
 480                                     &cfgTmpData->cfgEntData[idx],
 481                                     cfgTmpData);
 482                   }
 483                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 484                }
 485                else
 486                {
 487                             RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
 488                                            CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_DIR);
 489                   DU_LOG("\nDEBUG  -->  RLC_UL : RBID[%d] direction[%d] is invalid",
 490                          entCfg->rbId,entCfg->dir);
 491                }
 492                break;
 493             }
 494
 495          case CKW_CFG_REESTABLISH:
 496             {
 497                if (entCfg->dir == RLC_DIR_UL)
 498                {
 499                   RLC_MEM_CPY(entCfgCfm,
 500                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 501                              sizeof(RlcEntCfgCfmInfo));
 502                }
 503                else if (entCfg->dir == RLC_DIR_DL)
 504                {
 505                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 506                }
 507                else
 508                {
 509                   if (entCfg->dir & RLC_DIR_UL)
 510                   {
 511                      /* Reestablish indication is sent from UL Instance only*/
 512                      if (entDlCfgCfm->status.status == CKW_CFG_CFM_OK)
 513                      {
 514                         rlcCfgApplyReEstUlRb (gCb, cfg->ueId,
 515                                              cfg->cellId, TRUE,
 516                                              &cfgTmpData->cfgEntData[idx]);
 517                      }
 518                      RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 519                   }
 520                }
 521                break;
 522             }
 523          case CKW_CFG_DELETE_UE:
 524             {
 525                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
 526                {
 527                   rlcCfgApplyDelUlUe(gCb, cfgTmpData);
 528                   RLC_MEM_CPY(entCfgCfm,
 529                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 530                              sizeof(RlcEntCfgCfmInfo));
 531                }
 532                else
 533                {
 534                    RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
 535                               sizeof(RlcEntCfgCfmInfo));
 536                }
 537                break;
 538             }
 539          case CKW_CFG_DELETE_CELL:
 540             {
 541                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
 542                {
 543                   rlcCfgApplyDelUlCell(gCb, cfgTmpData);
 544                   RLC_MEM_CPY(entCfgCfm,
 545                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 546                              sizeof(RlcEntCfgCfmInfo));
 547                }
 548                else
 549                {
 550                    RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
 551                               sizeof(RlcEntCfgCfmInfo));
 552                }
 553                break;
 554             }
 555          default:
 556             {
 557                RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
 558                                    CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
 559
 560                DU_LOG("\nERROR  -->  RLC_UL : Invalid configuration type");
 561             }
 562       }
 563    }
 564
 565    /* Assign number of entity configurations and suId */
 566    cfgCfm->transId = cfgTmpData->uprLyrTransId;
 567    cfgCfm->ueId = cfg->ueId;
 568    cfgCfm->cellId = cfg->cellId;
 569    cfgCfm->numEnt = cfg->numEnt;
 570
 571    return ROK;
 572 }
 573 #ifdef __cplusplus
 574 }
 575 #endif /* __cplusplus */
 576
 577 \f
 578 /**********************************************************************
 579          End of file
 580 **********************************************************************/