src/5gnrmac/rg_dbm.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:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_dbm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_dbm.c
  32 @brief This file contains the APIs exposed for the insertion/fetching/deletion of cellCb/ueCb and traversal of LcCbLst.
  33 */
  34
  35 /* header include files -- defines (.h) */
  36 #include "common_def.h"
  37 #include "tfu.h"
  38 #include "du_app_mac_inf.h"
  39 #include "lrg.h"
  40 #include "crg.h"
  41 #include "rgu.h"
  42 #include "rg_sch_inf.h"
  43 #include "rg_env.h"
  44 #include "rg.h"
  45
  46 /* header/extern include files (.x) */
  47 #include "tfu.x"
  48 #include "lrg.x"
  49 #include "crg.x"
  50 #include "rgu.x"
  51 #include "rg_sch_inf.x"
  52 #include "rg_prg.x"       /* PRG interface typedefs*/
  53 #include "rg.x"
  54
  55 /* local defines */
  56 static S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, uint16_t numBins));
  57 static Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
  58 static Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
  59 static Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
  60 #ifdef LTEMAC_SPS
  61 static S16 rgDBMInitSpsUeCbLst ARGS((
  62 RgCellCb       *cellCb,
  63 uint16_t       numBins
  64 ));
  65 #endif
  66
  67 /* local typedefs */
  68
  69 /* local externs */
  70
  71 /* forward references */
  72
  73 /**
  74  * @brief Handler for Initializing the cell.
  75  *
  76  * @details
  77  *
  78  *     Function : rgDBMInitCell
  79  *
  80  *   Initializes the lists belonging to the cell.
  81  *
  82  *
  83  *  @param[in]  RgCellCb *cellCb
  84  *  @return  S16
  85  *      -# ROK
  86  *      -# RFAILED
  87  **/
  88 S16 rgDBMInitCell
  89 (
  90 RgCellCb       *cellCb
  91 )
  92 {
  93    S16 ret;
  94
  95    /* Initialize ue list */
  96    if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
  97       return (ret);
  98
  99 #ifdef LTEMAC_SPS
 100    /* Initialize SPS Ue list */
 101    if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
 102       return (ret);
 103 #endif /* LTEMAC_SPS */
 104
 105    /* Initialize BCCH/PCCH logical channels */
 106    rgDBMInitCmnLcLst(cellCb);
 107
 108
 109    /* Initialize rach ue list */
 110    rgDBMInitRachLst(cellCb);
 111
 112    return (ret);
 113
 114 } /* rgDBMInitCell */
 115
 116 /**
 117  * @brief Handler for initializing the ueCbLst under the cellCb.
 118  *
 119  * @details
 120  *
 121  *     Function : rgDBMInitUeCbLst
 122  *
 123  *
 124  *  @param[in] *cellCb
 125  *  @param[in] numBins
 126  *  @return  S16
 127  *      -# ROK
 128  *      -# RFAILED
 129  **/
 130 static S16 rgDBMInitUeCbLst
 131 (
 132 RgCellCb       *cellCb,
 133 uint16_t       numBins
 134 )
 135 {
 136    Inst inst = cellCb->macInst - RG_INST_START;
 137    RgUeCb ue;
 138
 139    return (cmHashListInit(&cellCb->ueLst, numBins, (uint16_t)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
 140                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
 141
 142 }  /* rgDBMInitUeCbLst */
 143
 144 /**
 145  * @brief Handler for de-initializing the ueCbLst under the cellCb.
 146  *
 147  * @details
 148  *
 149  *     Function : rgDBMDeInitUeCbLst
 150  *
 151  *
 152  *  @param[in] *cellCb
 153  *  @return  S16
 154  *      -# ROK
 155  *      -# RFAILED
 156  **/
 157 S16 rgDBMDeInitUeCbLst(RgCellCb *cellCb)
 158 {
 159
 160    return (cmHashListDeinit(&cellCb->ueLst));
 161
 162 }  /* rgDBMDeInitUeCbLst */
 163
 164 #ifdef LTEMAC_SPS
 165 /**
 166  * @brief Handler for initializing the spsUeCbLst under the cellCb.
 167  *
 168  * @details
 169  *
 170  *     Function : rgDBMInitSpsUeCbLst
 171  *
 172  *
 173  *  @param[in] *cellCb
 174  *  @param[in] numBins
 175  *  @return  S16
 176  *      -# ROK
 177  *      -# RFAILED
 178  **/
 179 static S16 rgDBMInitSpsUeCbLst(RgCellCb *cellCb,uint16_t numBins)
 180 {
 181    Inst inst = cellCb->macInst - RG_INST_START;
 182    RgUeCb ue;
 183
 184    return (cmHashListInit(&cellCb->spsUeLst, numBins, (uint16_t) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
 185                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
 186
 187 }  /* rgDBMInitSpsUeCbLst */
 188
 189 /**
 190  * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
 191  *
 192  * @details
 193  *
 194  *     Function : rgDBMDeInitSpsUeCbLst
 195  *
 196  *
 197  *  @param[in] *cellCb
 198  *  @return  S16
 199  *      -# ROK
 200  *      -# RFAILED
 201  **/
 202 S16 rgDBMDeInitSpsUeCbLst(RgCellCb *cellCb)
 203 {
 204
 205    return (cmHashListDeinit(&cellCb->spsUeLst));
 206
 207 }  /* rgDBMDeInitSpsUeCbLst */
 208
 209 #endif /* LTEMAC_SPS */
 210
 211 /**
 212  * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
 213  *
 214  * @details
 215  *
 216  *     Function : rgDBMInsUeCb
 217  *
 218  *
 219  *  @param[in] *cellCb
 220  *  @param[in] *ueCb
 221  *  @return  S16
 222  *      -# ROK
 223  *      -# RFAILED
 224  **/
 225 S16 rgDBMInsUeCb(RgCellCb *cellCb,RgUeCb *ueCb)
 226 {
 227    return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
 228       (uint8_t *)&ueCb->ueId, (uint16_t)sizeof(ueCb->ueId)));
 229
 230 }  /* rgDBMInsUeCb */
 231
 232 #ifdef LTEMAC_SPS
 233 /**
 234  * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
 235  *
 236  * @details
 237  *
 238  *     Function : rgDBMInsSpsUeCb
 239  *
 240  *
 241  *  @param[in] *cellCb
 242  *  @param[in] *ueCb
 243  *  @return  S16
 244  *      -# ROK
 245  *      -# RFAILED
 246  **/
 247 S16 rgDBMInsSpsUeCb(RgCellCb *cellCb,RgUeCb  *ueCb)
 248 {
 249
 250    return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
 251       (uint8_t *)&ueCb->spsRnti, (uint16_t)sizeof(ueCb->spsRnti)));
 252
 253 }  /* end of rgDBMInsSpsUeCb */
 254
 255 #endif /* LTEMAC_SPS */
 256
 257 /**
 258  * @brief Handler for accessing the existing ueCb identified by the key ueId
 259  * in the ueCbLst under the cellCb.
 260  *
 261  * @details
 262  *
 263  *     Function : rgDBMGetUeCb
 264  *
 265  *
 266  *  @param[in]  *cellCb
 267  *  @param[in]  ueId
 268  *  @return  RgUeCb*
 269  **/
 270 RgUeCb* rgDBMGetUeCb(RgCellCb *cellCb, CmLteRnti ueId)
 271 {
 272    RgUeCb *ueCb = NULLP;
 273
 274    cmHashListFind(&cellCb->ueLst, (uint8_t *)&ueId,
 275       sizeof(ueId), 0, (PTR *)&ueCb);
 276    return (ueCb);
 277 }  /* rgDBMGetUeCb */
 278
 279 #ifdef LTEMAC_SPS
 280 /**
 281  * @brief Handler for accessing the ueCb identified by the key sps-rnti
 282  * in the spsUeLst under the cellCb.
 283  *
 284  * @details
 285  *
 286  *     Function : rgDBMGetSpsUeCb
 287  *
 288  *
 289  *  @param[in]  *cellCb
 290  *  @param[in]  ueId
 291  *  @return  RgUeCb*
 292  **/
 293 RgUeCb* rgDBMGetSpsUeCb(RgCellCb  *cellCb, CmLteRnti spsRnti)
 294 {
 295    RgUeCb *ueCb = NULLP;
 296
 297    cmHashListFind(&cellCb->spsUeLst, (uint8_t *)&spsRnti,
 298       sizeof(spsRnti), 0, (PTR *)&ueCb);
 299    return (ueCb);
 300 }  /* rgDBMGetSpsUeCb */
 301
 302 #endif /* LTEMAC_SPS */
 303
 304 /**
 305  * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
 306  *  cellCb.
 307  *
 308  * @details
 309  *
 310  *     Function : rgDBMGetNextUeCb
 311  *
 312  *
 313  *  @param[in]  *cellCb
 314  *  @param[in]  *ueCb
 315  *  @return  RgUeCb*
 316  **/
 317 RgUeCb* rgDBMGetNextUeCb(RgCellCb *cellCb, RgUeCb *ueCb)
 318 {
 319    RgUeCb *nextUeCb = NULLP;
 320
 321    cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
 322    return (nextUeCb);
 323 }  /* rgDBMGetNextUeCb */
 324
 325 #ifdef LTEMAC_SPS
 326 /**
 327  * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
 328  *         using SPS-Rnti under the cellCb.
 329  *
 330  * @details
 331  *
 332  *     Function : rgDBMGetNextSpsUeCb
 333  *
 334  *
 335  *  @param[in]  *cellCb
 336  *  @param[in]  *ueCb
 337  *  @return  RgUeCb*
 338  **/
 339 RgUeCb* rgDBMGetNextSpsUeCb(RgCellCb *cellCb, RgUeCb *ueCb)
 340 {
 341    RgUeCb *nextUeCb = NULLP;
 342
 343    cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
 344    return (nextUeCb);
 345 }  /* end of rgDBMGetNextSpsUeCb */
 346
 347 #endif /* LTEMAC_SPS */
 348
 349
 350 /**
 351  * @brief Handler for deleting the existing ueCb from the ueCbLst under the
 352  * cellCb.
 353  *
 354  * @details
 355  *
 356  *     Function : rgDBMDelUeCb
 357  *
 358  *
 359  *  @param[in]  *cellCb
 360  *  @param[in]  *ueCb
 361  *  @return  S16
 362  *      -# ROK
 363  *      -# RFAILED
 364  **/
 365 S16 rgDBMDelUeCb(RgCellCb *cellCb, RgUeCb *ueCb)
 366 {
 367    return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
 368 }  /* rgDBMDelUeCb */
 369
 370 #ifdef LTEMAC_SPS
 371 /**
 372  * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
 373  * cellCb.
 374  *
 375  * @details
 376  *
 377  *     Function : rgDBMDelSpsUeCb
 378  *
 379  *
 380  *  @param[in]  *cellCb
 381  *  @param[in]  *ueCb
 382  *  @return  S16
 383  *      -# ROK
 384  *      -# RFAILED
 385  **/
 386 S16 rgDBMDelSpsUeCb(RgCellCb  *cellCb, RgUeCb *ueCb)
 387 {
 388
 389    return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
 390 }  /* end of rgDBMDelSpsUeCb */
 391
 392 #endif /* LTEMAC_SPS */
 393
 394 /**
 395  * @brief Handler for Initializing the UE.
 396  *
 397  * @details
 398  *
 399  *     Function : rgDBMInitUe
 400  *
 401  *   Initializes the lists belonging to the UE.
 402  *
 403  *
 404  *  @param[in]  RgUeCb  *ueCb
 405  *  @return  S16
 406  *      -# ROK
 407  *      -# RFAILED
 408  **/
 409 Void rgDBMInitUe(RgUeCb *ueCb)
 410 {
 411 #ifdef LTEMAC_SPS
 412    uint8_t        idx;
 413 #endif
 414
 415    /* Initialize Dedicated logical channels */
 416    rgDBMInitDedLcLst(ueCb);
 417
 418 #ifdef LTEMAC_SPS
 419    /* Initialize the SPS LC Ids */
 420    for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
 421    {
 422       ueCb->ul.spsLcId[idx] = FALSE;
 423    }
 424 #endif
 425
 426
 427    return;
 428 } /* rgDBMInitUe */
 429
 430 /**
 431  * @brief Handler for Initializing the dedicated logical channels.
 432  *
 433  * @details
 434  *
 435  *     Function : rgDBMInitDedLcLst
 436  *
 437  *   Initializes dedicated logical channels.
 438  *
 439  *  @param[in]  RgUeCb *ueCb
 440  *  @return     Void
 441  **/
 442 static Void rgDBMInitDedLcLst(RgUeCb *ueCb)
 443 {
 444    uint8_t idx;
 445
 446    for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
 447    {
 448       /* Set Dedicated LCs as not configured */
 449       ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
 450       ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
 451       ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
 452    }
 453
 454    for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
 455    {
 456       /* Set LCGs as not configured */
 457       ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
 458       ueCb->ul.lcgArr[idx].lcCount = 0;
 459    }
 460
 461    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 462   return;
 463 } /* rgDBMInitDedLcLst */
 464
 465 /**
 466  * @brief Handler for Initializing the common logical channel list of the cell.
 467  *
 468  * @details
 469  *
 470  *     Function : rgDBMInitCmnLcLst
 471  *
 472  *   Initializes following common logical channels belonging to the cell.
 473  *     - BCCH on BCH
 474  *     - BCCH on DLSCH
 475  *     - PCCH
 476  *
 477  *  @param[in]  RgCellCb *cellCb
 478  *  @return  Void
 479  **/
 480 static Void rgDBMInitCmnLcLst(RgCellCb *cellCb)
 481 {
 482    uint8_t idx;
 483
 484    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
 485    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
 486
 487    cellCb->numBcchDlschInfo = 0;
 488    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
 489    {
 490       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
 491       cellCb->bcchDlschInfo[idx].tb = NULLP;
 492    }
 493
 494    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 495   return;
 496 } /* rgDBMInitCmnLcLst */
 497
 498 /**
 499  * @brief Handler for Initializing the common logical channel list of the cell.
 500  *
 501  * @details
 502  *
 503  *     Function : rgDBMFreeCmnLcLst
 504  *
 505  *   Initializes following common logical channels belonging to the cell.
 506  *     - BCCH on BCH
 507  *     - BCCH on DLSCH
 508  *     - PCCH
 509  *
 510  *  @param[in]  RgCellCb *cellCb
 511  *  @return  Void
 512  **/
 513 Void rgDBMFreeCmnLcLst(RgCellCb *cellCb)
 514 {
 515    uint8_t idx;
 516
 517    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
 518    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
 519
 520    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
 521    {
 522       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
 523       RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
 524    }
 525    cellCb->numBcchDlschInfo = 0;
 526
 527    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 528   return;
 529 } /* rgDBMFreeCmnLcLst */
 530
 531 /**
 532  * @brief Handler for inserting dedicated DL logical channel.
 533  *
 534  * @details
 535  *
 536  *     Function : rgDBMInsDlDedLcCb
 537  *
 538  *  @param[in]  RgUeCb *ueCb
 539  *  @param[in]  RgDlLcCb* dlLcCb
 540  *  @return  Void
 541  **/
 542 Void rgDBMInsDlDedLcCb(RgUeCb  *ueCb, CmLteLcId idx)
 543 {
 544    if( idx >= RG_DEDLC_MIN_LCID )
 545    {
 546       ueCb->dl.lcCb[idx-1].lcId = idx;
 547    }
 548   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 549   return;
 550 }  /* rgDBMInsDlDedLcCb */
 551
 552 /**
 553  * @brief Handler for deleting dedicated DL logical channel.
 554  *
 555  * @details
 556  *
 557  *     Function : rgDBMDelDlDedLcCb
 558  *
 559  *  @param[in]  RgUeCb *ueCb
 560  *  @param[in]  RgDlLcCb* dlLcCb
 561  *  @return  Void
 562  **/
 563 Void rgDBMDelDlDedLcCb(RgUeCb  *ueCb, RgDlLcCb *dlLcCb)
 564 {
 565    ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
 566
 567   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 568   return;
 569
 570 }  /* rgDBMDelDlDedLcCb */
 571
 572 /**
 573  * @brief Handler for accessing the existing DL dedicated lcCb at idx in the
 574  * lcCbLst of the ueCb.
 575  *
 576  * @details
 577  *
 578  *     Function : rgDBMGetDlDedLcCb
 579  *
 580  *  @param[in]  *ueCb
 581  *  @param[in]  idx
 582  *  @return  RgDlLcCb*
 583  **/
 584 RgDlLcCb* rgDBMGetDlDedLcCb(RgUeCb *ueCb, CmLteLcId idx)
 585 {
 586    if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
 587    {
 588       return (NULLP);
 589    }
 590    if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
 591    {
 592       return (NULLP);
 593    }
 594
 595    return (&ueCb->dl.lcCb[idx-1]);
 596
 597 }  /* rgDBMGetDlDedLcCb */
 598
 599 /**
 600  * @brief Handler for inserting dedicated UL logical channel.
 601  *
 602  * @details
 603  *
 604  *     Function : rgDBMInsUlDedLcCb
 605  *
 606  *
 607  *  @param[in]  RgUeCb *ueCb
 608  *  @param[in]  CmLteLcId idx
 609  *  @param[in]  LteLcgId gId
 610  *  @return  Void
 611  **/
 612 #ifdef LTE_L2_MEAS
 613 Void rgDBMInsUlDedLcCb
 614 (
 615 RgUeCb         *ueCb,
 616 CmLteLcId      idx,
 617 LteLcgId       gId,
 618 uint8_t        qci
 619 )
 620 #else
 621 Void rgDBMInsUlDedLcCb
 622 (
 623 RgUeCb         *ueCb,
 624 CmLteLcId      idx,
 625 LteLcgId       gId
 626 )
 627 #endif
 628 {
 629    if ( idx >= RG_DEDLC_MIN_LCID)
 630    {
 631       ueCb->ul.lcCb[idx - 1].lcId = idx;
 632       ueCb->ul.lcCb[idx - 1].lcgId = gId;
 633 #ifdef LTE_L2_MEAS
 634       ueCb->ul.lcCb[idx - 1].qci = qci;
 635 #endif
 636    }
 637    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
 638    {
 639       ueCb->ul.lcgArr[gId].lcgId = gId;
 640    }
 641    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
 642
 643
 644   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 645   return;
 646
 647 }  /* rgDBMInsUlDedLcCb */
 648
 649 /**
 650  * @brief Handler for deleting the dedicated UL logical channel.
 651  *
 652  * @details
 653  *
 654  *     Function : rgDBMUpdUlDedLcCb
 655  *
 656  *
 657  *  @param[in]  RgUeCb *ueCb
 658  *  @param[in]  RgUlLcCb* ulLcCb
 659  *  @param[in]  LteLcgId gId
 660  *  @return  Void
 661  **/
 662 Void rgDBMUpdUlDedLcCb
 663 (
 664 RgUeCb         *ueCb,
 665 RgUlLcCb       *ulLcCb,
 666 LteLcgId       gId
 667 )
 668 {
 669    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
 670                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
 671    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
 672    {
 673       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
 674    }
 675    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
 676
 677    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
 678    {
 679       ueCb->ul.lcgArr[gId].lcgId = gId;
 680    }
 681    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
 682
 683   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 684   return;
 685 }  /* rgDBMUpdUlDedLcCb */
 686
 687 /**
 688  * @brief Handler for updating the dedicated UL logical channel.
 689  *
 690  * @details
 691  *
 692  *     Function : rgDBMDelUlDedLcCb
 693  *
 694  *
 695  *  @param[in]  RgUeCb *ueCb
 696  *  @param[in]  RgUlLcCb* ulLcCb
 697  *  @return  Void
 698  **/
 699 Void rgDBMDelUlDedLcCb(RgUeCb *ueCb, RgUlLcCb *ulLcCb)
 700 {
 701
 702    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
 703                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
 704    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
 705    {
 706       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
 707    }
 708    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
 709    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
 710
 711   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 712   return;
 713 }  /* rgDBMDelUlDedLcCb */
 714
 715 /**
 716  * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
 717  * lcCbLst of the ueCb.
 718  *
 719  * @details
 720  *
 721  *     Function : rgDBMGetUlDedLcCb
 722  *
 723  *
 724  *  @param[in]  *ueCb
 725  *  @param[in]  idx
 726  *  @return  RgUlLcCb*
 727  **/
 728 RgUlLcCb* rgDBMGetUlDedLcCb(RgUeCb *ueCb, CmLteLcId  idx)
 729 {
 730
 731    if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
 732    {
 733       return (NULLP);
 734    }
 735    if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
 736    {
 737       return (NULLP);
 738    }
 739
 740    return (&ueCb->ul.lcCb[idx-1]);
 741 }  /* rgDBMGetDlDedLcCb */
 742
 743 /**
 744  * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
 745  * in the lcCbLst of the ueCb.
 746  *
 747  * @details
 748  *
 749  *     Function : rgDBMChkCmnLcCb
 750  *
 751  *
 752  *  @param[in]  *cellCb
 753  *  @param[in]  lcId
 754  *  @return  S16
 755  *      -# ROK
 756  *      -# RFAILED
 757  **/
 758 S16 rgDBMChkCmnLcCb(RgCellCb *cellCb, CmLteLcId lcId)
 759 {
 760    uint8_t idx;
 761
 762    if(cellCb->bcchBchInfo.lcId == lcId)
 763    {
 764       return ROK;
 765    }
 766    if(cellCb->pcchInfo.lcId == lcId)
 767    {
 768       return ROK;
 769    }
 770
 771    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
 772    {
 773       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
 774       {
 775          return ROK;
 776       }
 777    }
 778    return RFAILED;
 779 }  /* rgDBMChkCmnLcCb */
 780
 781 /**
 782  * @brief Handler for accessing the existing BCCH mapped on to BCH in the
 783  * lcCbLst of the ueCb.
 784  *
 785  * @details
 786  *
 787  *     Function : rgDBMGetBcchOnBch
 788  *
 789  *
 790  *  @param[in]  *cellCb
 791  *  @return  RgBcchBchLcCb*
 792  **/
 793 RgBcchBchLcCb* rgDBMGetBcchOnBch(RgCellCb *cellCb)
 794 {
 795
 796    if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
 797    {
 798       return (&(cellCb->bcchBchInfo));
 799    }
 800    return (NULLP);
 801 }  /* rgDBMGetBcchOnBch */
 802
 803 /**
 804  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
 805  * lcCbLst of the ueCb.
 806  *
 807  * @details
 808  *
 809  *     Function : rgDBMGetBcchOnDlsch
 810  *
 811  *
 812  *  @param[in]  *cellCb
 813  *  @param[in]  lcId
 814  *  @return  RgBcchDlschLcCb*
 815  **/
 816 RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(RgCellCb *cellCb,CmLteLcId lcId)
 817 {
 818    uint8_t idx;
 819
 820    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
 821    {
 822       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
 823       {
 824          return (&(cellCb->bcchDlschInfo[idx]));
 825       }
 826    }
 827    return (NULLP);
 828 }  /* rgDBMGetBcchOnDlsch */
 829
 830 /**
 831  * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
 832  *
 833  * @details
 834  *
 835  *     Function : rgDBMGetPcch
 836  *
 837  *
 838  *  @param[in]  *cellCb
 839  *  @return  RgPcchLcCb*
 840  **/
 841 RgPcchLcCb* rgDBMGetPcch(RgCellCb *cellCb)
 842 {
 843
 844    if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
 845    {
 846       return (&(cellCb->pcchInfo));
 847    }
 848    return (NULLP);
 849 }  /* rgDBMGetPcch */
 850
 851 /**
 852  * @brief Handler for inserting the BCCH mapped on to BCH in the
 853  * lcCbLst of the ueCb.
 854  *
 855  * @details
 856  *
 857  *     Function : rgDBMInsBcchOnBch
 858  *
 859  *
 860  *  @param[in]  *cellCb
 861  *  @return  Void
 862  **/
 863 Void rgDBMInsBcchOnBch(RgCellCb *cellCb, CmLteLcId idx)
 864 {
 865
 866    cellCb->bcchBchInfo.lcId = idx;
 867
 868   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 869   return;
 870 }  /* rgDBMInsBcchOnBch */
 871
 872 /**
 873  * @brief Handler for inserting the BCCH mapped on to DLSCH in the
 874  * lcCbLst of the ueCb.
 875  *
 876  * @details
 877  *
 878  *     Function : rgDBMInsBcchOnDlsch
 879  *
 880  *
 881  *  @param[in]  *cellCb
 882  *  @return  Void
 883  **/
 884 Void rgDBMInsBcchOnDlsch(RgCellCb *cellCb, CmLteLcId idx)
 885 {
 886
 887    cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
 888    cellCb->numBcchDlschInfo++;
 889
 890   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 891   return;
 892 }  /* rgDBMInsBcchOnDlsch */
 893
 894
 895 /**
 896  * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
 897  *
 898  * @details
 899  *
 900  *     Function : rgDBMInsPcch
 901  *
 902  *
 903  *  @param[in]  *cellCb
 904  *  @return  Void
 905  **/
 906 Void rgDBMInsPcch(RgCellCb *cellCb, CmLteLcId idx)
 907 {
 908
 909    cellCb->pcchInfo.lcId = idx;
 910
 911   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 912   return;
 913 }  /* rgDBMInsPcch */
 914
 915 /**
 916  * @brief Handler for initializing the rachLst
 917  *
 918  * @details
 919  *
 920  *     Function : rgDBMInitRachLst
 921  *
 922  *
 923  *  @param[in] *cellCb
 924  *  @return  Void
 925  **/
 926 static Void rgDBMInitRachLst(RgCellCb *cellCb)
 927 {
 928
 929    cmLListInit(&cellCb->raInfo.ueRachLst);
 930    return;
 931 }  /* rgDBMInitRachLst */
 932
 933 /**
 934  * @brief Handler for inserting the ueCb in the rachLst.
 935  *
 936  * @details
 937  *
 938  *     Function : rgDBMInsUeCbInRachLst
 939  *
 940  *
 941  *  @param[in]  *cellCb
 942  *  @param[in]  *ueCb
 943  *  @return  Void
 944  **/
 945 Void rgDBMInsUeCbInRachLst(RgCellCb *cellCb, RgUeCb *ueCb)
 946 {
 947
 948    cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
 949
 950    return;
 951 }  /* rgDBMInsUeCbInRachLst */
 952
 953 /**
 954  * @brief Handler for accessing the existing raCb in the rachLst.
 955  *
 956  * @details
 957  *
 958  *     Function : rgDBMGetUeCbFromRachLst
 959  *
 960  *
 961  *  @param[in]  *cellCb
 962  *  @param[in]  key
 963  *  @return  RgUeCb*
 964  **/
 965 RgUeCb* rgDBMGetUeCbFromRachLst(RgCellCb *cellCb, CmLteRnti key)
 966 {
 967    CmLList *tmpNode;
 968
 969    CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
 970    while(tmpNode)
 971    {
 972       if(((RgUeCb *)tmpNode->node)->ueId == key)
 973       {
 974          return ((RgUeCb *)(tmpNode->node));
 975       }
 976       CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
 977    }
 978    return (NULLP);
 979 }  /* rgDBMGetUeCbFromRachLst */
 980
 981 /**
 982  * @brief Handler for accessing the existing ueCb from rachLst.
 983  *
 984  * @details
 985  *
 986  *     Function : rgDBMGetNextUeCbFromRachLst
 987  *
 988  *
 989  *  @param[in]  *cellCb
 990  *  @param[in]  *ueCb
 991  *  @return  RgUeCb*
 992  **/
 993 RgUeCb* rgDBMGetNextUeCbFromRachLst(RgCellCb *cellCb,RgUeCb *ueCb)
 994 {
 995
 996    if(!ueCb)
 997    {
 998       return ( cellCb->raInfo.ueRachLst.first ?
 999                (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1000    }
1001    return ( ueCb->rachLstEnt.next ?
1002                (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1003 }  /* rgDBMGetNextUeCbFromRachLst */
1004
1005 /**
1006  * @brief Handler for deleting the existing ueCb in the rachLst.
1007  *
1008  * @details
1009  *
1010  *     Function : rgDBMDelUeCbFromRachLst
1011  *
1012  *
1013  *  @param[in]  *cellCb
1014  *  @param[in]  key
1015  *  @return  RgUeCb*
1016  **/
1017 Void rgDBMDelUeCbFromRachLst(RgCellCb *cellCb, RgUeCb *ueCb)
1018 {
1019
1020    cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1021    return;
1022 }  /* rgDBMDelUeCbFromRachLst */
1023
1024 /**********************************************************************
1025
1026          End of file
1027 **********************************************************************/