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    RlcCb             *tRlcCb;
 197    RlcCfgCfmInfo    *cfgCfm;
 198    RlcUlCfgTmpData   *cfgTmpData;
 199    Pst rspPst;
 200    memset(&rspPst, 0, sizeof(Pst));
 201
 202 #if (ERRCLASS & ERRCLS_INT_PAR)
 203    if (pst->dstInst >= MAX_RLC_INSTANCES)
 204    {
 205       RLC_FREE_SHRABL_BUF(pst->region,
 206                          pst->pool,
 207                          cfmInfo,
 208                          sizeof(RlcCfgCfmInfo));
 209       return  (RFAILED);
 210    }
 211 #endif
 212    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 213    RLCDBGP_BRIEF(tRlcCb, " suId(%d)\n", suId);
 214
 215 #if (ERRCLASS & ERRCLS_INT_PAR)
 216    if (suId < 0)
 217    {
 218       DU_LOG("\nERROR  -->  RLC_UL : Invalid suId");
 219       RLC_SEND_SAPID_ALARM(tRlcCb,suId,
 220                            LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
 221       RLC_FREE_SHRABL_BUF(pst->region,
 222                          pst->pool,
 223                          cfmInfo,
 224                          sizeof(RlcCfgCfmInfo));
 225       return RFAILED;
 226    }
 227 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 228
 229    if(ROK != rlcDbmFindUlTransaction(tRlcCb,cfmInfo->transId, &cfgTmpData))
 230    {
 231       DU_LOG("\nERROR  -->  RLC_UL : Invalid transId");
 232       RLC_FREE_SHRABL_BUF(pst->region,
 233                          pst->pool,
 234                          cfmInfo,
 235                          sizeof(RlcCfgCfmInfo));
 236       return  (RFAILED);
 237    }
 238
 239    if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
 240    {
 241       RLC_FREE_SHRABL_BUF(pst->region,
 242                          pst->pool,
 243                          cfmInfo,
 244                          sizeof(RlcCfgCfmInfo));
 245        return RFAILED;
 246    }
 247       /* Allocate memory and memset to 0 for cfmInfo */
 248    RLC_ALLOC(tRlcCb,cfgCfm, sizeof(RlcCfgCfmInfo));
 249 #if (ERRCLASS & ERRCLS_ADD_RES)
 250    if (cfgCfm == NULLP)
 251    {
 252       DU_LOG("\nERROR  -->  RLC_UL : Memory Allocation failed.");
 253       RLC_FREE_SHRABL_BUF(pst->region,
 254                          pst->pool,
 255                          cfmInfo,
 256                          sizeof(RlcCfgCfmInfo));
 257        return RFAILED;
 258    }
 259 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 260    rlcHdlCrlcUlCfgReq(tRlcCb,cfgTmpData, cfmInfo, cfgCfm);
 261    if(tRlcCb->u.ulCb->rlcUlUdxEventType == EVENT_RLC_UE_CREATE_REQ)
 262    {
 263       FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_CREATE_RSP);
 264       SendRlcUeCfgRspToDu(&rspPst, cfgCfm);
 265    }
 266    else if(tRlcCb->u.ulCb->rlcUlUdxEventType == EVENT_RLC_UE_RECONFIG_REQ)
 267    {
 268       FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_RECONFIG_RSP);
 269       SendRlcUeCfgRspToDu(&rspPst, cfgCfm);
 270    }
 271    else if (tRlcCb->u.ulCb->rlcUlUdxEventType == EVENT_RLC_UE_DELETE_REQ)
 272    {
 273       FILL_PST_RLC_TO_DUAPP(rspPst, RLC_UL_INST, EVENT_RLC_UE_DELETE_RSP);
 274       if(sendRlcUeDeleteRspToDu(cfgCfm->ueId, cfgCfm->cellId, SUCCESSFUL) != ROK)
 275       {
 276          DU_LOG("ERROR  --> RLC_UL: rlcUlUdxCfgCfm(): Failed to send UE delete response ");
 277          return RFAILED;
 278       }
 279    }
 280
 281    /* free the memory from DL */
 282    RLC_FREE_SHRABL_BUF(pst->region,
 283                       pst->pool,
 284                       cfmInfo,
 285                       sizeof(RlcCfgCfmInfo));
 286
 287    /* free the cfgInfo that came from LM */
 288    RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->cfgInfo, sizeof(RlcCfgInfo));
 289    RLC_FREE(tRlcCb,cfgTmpData,sizeof(RlcUlCfgTmpData));
 290
 291    return ROK;
 292 }
 293
 294 /**
 295  * @brief
 296  *    Handler for UeId change confirm
 297  *
 298  * @details
 299  *    This function handles the UeId Change Confirm from DL Instance
 300  *
 301  *  @param[in] pst     Post structure
 302  *  @param[in] suId    Service User ID
 303  *  @param[in] transId Transaction Id
 304  *  @param[in] status  Status of confirmation
 305  *  @return  S16
 306  *      -# ROK
 307  *      -# RFAILED
 308  */
 309
 310 S16 rlcUlUdxUeIdChgCfm
 311 (
 312 Pst        *pst,
 313 SuId       suId,
 314 uint32_t        transId,
 315 CmStatus   status
 316 )
 317 {
 318    RlcCb             *tRlcCb;
 319    RlcUlCfgTmpData   *cfgTmpData;
 320
 321 #if (ERRCLASS & ERRCLS_INT_PAR)
 322    if (pst->dstInst >= MAX_RLC_INSTANCES)
 323    {
 324       return  (RFAILED);
 325    }
 326 #endif
 327    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 328
 329    RLCDBGP_BRIEF(tRlcCb, " suId(%d) \n", suId);
 330
 331 #if (ERRCLASS & ERRCLS_INT_PAR)
 332    if (suId < 0)
 333    {
 334       DU_LOG("\nERROR  -->  RLC_UL : Invalid suId");
 335       return RFAILED;
 336    }
 337 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 338
 339    if(ROK != rlcDbmFindUlTransaction(tRlcCb, transId, &cfgTmpData))
 340    {
 341       DU_LOG("\nERROR  -->  RLC_UL : Invalid transId");
 342       return  (RFAILED);
 343    }
 344
 345    if(ROK != rlcDbmDelUlTransaction(tRlcCb, cfgTmpData))
 346    {
 347       return RFAILED;
 348    }
 349
 350    if(status.status == CKW_CFG_CFM_OK)
 351    {
 352        if(cfgTmpData->ueCb != NULLP)
 353        {
 354       rlcCfgApplyUlUeIdChng(tRlcCb, cfgTmpData->ueInfo, cfgTmpData->newUeInfo, cfgTmpData);
 355    }
 356    }
 357    RlcUiCkwUeIdChgCfm(&(tRlcCb->u.ulCb->ckwSap.pst),
 358                      tRlcCb->u.ulCb->ckwSap.suId,
 359                      transId,cfgTmpData->ueInfo,status);
 360    /* only newUeInfo needs to be freed here, ueInfo would be freed at the
 361       interface or by he receipient in case of tight coupling */
 362    RLC_PST_FREE(pst->region, pst->pool, cfgTmpData->newUeInfo, sizeof(CkwUeInfo));
 363    RLC_FREE(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
 364    return ROK;
 365 }
 366
 367 /**
 368  * @brief
 369  *    Udx Status Prohibit Timer Start
 370  *
 371  *  @param[in] pst     Post structure
 372  *  @param[in] suId    Service User ID
 373  *  @param[in] rlcId   rlc Id
 374  *  @return  S16
 375  *      -# ROK
 376  *      -# RFAILED
 377  */
 378 S16  rlcUlUdxStaProhTmrStart
 379 (
 380 Pst*         pst,
 381 SuId         suId,
 382 CmLteRlcId   *rlcId
 383 )
 384 {
 385    RlcCb       *tRlcCb= NULLP;
 386    RlcUlRbCb   *rbCb;
 387
 388 #if (ERRCLASS & ERRCLS_INT_PAR)
 389    if (pst->dstInst >= MAX_RLC_INSTANCES)
 390    {
 391       return  (RFAILED);
 392    }
 393 #endif
 394    tRlcCb = RLC_GET_RLCCB(pst->dstInst);
 395
 396    rlcDbmFetchUlRbCbByRbId(tRlcCb, rlcId, &rbCb);
 397    if (rbCb == NULLP)
 398    {
 399       DU_LOG("\nERROR  -->  RLC_UL : CellId [%u]:RbId[%d] not found",
 400             rlcId->cellId,rlcId->rbId);
 401       return RFAILED;
 402    }
 403
 404    /* Start staProhTmr */
 405    rlcStartTmr(tRlcCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
 406
 407    return  (ROK);
 408 }
 409
 410 /**
 411  * @brief
 412  *    Handler for configuration confirm from DL.
 413  *
 414  * @param[in] gCb        - RLC Instance Control Block
 415  * @param[in] cfgTmpData - Configuration Temporary Data
 416  * @param[in] cfmInfo    - DL Configuration Confirm Info
 417  * @param[out] cfgCfm    - Configuration Confirm to be sent to RRC
 418  *
 419  * @return  S16
 420  *    -# ROK
 421  *    -# RFAILED
 422  */
 423 S16 rlcHdlCrlcUlCfgReq
 424 (
 425 RlcCb             *gCb,
 426 RlcUlCfgTmpData   *cfgTmpData,
 427 RlcCfgCfmInfo    *cfmInfo,
 428 RlcCfgCfmInfo    *cfgCfm
 429 )
 430 {
 431    RlcCfgInfo   *cfg;
 432    uint32_t     idx;
 433    uint32_t     maxEnt;
 434
 435    cfg = cfgTmpData->cfgInfo;
 436    maxEnt = (cfg->numEnt < CKW_MAX_ENT_CFG)? cfg->numEnt:CKW_MAX_ENT_CFG;
 437
 438    for (idx = 0; idx < maxEnt; idx++)
 439    {
 440       RlcEntCfgCfmInfo   *entCfgCfm;
 441       RlcEntCfgCfmInfo   *entDlCfgCfm;
 442       RlcEntCfgInfo      *entCfg;
 443
 444       entCfg  = &(cfg->entCfg[idx]);
 445       entCfgCfm   = &(cfgCfm->entCfgCfm[idx]);
 446       entDlCfgCfm = &(cfmInfo->entCfgCfm[idx]);
 447       switch (entCfg->cfgType)
 448       {
 449          case CKW_CFG_ADD:
 450          case CKW_CFG_MODIFY:
 451          case CKW_CFG_DELETE:
 452             {
 453                if (entCfg->dir == RLC_DIR_UL)
 454                {
 455                   RLC_MEM_CPY(entCfgCfm,
 456                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 457                              sizeof(RlcEntCfgCfmInfo));
 458                }
 459                else if (entCfg->dir == RLC_DIR_DL)
 460                {
 461                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 462                }
 463                else if(entCfg->dir == RLC_DIR_BOTH)
 464                {
 465                   if (entDlCfgCfm->status.status != CKW_CFG_CFM_OK)
 466                   {
 467                      rlcCfgRollBackUlRb(gCb,
 468                                        cfg->ueId,
 469                                        &cfg->entCfg[idx],
 470                                        &cfgTmpData->cfgEntData[idx]);
 471                   }
 472                   else
 473                   {
 474                      rlcCfgApplyUlRb(gCb,
 475                                     &cfg->entCfg[idx],
 476                                     &cfgTmpData->cfgEntData[idx],
 477                                     cfgTmpData);
 478                   }
 479                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 480                }
 481                else
 482                {
 483                             RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
 484                                            CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_DIR);
 485                   DU_LOG("\nDEBUG  -->  RLC_UL : RBID[%d] direction[%d] is invalid",
 486                          entCfg->rbId,entCfg->dir);
 487                }
 488                break;
 489             }
 490
 491          case CKW_CFG_REESTABLISH:
 492             {
 493                if (entCfg->dir == RLC_DIR_UL)
 494                {
 495                   RLC_MEM_CPY(entCfgCfm,
 496                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 497                              sizeof(RlcEntCfgCfmInfo));
 498                }
 499                else if (entCfg->dir == RLC_DIR_DL)
 500                {
 501                   RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 502                }
 503                else
 504                {
 505                   if (entCfg->dir & RLC_DIR_UL)
 506                   {
 507                      /* Reestablish indication is sent from UL Instance only*/
 508                      if (entDlCfgCfm->status.status == CKW_CFG_CFM_OK)
 509                      {
 510                         rlcCfgApplyReEstUlRb (gCb, cfg->ueId,
 511                                              cfg->cellId, TRUE,
 512                                              &cfgTmpData->cfgEntData[idx]);
 513                      }
 514                      RLC_MEM_CPY(entCfgCfm, entDlCfgCfm, sizeof(RlcEntCfgCfmInfo));
 515                   }
 516                }
 517                break;
 518             }
 519          case CKW_CFG_DELETE_UE:
 520             {
 521                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
 522                {
 523                   rlcCfgApplyDelUlUe(gCb, cfgTmpData);
 524                   RLC_MEM_CPY(entCfgCfm,
 525                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 526                              sizeof(RlcEntCfgCfmInfo));
 527                }
 528                else
 529                {
 530                    RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
 531                               sizeof(RlcEntCfgCfmInfo));
 532                }
 533                break;
 534             }
 535          case CKW_CFG_DELETE_CELL:
 536             {
 537                if (cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status == CKW_CFG_CFM_OK)
 538                {
 539                   rlcCfgApplyDelUlCell(gCb, cfgTmpData);
 540                   RLC_MEM_CPY(entCfgCfm,
 541                              &cfgTmpData->cfgEntData[idx].entUlCfgCfm,
 542                              sizeof(RlcEntCfgCfmInfo));
 543                }
 544                else
 545                {
 546                    RLC_MEM_CPY(entCfgCfm, entDlCfgCfm,
 547                               sizeof(RlcEntCfgCfmInfo));
 548                }
 549                break;
 550             }
 551          default:
 552             {
 553                RLC_CFG_FILL_CFG_CFM(entCfgCfm, entCfg->rbId, entCfg->rbType,
 554                                    CKW_CFG_CFM_NOK, CKW_CFG_REAS_INVALID_CFG);
 555
 556                DU_LOG("\nERROR  -->  RLC_UL : Invalid configuration type");
 557             }
 558       }
 559    }
 560
 561    /* Assign number of entity configurations and suId */
 562    cfgCfm->transId = cfgTmpData->uprLyrTransId;
 563    cfgCfm->ueId = cfg->ueId;
 564    cfgCfm->cellId = cfg->cellId;
 565    cfgCfm->numEnt = cfg->numEnt;
 566
 567    return ROK;
 568 }
 569 #ifdef __cplusplus
 570 }
 571 #endif /* __cplusplus */
 572
 573 \f
 574 /**********************************************************************
 575          End of file
 576 **********************************************************************/