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 PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, U16 numBins));
  57 PRIVATE Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
  58 PRIVATE Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
  59 PRIVATE Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
  60 #ifdef LTEMAC_SPS
  61 PRIVATE S16 rgDBMInitSpsUeCbLst ARGS((
  62 RgCellCb       *cellCb,
  63 U16            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 #ifdef ANSI
  89 S16 rgDBMInitCell
  90 (
  91 RgCellCb       *cellCb
  92 )
  93 #else
  94 S16 rgDBMInitCell(cellCb)
  95 RgCellCb       *cellCb;
  96 #endif
  97 {
  98    S16 ret;
  99
 100    /* Initialize ue list */
 101    if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
 102       return (ret);
 103
 104 #ifdef LTEMAC_SPS
 105    /* Initialize SPS Ue list */
 106    if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
 107       return (ret);
 108 #endif /* LTEMAC_SPS */
 109
 110    /* Initialize BCCH/PCCH logical channels */
 111    rgDBMInitCmnLcLst(cellCb);
 112
 113
 114    /* Initialize rach ue list */
 115    rgDBMInitRachLst(cellCb);
 116
 117    return (ret);
 118
 119 } /* rgDBMInitCell */
 120
 121 /**
 122  * @brief Handler for initializing the ueCbLst under the cellCb.
 123  *
 124  * @details
 125  *
 126  *     Function : rgDBMInitUeCbLst
 127  *
 128  *
 129  *  @param[in] *cellCb
 130  *  @param[in] numBins
 131  *  @return  S16
 132  *      -# ROK
 133  *      -# RFAILED
 134  **/
 135 #ifdef ANSI
 136 PRIVATE S16 rgDBMInitUeCbLst
 137 (
 138 RgCellCb       *cellCb,
 139 U16            numBins
 140 )
 141 #else
 142 PRIVATE S16 rgDBMInitUeCbLst(cellCb, numBins)
 143 RgCellCb       *cellCb;
 144 U16            numBins;
 145 #endif
 146 {
 147    Inst inst = cellCb->macInst - RG_INST_START;
 148    RgUeCb ue;
 149
 150    return (cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
 151                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
 152
 153 }  /* rgDBMInitUeCbLst */
 154
 155 /**
 156  * @brief Handler for de-initializing the ueCbLst under the cellCb.
 157  *
 158  * @details
 159  *
 160  *     Function : rgDBMDeInitUeCbLst
 161  *
 162  *
 163  *  @param[in] *cellCb
 164  *  @return  S16
 165  *      -# ROK
 166  *      -# RFAILED
 167  **/
 168 #ifdef ANSI
 169 S16 rgDBMDeInitUeCbLst
 170 (
 171 RgCellCb       *cellCb
 172 )
 173 #else
 174 S16 rgDBMDeInitUeCbLst(cellCb)
 175 RgCellCb       *cellCb;
 176 #endif
 177 {
 178
 179    return (cmHashListDeinit(&cellCb->ueLst));
 180
 181 }  /* rgDBMDeInitUeCbLst */
 182
 183 #ifdef LTEMAC_SPS
 184 /**
 185  * @brief Handler for initializing the spsUeCbLst under the cellCb.
 186  *
 187  * @details
 188  *
 189  *     Function : rgDBMInitSpsUeCbLst
 190  *
 191  *
 192  *  @param[in] *cellCb
 193  *  @param[in] numBins
 194  *  @return  S16
 195  *      -# ROK
 196  *      -# RFAILED
 197  **/
 198 #ifdef ANSI
 199 PRIVATE S16 rgDBMInitSpsUeCbLst
 200 (
 201 RgCellCb       *cellCb,
 202 U16            numBins
 203 )
 204 #else
 205 PRIVATE S16 rgDBMInitSpsUeCbLst(cellCb, numBins)
 206 RgCellCb       *cellCb;
 207 U16            numBins;
 208 #endif
 209 {
 210    Inst inst = cellCb->macInst - RG_INST_START;
 211    RgUeCb ue;
 212
 213    return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
 214                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
 215
 216 }  /* rgDBMInitSpsUeCbLst */
 217
 218 /**
 219  * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
 220  *
 221  * @details
 222  *
 223  *     Function : rgDBMDeInitSpsUeCbLst
 224  *
 225  *
 226  *  @param[in] *cellCb
 227  *  @return  S16
 228  *      -# ROK
 229  *      -# RFAILED
 230  **/
 231 #ifdef ANSI
 232 S16 rgDBMDeInitSpsUeCbLst
 233 (
 234 RgCellCb       *cellCb
 235 )
 236 #else
 237 S16 rgDBMDeInitSpsUeCbLst(cellCb)
 238 RgCellCb       *cellCb;
 239 #endif
 240 {
 241
 242    return (cmHashListDeinit(&cellCb->spsUeLst));
 243
 244 }  /* rgDBMDeInitSpsUeCbLst */
 245
 246 #endif /* LTEMAC_SPS */
 247
 248 /**
 249  * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
 250  *
 251  * @details
 252  *
 253  *     Function : rgDBMInsUeCb
 254  *
 255  *
 256  *  @param[in] *cellCb
 257  *  @param[in] *ueCb
 258  *  @return  S16
 259  *      -# ROK
 260  *      -# RFAILED
 261  **/
 262 #ifdef ANSI
 263 S16 rgDBMInsUeCb
 264 (
 265 RgCellCb       *cellCb,
 266 RgUeCb         *ueCb
 267 )
 268 #else
 269 S16 rgDBMInsUeCb(cellCb, ueCb)
 270 RgCellCb       *cellCb;
 271 RgUeCb         *ueCb;
 272 #endif
 273 {
 274    return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
 275       (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
 276
 277 }  /* rgDBMInsUeCb */
 278
 279 #ifdef LTEMAC_SPS
 280 /**
 281  * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
 282  *
 283  * @details
 284  *
 285  *     Function : rgDBMInsSpsUeCb
 286  *
 287  *
 288  *  @param[in] *cellCb
 289  *  @param[in] *ueCb
 290  *  @return  S16
 291  *      -# ROK
 292  *      -# RFAILED
 293  **/
 294 #ifdef ANSI
 295 S16 rgDBMInsSpsUeCb
 296 (
 297 RgCellCb       *cellCb,
 298 RgUeCb         *ueCb
 299 )
 300 #else
 301 S16 rgDBMInsSpsUeCb(cellCb, ueCb)
 302 RgCellCb       *cellCb;
 303 RgUeCb         *ueCb;
 304 #endif
 305 {
 306
 307    return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
 308       (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
 309
 310 }  /* end of rgDBMInsSpsUeCb */
 311
 312 #endif /* LTEMAC_SPS */
 313
 314 /**
 315  * @brief Handler for accessing the existing ueCb identified by the key ueId
 316  * in the ueCbLst under the cellCb.
 317  *
 318  * @details
 319  *
 320  *     Function : rgDBMGetUeCb
 321  *
 322  *
 323  *  @param[in]  *cellCb
 324  *  @param[in]  ueId
 325  *  @return  RgUeCb*
 326  **/
 327 #ifdef ANSI
 328 RgUeCb* rgDBMGetUeCb
 329 (
 330 RgCellCb       *cellCb,
 331 CmLteRnti      ueId
 332 )
 333 #else
 334 RgUeCb* rgDBMGetUeCb(cellCb, ueId)
 335 RgCellCb       *cellCb;
 336 CmLteRnti      ueId;
 337 #endif
 338 {
 339    RgUeCb *ueCb = NULLP;
 340
 341    cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
 342       sizeof(ueId), 0, (PTR *)&ueCb);
 343    return (ueCb);
 344 }  /* rgDBMGetUeCb */
 345
 346 #ifdef LTEMAC_SPS
 347 /**
 348  * @brief Handler for accessing the ueCb identified by the key sps-rnti
 349  * in the spsUeLst under the cellCb.
 350  *
 351  * @details
 352  *
 353  *     Function : rgDBMGetSpsUeCb
 354  *
 355  *
 356  *  @param[in]  *cellCb
 357  *  @param[in]  ueId
 358  *  @return  RgUeCb*
 359  **/
 360 #ifdef ANSI
 361 RgUeCb* rgDBMGetSpsUeCb
 362 (
 363 RgCellCb       *cellCb,
 364 CmLteRnti      spsRnti
 365 )
 366 #else
 367 RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
 368 RgCellCb       *cellCb;
 369 CmLteRnti      spsRnti;
 370 #endif
 371 {
 372    RgUeCb *ueCb = NULLP;
 373
 374    cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
 375       sizeof(spsRnti), 0, (PTR *)&ueCb);
 376    return (ueCb);
 377 }  /* rgDBMGetSpsUeCb */
 378
 379 #endif /* LTEMAC_SPS */
 380
 381 /**
 382  * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
 383  *  cellCb.
 384  *
 385  * @details
 386  *
 387  *     Function : rgDBMGetNextUeCb
 388  *
 389  *
 390  *  @param[in]  *cellCb
 391  *  @param[in]  *ueCb
 392  *  @return  RgUeCb*
 393  **/
 394 #ifdef ANSI
 395 RgUeCb* rgDBMGetNextUeCb
 396 (
 397 RgCellCb       *cellCb,
 398 RgUeCb         *ueCb
 399 )
 400 #else
 401 RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
 402 RgCellCb       *cellCb;
 403 RgUeCb         *ueCb;
 404 #endif
 405 {
 406    RgUeCb *nextUeCb = NULLP;
 407
 408    cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
 409    return (nextUeCb);
 410 }  /* rgDBMGetNextUeCb */
 411
 412 #ifdef LTEMAC_SPS
 413 /**
 414  * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
 415  *         using SPS-Rnti under the cellCb.
 416  *
 417  * @details
 418  *
 419  *     Function : rgDBMGetNextSpsUeCb
 420  *
 421  *
 422  *  @param[in]  *cellCb
 423  *  @param[in]  *ueCb
 424  *  @return  RgUeCb*
 425  **/
 426 #ifdef ANSI
 427 RgUeCb* rgDBMGetNextSpsUeCb
 428 (
 429 RgCellCb       *cellCb,
 430 RgUeCb         *ueCb
 431 )
 432 #else
 433 RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
 434 RgCellCb       *cellCb;
 435 RgUeCb         *ueCb;
 436 #endif
 437 {
 438    RgUeCb *nextUeCb = NULLP;
 439
 440    cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
 441    return (nextUeCb);
 442 }  /* end of rgDBMGetNextSpsUeCb */
 443
 444 #endif /* LTEMAC_SPS */
 445
 446
 447 /**
 448  * @brief Handler for deleting the existing ueCb from the ueCbLst under the
 449  * cellCb.
 450  *
 451  * @details
 452  *
 453  *     Function : rgDBMDelUeCb
 454  *
 455  *
 456  *  @param[in]  *cellCb
 457  *  @param[in]  *ueCb
 458  *  @return  S16
 459  *      -# ROK
 460  *      -# RFAILED
 461  **/
 462 #ifdef ANSI
 463 S16 rgDBMDelUeCb
 464 (
 465 RgCellCb       *cellCb,
 466 RgUeCb         *ueCb
 467 )
 468 #else
 469 S16 rgDBMDelUeCb(cellCb, ueCb)
 470 RgCellCb       *cellCb;
 471 RgUeCb         *ueCb;
 472 #endif
 473 {
 474    return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
 475 }  /* rgDBMDelUeCb */
 476
 477 #ifdef LTEMAC_SPS
 478 /**
 479  * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
 480  * cellCb.
 481  *
 482  * @details
 483  *
 484  *     Function : rgDBMDelSpsUeCb
 485  *
 486  *
 487  *  @param[in]  *cellCb
 488  *  @param[in]  *ueCb
 489  *  @return  S16
 490  *      -# ROK
 491  *      -# RFAILED
 492  **/
 493 #ifdef ANSI
 494 S16 rgDBMDelSpsUeCb
 495 (
 496 RgCellCb       *cellCb,
 497 RgUeCb         *ueCb
 498 )
 499 #else
 500 S16 rgDBMDelSpsUeCb(cellCb, ueCb)
 501 RgCellCb       *cellCb;
 502 RgUeCb         *ueCb;
 503 #endif
 504 {
 505
 506    return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
 507 }  /* end of rgDBMDelSpsUeCb */
 508
 509 #endif /* LTEMAC_SPS */
 510
 511 /**
 512  * @brief Handler for Initializing the UE.
 513  *
 514  * @details
 515  *
 516  *     Function : rgDBMInitUe
 517  *
 518  *   Initializes the lists belonging to the UE.
 519  *
 520  *
 521  *  @param[in]  RgUeCb  *ueCb
 522  *  @return  S16
 523  *      -# ROK
 524  *      -# RFAILED
 525  **/
 526 #ifdef ANSI
 527 Void rgDBMInitUe
 528 (
 529 RgUeCb       *ueCb
 530 )
 531 #else
 532 Void rgDBMInitUe(ueCb)
 533 RgUeCb       *ueCb;
 534 #endif
 535 {
 536 #ifdef LTEMAC_SPS
 537    U8        idx;
 538 #endif
 539
 540    /* Initialize Dedicated logical channels */
 541    rgDBMInitDedLcLst(ueCb);
 542
 543 #ifdef LTEMAC_SPS
 544    /* Initialize the SPS LC Ids */
 545    for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
 546    {
 547       ueCb->ul.spsLcId[idx] = FALSE;
 548    }
 549 #endif
 550
 551
 552    RETVOID;
 553 } /* rgDBMInitUe */
 554
 555 /**
 556  * @brief Handler for Initializing the dedicated logical channels.
 557  *
 558  * @details
 559  *
 560  *     Function : rgDBMInitDedLcLst
 561  *
 562  *   Initializes dedicated logical channels.
 563  *
 564  *  @param[in]  RgUeCb *ueCb
 565  *  @return     Void
 566  **/
 567 #ifdef ANSI
 568 PRIVATE Void rgDBMInitDedLcLst
 569 (
 570 RgUeCb       *ueCb
 571 )
 572 #else
 573 PRIVATE Void rgDBMInitDedLcLst(ueCb)
 574 RgUeCb       *ueCb;
 575 #endif
 576 {
 577    U8 idx;
 578
 579    for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
 580    {
 581       /* Set Dedicated LCs as not configured */
 582       ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
 583       ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
 584       ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
 585    }
 586
 587    for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
 588    {
 589       /* Set LCGs as not configured */
 590       ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
 591       ueCb->ul.lcgArr[idx].lcCount = 0;
 592    }
 593
 594    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 595   RETVOID;
 596 } /* rgDBMInitDedLcLst */
 597
 598 /**
 599  * @brief Handler for Initializing the common logical channel list of the cell.
 600  *
 601  * @details
 602  *
 603  *     Function : rgDBMInitCmnLcLst
 604  *
 605  *   Initializes following common logical channels belonging to the cell.
 606  *     - BCCH on BCH
 607  *     - BCCH on DLSCH
 608  *     - PCCH
 609  *
 610  *  @param[in]  RgCellCb *cellCb
 611  *  @return  Void
 612  **/
 613 #ifdef ANSI
 614 PRIVATE Void rgDBMInitCmnLcLst
 615 (
 616 RgCellCb       *cellCb
 617 )
 618 #else
 619 PRIVATE Void rgDBMInitCmnLcLst(cellCb)
 620 RgCellCb       *cellCb;
 621 #endif
 622 {
 623    U8 idx;
 624
 625    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
 626    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
 627
 628    cellCb->numBcchDlschInfo = 0;
 629    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
 630    {
 631       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
 632       cellCb->bcchDlschInfo[idx].tb = NULLP;
 633    }
 634
 635    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 636   RETVOID;
 637 } /* rgDBMInitCmnLcLst */
 638
 639 /**
 640  * @brief Handler for Initializing the common logical channel list of the cell.
 641  *
 642  * @details
 643  *
 644  *     Function : rgDBMFreeCmnLcLst
 645  *
 646  *   Initializes following common logical channels belonging to the cell.
 647  *     - BCCH on BCH
 648  *     - BCCH on DLSCH
 649  *     - PCCH
 650  *
 651  *  @param[in]  RgCellCb *cellCb
 652  *  @return  Void
 653  **/
 654 #ifdef ANSI
 655 Void rgDBMFreeCmnLcLst
 656 (
 657 RgCellCb       *cellCb
 658 )
 659 #else
 660 Void rgDBMFreeCmnLcLst(cellCb)
 661 RgCellCb       *cellCb;
 662 #endif
 663 {
 664    U8 idx;
 665
 666    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
 667    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
 668
 669    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
 670    {
 671       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
 672       RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
 673    }
 674    cellCb->numBcchDlschInfo = 0;
 675
 676    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 677   RETVOID;
 678 } /* rgDBMFreeCmnLcLst */
 679
 680 /**
 681  * @brief Handler for inserting dedicated DL logical channel.
 682  *
 683  * @details
 684  *
 685  *     Function : rgDBMInsDlDedLcCb
 686  *
 687  *  @param[in]  RgUeCb *ueCb
 688  *  @param[in]  RgDlLcCb* dlLcCb
 689  *  @return  Void
 690  **/
 691 #ifdef ANSI
 692 Void rgDBMInsDlDedLcCb
 693 (
 694 RgUeCb         *ueCb,
 695 CmLteLcId        idx
 696 )
 697 #else
 698 Void rgDBMInsDlDedLcCb(ueCb, idx)
 699 RgUeCb         *ueCb;
 700 CmLteLcId        idx;
 701 #endif
 702 {
 703    if( idx >= RG_DEDLC_MIN_LCID )
 704    {
 705       ueCb->dl.lcCb[idx-1].lcId = idx;
 706    }
 707   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 708   RETVOID;
 709 }  /* rgDBMInsDlDedLcCb */
 710
 711 /**
 712  * @brief Handler for deleting dedicated DL logical channel.
 713  *
 714  * @details
 715  *
 716  *     Function : rgDBMDelDlDedLcCb
 717  *
 718  *  @param[in]  RgUeCb *ueCb
 719  *  @param[in]  RgDlLcCb* dlLcCb
 720  *  @return  Void
 721  **/
 722 #ifdef ANSI
 723 Void rgDBMDelDlDedLcCb
 724 (
 725 RgUeCb         *ueCb,
 726 RgDlLcCb       *dlLcCb
 727 )
 728 #else
 729 Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
 730 RgUeCb         *ueCb;
 731 RgDlLcCb       *dlLcCb;
 732 #endif
 733 {
 734    ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
 735
 736   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 737   RETVOID;
 738
 739 }  /* rgDBMDelDlDedLcCb */
 740
 741 /**
 742  * @brief Handler for accessing the existing DL dedicated lcCb at idx in the
 743  * lcCbLst of the ueCb.
 744  *
 745  * @details
 746  *
 747  *     Function : rgDBMGetDlDedLcCb
 748  *
 749  *  @param[in]  *ueCb
 750  *  @param[in]  idx
 751  *  @return  RgDlLcCb*
 752  **/
 753 #ifdef ANSI
 754 RgDlLcCb* rgDBMGetDlDedLcCb
 755 (
 756 RgUeCb         *ueCb,
 757 CmLteLcId        idx
 758 )
 759 #else
 760 RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
 761 RgUeCb         *ueCb;
 762 CmLteLcId        idx;
 763 #endif
 764 {
 765    if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
 766    {
 767       return (NULLP);
 768    }
 769    if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
 770    {
 771       return (NULLP);
 772    }
 773
 774    return (&ueCb->dl.lcCb[idx-1]);
 775
 776 }  /* rgDBMGetDlDedLcCb */
 777
 778 /**
 779  * @brief Handler for inserting dedicated UL logical channel.
 780  *
 781  * @details
 782  *
 783  *     Function : rgDBMInsUlDedLcCb
 784  *
 785  *
 786  *  @param[in]  RgUeCb *ueCb
 787  *  @param[in]  CmLteLcId idx
 788  *  @param[in]  LteLcgId gId
 789  *  @return  Void
 790  **/
 791 #ifdef LTE_L2_MEAS
 792 #ifdef ANSI
 793 Void rgDBMInsUlDedLcCb
 794 (
 795 RgUeCb         *ueCb,
 796 CmLteLcId      idx,
 797 LteLcgId       gId,
 798 U8             qci
 799 )
 800 #else
 801 Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
 802 RgUeCb         *ueCb;
 803 CmLteLcId      idx;
 804 LteLcgId       gId;
 805 U8             qci;
 806 #endif
 807 #else
 808 #ifdef ANSI
 809 Void rgDBMInsUlDedLcCb
 810 (
 811 RgUeCb         *ueCb,
 812 CmLteLcId      idx,
 813 LteLcgId       gId
 814 )
 815 #else
 816 Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
 817 RgUeCb         *ueCb;
 818 CmLteLcId      idx;
 819 LteLcgId       gId;
 820 #endif
 821 #endif
 822 {
 823    if ( idx >= RG_DEDLC_MIN_LCID)
 824    {
 825       ueCb->ul.lcCb[idx - 1].lcId = idx;
 826       ueCb->ul.lcCb[idx - 1].lcgId = gId;
 827 #ifdef LTE_L2_MEAS
 828       ueCb->ul.lcCb[idx - 1].qci = qci;
 829 #endif
 830    }
 831    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
 832    {
 833       ueCb->ul.lcgArr[gId].lcgId = gId;
 834    }
 835    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
 836
 837
 838   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 839   RETVOID;
 840
 841 }  /* rgDBMInsUlDedLcCb */
 842
 843 /**
 844  * @brief Handler for deleting the dedicated UL logical channel.
 845  *
 846  * @details
 847  *
 848  *     Function : rgDBMUpdUlDedLcCb
 849  *
 850  *
 851  *  @param[in]  RgUeCb *ueCb
 852  *  @param[in]  RgUlLcCb* ulLcCb
 853  *  @param[in]  LteLcgId gId
 854  *  @return  Void
 855  **/
 856 #ifdef ANSI
 857 Void rgDBMUpdUlDedLcCb
 858 (
 859 RgUeCb         *ueCb,
 860 RgUlLcCb       *ulLcCb,
 861 LteLcgId       gId
 862 )
 863 #else
 864 Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
 865 RgUeCb         *ueCb;
 866 RgUlLcCb       *ulLcCb;
 867 LteLcgId       gId;
 868 #endif
 869 {
 870    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
 871                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
 872    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
 873    {
 874       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
 875    }
 876    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
 877
 878    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
 879    {
 880       ueCb->ul.lcgArr[gId].lcgId = gId;
 881    }
 882    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
 883
 884   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 885   RETVOID;
 886 }  /* rgDBMUpdUlDedLcCb */
 887
 888 /**
 889  * @brief Handler for updating the dedicated UL logical channel.
 890  *
 891  * @details
 892  *
 893  *     Function : rgDBMDelUlDedLcCb
 894  *
 895  *
 896  *  @param[in]  RgUeCb *ueCb
 897  *  @param[in]  RgUlLcCb* ulLcCb
 898  *  @return  Void
 899  **/
 900 #ifdef ANSI
 901 Void rgDBMDelUlDedLcCb
 902 (
 903 RgUeCb         *ueCb,
 904 RgUlLcCb       *ulLcCb
 905 )
 906 #else
 907 Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
 908 RgUeCb         *ueCb;
 909 RgUlLcCb       *ulLcCb;
 910 #endif
 911 {
 912
 913    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
 914                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
 915    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
 916    {
 917       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
 918    }
 919    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
 920    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
 921
 922   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 923   RETVOID;
 924 }  /* rgDBMDelUlDedLcCb */
 925
 926 /**
 927  * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
 928  * lcCbLst of the ueCb.
 929  *
 930  * @details
 931  *
 932  *     Function : rgDBMGetUlDedLcCb
 933  *
 934  *
 935  *  @param[in]  *ueCb
 936  *  @param[in]  idx
 937  *  @return  RgUlLcCb*
 938  **/
 939 #ifdef ANSI
 940 RgUlLcCb* rgDBMGetUlDedLcCb
 941 (
 942 RgUeCb         *ueCb,
 943 CmLteLcId        idx
 944 )
 945 #else
 946 RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
 947 RgUeCb         *ueCb;
 948 CmLteLcId        idx;
 949 #endif
 950 {
 951
 952    if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
 953    {
 954       return (NULLP);
 955    }
 956    if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
 957    {
 958       return (NULLP);
 959    }
 960
 961    return (&ueCb->ul.lcCb[idx-1]);
 962 }  /* rgDBMGetDlDedLcCb */
 963
 964 /**
 965  * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
 966  * in the lcCbLst of the ueCb.
 967  *
 968  * @details
 969  *
 970  *     Function : rgDBMChkCmnLcCb
 971  *
 972  *
 973  *  @param[in]  *cellCb
 974  *  @param[in]  lcId
 975  *  @return  S16
 976  *      -# ROK
 977  *      -# RFAILED
 978  **/
 979 #ifdef ANSI
 980 S16 rgDBMChkCmnLcCb
 981 (
 982 RgCellCb       *cellCb,
 983 CmLteLcId        lcId
 984 )
 985 #else
 986 S16 rgDBMChkCmnLcCb(cellCb, lcId)
 987 RgCellCb       *cellCb;
 988 CmLteLcId        lcId;
 989 #endif
 990 {
 991    U8 idx;
 992
 993    if(cellCb->bcchBchInfo.lcId == lcId)
 994    {
 995       return ROK;
 996    }
 997    if(cellCb->pcchInfo.lcId == lcId)
 998    {
 999       return ROK;
1000    }
1001
1002    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
1003    {
1004       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1005       {
1006          return ROK;
1007       }
1008    }
1009    return RFAILED;
1010 }  /* rgDBMChkCmnLcCb */
1011
1012 /**
1013  * @brief Handler for accessing the existing BCCH mapped on to BCH in the
1014  * lcCbLst of the ueCb.
1015  *
1016  * @details
1017  *
1018  *     Function : rgDBMGetBcchOnBch
1019  *
1020  *
1021  *  @param[in]  *cellCb
1022  *  @return  RgBcchBchLcCb*
1023  **/
1024 #ifdef ANSI
1025 RgBcchBchLcCb* rgDBMGetBcchOnBch
1026 (
1027 RgCellCb       *cellCb
1028 )
1029 #else
1030 RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
1031 RgCellCb       *cellCb;
1032 #endif
1033 {
1034
1035    if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
1036    {
1037       return (&(cellCb->bcchBchInfo));
1038    }
1039    return (NULLP);
1040 }  /* rgDBMGetBcchOnBch */
1041
1042 /**
1043  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
1044  * lcCbLst of the ueCb.
1045  *
1046  * @details
1047  *
1048  *     Function : rgDBMGetBcchOnDlsch
1049  *
1050  *
1051  *  @param[in]  *cellCb
1052  *  @param[in]  lcId
1053  *  @return  RgBcchDlschLcCb*
1054  **/
1055 #ifdef ANSI
1056 RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
1057 (
1058 RgCellCb       *cellCb,
1059 CmLteLcId      lcId
1060 )
1061 #else
1062 RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
1063 RgCellCb       *cellCb;
1064 CmLteLcId      lcId;
1065 #endif
1066 {
1067    U8 idx;
1068
1069    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
1070    {
1071       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1072       {
1073          return (&(cellCb->bcchDlschInfo[idx]));
1074       }
1075    }
1076    return (NULLP);
1077 }  /* rgDBMGetBcchOnDlsch */
1078
1079 /**
1080  * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
1081  *
1082  * @details
1083  *
1084  *     Function : rgDBMGetPcch
1085  *
1086  *
1087  *  @param[in]  *cellCb
1088  *  @return  RgPcchLcCb*
1089  **/
1090 #ifdef ANSI
1091 RgPcchLcCb* rgDBMGetPcch
1092 (
1093 RgCellCb       *cellCb
1094 )
1095 #else
1096 RgPcchLcCb* rgDBMGetPcch(cellCb)
1097 RgCellCb       *cellCb;
1098 #endif
1099 {
1100
1101    if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
1102    {
1103       return (&(cellCb->pcchInfo));
1104    }
1105    return (NULLP);
1106 }  /* rgDBMGetPcch */
1107
1108 /**
1109  * @brief Handler for inserting the BCCH mapped on to BCH in the
1110  * lcCbLst of the ueCb.
1111  *
1112  * @details
1113  *
1114  *     Function : rgDBMInsBcchOnBch
1115  *
1116  *
1117  *  @param[in]  *cellCb
1118  *  @return  Void
1119  **/
1120 #ifdef ANSI
1121 Void rgDBMInsBcchOnBch
1122 (
1123 RgCellCb       *cellCb,
1124 CmLteLcId      idx
1125 )
1126 #else
1127 Void rgDBMInsBcchOnBch(cellCb, idx)
1128 RgCellCb       *cellCb;
1129 CmLteLcId      idx;
1130 #endif
1131 {
1132
1133    cellCb->bcchBchInfo.lcId = idx;
1134
1135   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1136   RETVOID;
1137 }  /* rgDBMInsBcchOnBch */
1138
1139 /**
1140  * @brief Handler for inserting the BCCH mapped on to DLSCH in the
1141  * lcCbLst of the ueCb.
1142  *
1143  * @details
1144  *
1145  *     Function : rgDBMInsBcchOnDlsch
1146  *
1147  *
1148  *  @param[in]  *cellCb
1149  *  @return  Void
1150  **/
1151 #ifdef ANSI
1152 Void rgDBMInsBcchOnDlsch
1153 (
1154 RgCellCb       *cellCb,
1155 CmLteLcId      idx
1156 )
1157 #else
1158 Void rgDBMInsBcchOnDlsch(cellCb, idx)
1159 RgCellCb       *cellCb;
1160 CmLteLcId      idx;
1161 #endif
1162 {
1163
1164    cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
1165    cellCb->numBcchDlschInfo++;
1166
1167   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1168   RETVOID;
1169 }  /* rgDBMInsBcchOnDlsch */
1170
1171
1172 /**
1173  * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
1174  *
1175  * @details
1176  *
1177  *     Function : rgDBMInsPcch
1178  *
1179  *
1180  *  @param[in]  *cellCb
1181  *  @return  Void
1182  **/
1183 #ifdef ANSI
1184 Void rgDBMInsPcch
1185 (
1186 RgCellCb       *cellCb,
1187 CmLteLcId      idx
1188 )
1189 #else
1190 Void rgDBMInsPcch(cellCb, idx)
1191 RgCellCb       *cellCb;
1192 CmLteLcId      idx;
1193 #endif
1194 {
1195
1196    cellCb->pcchInfo.lcId = idx;
1197
1198   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1199   RETVOID;
1200 }  /* rgDBMInsPcch */
1201
1202 /**
1203  * @brief Handler for initializing the rachLst
1204  *
1205  * @details
1206  *
1207  *     Function : rgDBMInitRachLst
1208  *
1209  *
1210  *  @param[in] *cellCb
1211  *  @return  Void
1212  **/
1213 #ifdef ANSI
1214 PRIVATE Void rgDBMInitRachLst
1215 (
1216 RgCellCb       *cellCb
1217 )
1218 #else
1219 PRIVATE Void rgDBMInitRachLst(cellCb)
1220 RgCellCb       *cellCb;
1221 #endif
1222 {
1223
1224    cmLListInit(&cellCb->raInfo.ueRachLst);
1225    RETVOID;
1226 }  /* rgDBMInitRachLst */
1227
1228 /**
1229  * @brief Handler for inserting the ueCb in the rachLst.
1230  *
1231  * @details
1232  *
1233  *     Function : rgDBMInsUeCbInRachLst
1234  *
1235  *
1236  *  @param[in]  *cellCb
1237  *  @param[in]  *ueCb
1238  *  @return  Void
1239  **/
1240 #ifdef ANSI
1241 Void rgDBMInsUeCbInRachLst
1242 (
1243 RgCellCb       *cellCb,
1244 RgUeCb         *ueCb
1245 )
1246 #else
1247 Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
1248 RgCellCb       *cellCb;
1249 RgUeCb         *ueCb;
1250 #endif
1251 {
1252
1253    cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
1254
1255    RETVOID;
1256 }  /* rgDBMInsUeCbInRachLst */
1257
1258 /**
1259  * @brief Handler for accessing the existing raCb in the rachLst.
1260  *
1261  * @details
1262  *
1263  *     Function : rgDBMGetUeCbFromRachLst
1264  *
1265  *
1266  *  @param[in]  *cellCb
1267  *  @param[in]  key
1268  *  @return  RgUeCb*
1269  **/
1270 #ifdef ANSI
1271 RgUeCb* rgDBMGetUeCbFromRachLst
1272 (
1273 RgCellCb       *cellCb,
1274 CmLteRnti      key
1275 )
1276 #else
1277 RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
1278 RgCellCb       *cellCb;
1279 CmLteRnti      key;
1280 #endif
1281 {
1282    CmLList *tmpNode;
1283
1284    CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1285    while(tmpNode)
1286    {
1287       if(((RgUeCb *)tmpNode->node)->ueId == key)
1288       {
1289          return ((RgUeCb *)(tmpNode->node));
1290       }
1291       CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1292    }
1293    return (NULLP);
1294 }  /* rgDBMGetUeCbFromRachLst */
1295
1296 /**
1297  * @brief Handler for accessing the existing ueCb from rachLst.
1298  *
1299  * @details
1300  *
1301  *     Function : rgDBMGetNextUeCbFromRachLst
1302  *
1303  *
1304  *  @param[in]  *cellCb
1305  *  @param[in]  *ueCb
1306  *  @return  RgUeCb*
1307  **/
1308 #ifdef ANSI
1309 RgUeCb* rgDBMGetNextUeCbFromRachLst
1310 (
1311 RgCellCb       *cellCb,
1312 RgUeCb         *ueCb
1313 )
1314 #else
1315 RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
1316 RgCellCb       *cellCb;
1317 RgUeCb         *ueCb;
1318 #endif
1319 {
1320
1321    if(!ueCb)
1322    {
1323       return ( cellCb->raInfo.ueRachLst.first ?
1324                (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1325    }
1326    return ( ueCb->rachLstEnt.next ?
1327                (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1328 }  /* rgDBMGetNextUeCbFromRachLst */
1329
1330 /**
1331  * @brief Handler for deleting the existing ueCb in the rachLst.
1332  *
1333  * @details
1334  *
1335  *     Function : rgDBMDelUeCbFromRachLst
1336  *
1337  *
1338  *  @param[in]  *cellCb
1339  *  @param[in]  key
1340  *  @return  RgUeCb*
1341  **/
1342 #ifdef ANSI
1343 Void rgDBMDelUeCbFromRachLst
1344 (
1345 RgCellCb       *cellCb,
1346 RgUeCb         *ueCb
1347 )
1348 #else
1349 Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
1350 RgCellCb       *cellCb;
1351 RgUeCb         *ueCb;
1352 #endif
1353 {
1354
1355    cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1356    RETVOID;
1357 }  /* rgDBMDelUeCbFromRachLst */
1358
1359 /**********************************************************************
1360
1361          End of file
1362 **********************************************************************/