src/5gnrsch/sch_fcfs.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:     5G NR SCH layer
  22
  23 Type:     C source file
  24
  25 Desc:     C source code for scheduling based on First Come First Serve
  26           algorithm
  27
  28 File:     sch_fcfs.c
  29
  30  **********************************************************************/
  31
  32 /** @file sch_slot_ind.c
  33   @brief This module processes slot indications
  34  */
  35 #include "common_def.h"
  36 #include "tfu.h"
  37 #include "lrg.h"
  38 #include "tfu.x"
  39 #include "lrg.x"
  40 #include "du_log.h"
  41 #include "du_app_mac_inf.h"
  42 #include "mac_sch_interface.h"
  43 #include "sch.h"
  44 #include "sch_utils.h"
  45 #include "sch_fcfs.h"
  46 #ifdef NR_DRX
  47 #include "sch_drx.h"
  48 #endif
  49
  50 /*******************************************************************
  51  *
  52  * @brief Function to handle Cell configuration request
  53  *
  54  * @details
  55  *
  56  *    Function : schFcfsCellCfgReq
  57  *
  58  *    Functionality: This function configures cell paremeters
  59  *       required for FCFS scheduling
  60  *
  61  * @params[in] SchCellCb *cellCb, Cell control block
  62  * @return ROK
  63  *         RFAILED
  64  *
  65  * ****************************************************************/
  66 uint8_t schFcfsCellCfgReq(SchCellCb *cellCb)
  67 {
  68    SchFcfsCellCb *fcfsCellCb = NULLP;
  69
  70    SCH_ALLOC(fcfsCellCb, sizeof(SchFcfsCellCb));
  71    if(!fcfsCellCb)
  72    {
  73       DU_LOG("\nERROR  -->  SCH: Memory allocation failed in schFcfsCellCfgReq");
  74       return RFAILED;
  75    }
  76    cmLListInit(&fcfsCellCb->ueToBeScheduled);
  77    cellCb->schSpcCell = (void *)fcfsCellCb;
  78    return ROK;
  79 }
  80
  81 /*******************************************************************
  82  *
  83  * @brief Function to handle Cell configuration request
  84  *
  85  * @details
  86  *
  87  *    Function : schFcfsCellDelReq
  88  *
  89  *    Functionality: This function deletes/frees cell params
  90  *       specific to FCFS scheduling
  91  *
  92  * @params[in] Pointer to Cell control block
  93  * @return void
  94  *
  95  * ****************************************************************/
  96 void schFcfsCellDelReq(SchCellCb *cellCb)
  97 {
  98    SchFcfsCellCb *fcfsCellCb = NULLP;
  99    CmLList *node=NULL, *next=NULL;
 100
 101    fcfsCellCb = (SchFcfsCellCb *)cellCb->schSpcCell;
 102    /* Remove all UE from ueToBeScheduled list and deallocate */
 103    node = fcfsCellCb->ueToBeScheduled.first;
 104    while(node)
 105    {
 106       next = node->next;
 107       SCH_FREE(node->node, sizeof(uint8_t));
 108       cmLListDelFrm(&fcfsCellCb->ueToBeScheduled, node);
 109       SCH_FREE(node, sizeof(CmLList));
 110       node = next;
 111    }
 112    SCH_FREE(fcfsCellCb, sizeof(SchFcfsCellCb));
 113    cellCb->schSpcCell = NULLP;
 114 }
 115
 116 /*******************************************************************
 117  *
 118  * @brief Function to handle UE configuration request
 119  *
 120  * @details
 121  *
 122  *    Function : SchFcfsAddUeConfigReq
 123  *
 124  *    Functionality: Adds/Configures UE parameters required for
 125  *       FCFS scheduling
 126  *
 127  * @params[in] Pointer to UE control block
 128  * @return ROK
 129  *         RFAILED
 130  *
 131  * ****************************************************************/
 132 uint8_t SchFcfsAddUeConfigReq(SchUeCb *ueCb)
 133 {
 134    SchFcfsUeCb *ueFcfsCb;
 135
 136    SCH_ALLOC(ueFcfsCb, sizeof(SchFcfsHqCb));
 137    if(!ueFcfsCb)
 138    {
 139       DU_LOG("\nERROR  -->  SCH: Memory allocation failed in SchFcfsAddUeConfigReq");
 140       return RFAILED;
 141    }
 142
 143    cmLListInit(&ueFcfsCb->hqRetxCb.ulRetxHqList);
 144    cmLListInit(&ueFcfsCb->hqRetxCb.dlRetxHqList);
 145    ueCb->schSpcUeCb = (void *)ueFcfsCb;
 146
 147    return ROK;
 148 }
 149
 150 /*******************************************************************
 151  *
 152  * @brief Handles UE reconfiguration request
 153  *
 154  * @details
 155  *
 156  *    Function : SchFcfsModUeConfigReq
 157  *
 158  *    Functionality:
 159  *
 160  * @params[in] Pointer to UE control block
 161  * @return void
 162  *
 163  * ****************************************************************/
 164 void SchFcfsModUeConfigReq(SchUeCb *ueCb)
 165 {
 166    /*TBD: No action required for FCFS*/
 167    return;
 168 }
 169
 170 /*******************************************************************
 171  *
 172  * @brief Handles UE Delete Request
 173  *
 174  * @details
 175  *
 176  *    Function : SchFcfsUeDeleteReq
 177  *
 178  *    Functionality: Deletes/Frees UE parameters specific to
 179  *       FCFS scheduling
 180  *
 181  * @params[in] Pointer to UE control block
 182  * @return void
 183  *
 184  * ****************************************************************/
 185 void SchFcfsUeDeleteReq(SchUeCb *ueCb)
 186 {
 187    SchFcfsCellCb *fcfsCellCb = NULLP;
 188    SchFcfsUeCb *ueFcfsCb = NULLP;
 189    CmLList *node=NULL, *next=NULL;
 190    uint8_t ueId = 0;
 191
 192    fcfsCellCb = (SchFcfsCellCb *)ueCb->cellCb->schSpcCell;
 193    /* Remove all UE from ueToBeScheduled list and deallocate */
 194    node = fcfsCellCb->ueToBeScheduled.first;
 195    while(node)
 196    {
 197       next = node->next;
 198       ueId = *(uint8_t *)node->node;
 199       if(ueId == ueCb->ueId)
 200       {
 201         SCH_FREE(node->node, sizeof(uint8_t));
 202         cmLListDelFrm(&fcfsCellCb->ueToBeScheduled, node);
 203         SCH_FREE(node, sizeof(CmLList));
 204         break;
 205       }
 206       node = next;
 207    }
 208
 209    ueFcfsCb = (SchFcfsUeCb *)ueCb->schSpcUeCb;
 210    cmLListDeleteLList(&ueFcfsCb->hqRetxCb.ulRetxHqList);
 211    cmLListDeleteLList(&ueFcfsCb->hqRetxCb.dlRetxHqList);
 212
 213    SCH_FREE(ueFcfsCb, sizeof(SchFcfsUeCb));
 214    ueCb->schSpcUeCb = NULLP;
 215    return;
 216 }
 217
 218 /*******************************************************************
 219  *
 220  * @brief Intializes HARQ Process control block
 221  *
 222  * @details
 223  *
 224  *    Function : schFcfsInitDlHqProcCb
 225  *
 226  *    Functionality: Intitialized parameters of HARQ process control
 227  *       block specific to FCFS scheduling in Downlink
 228  *
 229  * @params[in] Pointer to Downlink HARQ Process control block
 230  * @return ROK
 231  *         RFAILED
 232  *
 233  * ****************************************************************/
 234 uint8_t schFcfsInitDlHqProcCb(SchDlHqProcCb *hqP)
 235 {
 236    SchFcfsHqProcCb *fcfsHqP;
 237
 238    SCH_ALLOC(fcfsHqP, sizeof(SchFcfsHqProcCb));
 239    if(!fcfsHqP)
 240    {
 241       DU_LOG("\nERROR  -->  SCH: Memory allocation failed in schFcfsInitDlHqProcCb");
 242       return RFAILED;
 243    }
 244
 245    cmLListInit(&fcfsHqP->lcCb.dedLcList);
 246    cmLListInit(&fcfsHqP->lcCb.defLcList);
 247    hqP->schSpcDlHqProcCb = (void *)fcfsHqP;
 248
 249    return ROK;
 250 }
 251
 252 /*******************************************************************
 253  *
 254  * @brief Handles HARQ Process delete request
 255  *
 256  * @details
 257  *
 258  *    Function : schFcfsDeleteDlHqProcCb
 259  *
 260  *    Functionality: Deletes HARQ Process parameters specific to
 261  *       FCFS scheduling in Downlink
 262  *
 263  * @params[in] Pointer to Downlink HARQ Process control block
 264  * @return void
 265  *
 266  * ****************************************************************/
 267 void schFcfsDeleteDlHqProcCb(SchDlHqProcCb *hqP)
 268 {
 269    SchFcfsHqProcCb *fcfsHqP = (SchFcfsHqProcCb *)hqP->schSpcDlHqProcCb;
 270    cmLListDeleteLList(&fcfsHqP->lcCb.dedLcList);
 271    cmLListDeleteLList(&fcfsHqP->lcCb.defLcList);
 272    SCH_FREE(fcfsHqP, sizeof(SchFcfsHqProcCb));
 273    hqP->schSpcDlHqProcCb = NULLP;
 274 }
 275
 276 /*******************************************************************
 277  *
 278  * @brief Intializes HARQ Process control block
 279  *
 280  * @details
 281  *
 282  *    Function : schFcfsInitUlHqProcCb
 283  *
 284  *    Functionality: Intitialized parameters of HARQ process control
 285  *       block specific to FCFS scheduling in Uplink
 286  *
 287  * @params[in] Pointer to Uplink HARQ Process control block
 288  * @return ROK
 289  *         RFAILED
 290  *
 291  * ****************************************************************/
 292 uint8_t schFcfsInitUlHqProcCb(SchUlHqProcCb *hqP)
 293 {
 294    SchFcfsHqProcCb *fcfsHqP;
 295
 296    SCH_ALLOC(fcfsHqP, sizeof(SchFcfsHqProcCb));
 297    if(!fcfsHqP)
 298    {
 299       DU_LOG("\nERROR  -->  SCH: Memory allocation failed in schFcfsInitUlHqProcCb");
 300       return RFAILED;
 301    }
 302    cmLListInit(&fcfsHqP->lcCb.dedLcList);
 303    cmLListInit(&fcfsHqP->lcCb.defLcList);
 304    hqP->schSpcUlHqProcCb = (void *)fcfsHqP;
 305
 306    return ROK;
 307 }
 308
 309 /*******************************************************************
 310  *
 311  * @brief Handled Deletion of HARQ Process control block
 312  *
 313  * @details
 314  *
 315  *    Function : schFcfsDeleteUlHqProcCb
 316  *
 317  *    Functionality: Deletes HARQ Process parameters specific to
 318  *       FCFS scheduling in Uplink
 319  *
 320  * @params[in] Pointer to Uplink HARQ Process Control block
 321  * @return void
 322  *
 323  * ****************************************************************/
 324 void schFcfsDeleteUlHqProcCb(SchUlHqProcCb *hqP)
 325 {
 326    SchFcfsHqProcCb *fcfsHqP = (SchFcfsHqProcCb *)hqP->schSpcUlHqProcCb;
 327    cmLListDeleteLList(&fcfsHqP->lcCb.dedLcList);
 328    cmLListDeleteLList(&fcfsHqP->lcCb.defLcList);
 329    SCH_FREE(fcfsHqP, sizeof(SchFcfsHqProcCb));
 330    hqP->schSpcUlHqProcCb = NULLP;
 331 }
 332
 333 /*******************************************************************
 334  *
 335  * @brief Handles freeing of HARQ Process
 336  *
 337  * @details
 338  *
 339  *    Function : schFcfsFreeDlHqProcCb
 340  *
 341  *    Functionality: Frees HARQ Process parameters specific to
 342  *       FCFS scheduling in Downlink when HARQ process becomes free
 343  *
 344  * @params[in] Pointer to HARQ process control block
 345  * @return void
 346  *
 347  * ****************************************************************/
 348 void schFcfsFreeDlHqProcCb(SchDlHqProcCb *hqP)
 349 {
 350    SchFcfsHqProcCb *fcfsHqP = (SchFcfsHqProcCb *)hqP->schSpcDlHqProcCb;
 351
 352    cmLListDeleteLList(&fcfsHqP->lcCb.dedLcList);
 353    cmLListDeleteLList(&fcfsHqP->lcCb.defLcList);
 354 }
 355
 356 /*******************************************************************
 357  *
 358  * @brief Handles freeing of HARQ Process
 359  *
 360  * @details
 361  *
 362  *    Function : schFcfsFreeUlHqProcCb
 363  *
 364  *    Functionality: Frees HARQ Process parameters specific to
 365  *       FCFS scheduling in Uplink when HARQ process becomes free
 366  *
 367  * @params[in] Pointer to HARQ process control block
 368  * @return void
 369  *
 370  * ****************************************************************/
 371 void schFcfsFreeUlHqProcCb(SchUlHqProcCb *hqP)
 372 {
 373    SchFcfsHqProcCb *fcfsHqP = (SchFcfsHqProcCb *)hqP->schSpcUlHqProcCb;
 374
 375    cmLListDeleteLList(&fcfsHqP->lcCb.dedLcList);
 376    cmLListDeleteLList(&fcfsHqP->lcCb.defLcList);
 377 }
 378
 379 /*******************************************************************
 380  *
 381  * @brief Adds HARQ process to retransmission list
 382  *
 383  * @details
 384  *
 385  *    Function : schFcfsAddToDlHqRetxList
 386  *
 387  *    Functionality: Adds HARQ process to retransmission list
 388  *
 389  * @params[in] Pointer to Downlink HARQ Process
 390  * @return void
 391  *
 392  * ****************************************************************/
 393 void schFcfsAddToDlHqRetxList(SchDlHqProcCb *hqP)
 394 {
 395    SchFcfsUeCb *fcfsUeCb;
 396
 397    fcfsUeCb = (SchFcfsUeCb *)hqP->hqEnt->ue->schSpcUeCb;
 398    cmLListAdd2Tail(&(fcfsUeCb->hqRetxCb.dlRetxHqList),&hqP->dlHqProcLink);
 399 #ifdef NR_DRX
 400    if(hqP->hqEnt->ue->ueDrxInfoPres == true)
 401    {
 402       schDrxStrtDlHqRttTmr(hqP);
 403    }
 404    else
 405 #endif
 406    {
 407       schFcfsAddUeToSchedule(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId);
 408    }
 409 }
 410
 411 /*******************************************************************
 412  *
 413  * @brief Adds HARQ process to retransmission list
 414  *
 415  * @details
 416  *
 417  *    Function : schFcfsAddToUlHqRetxList
 418  *
 419  *    Functionality: Adds HARQ process to retransmission list
 420  *
 421  * @params[in] Pointer to Uplink HARQ Process
 422  * @return void
 423  *
 424  * ****************************************************************/
 425 void schFcfsAddToUlHqRetxList(SchUlHqProcCb *hqP)
 426 {
 427    SchFcfsUeCb *fcfsUeCb;
 428
 429    fcfsUeCb = (SchFcfsUeCb *)hqP->hqEnt->ue->schSpcUeCb;
 430    cmLListAdd2Tail(&(fcfsUeCb->hqRetxCb.ulRetxHqList),&hqP->ulHqProcLink);
 431 #ifdef NR_DRX
 432    if(hqP->hqEnt->ue->ueDrxInfoPres == true)
 433    {
 434       schDrxStrtUlHqRttTmr(hqP);
 435    }
 436    else
 437 #endif
 438    {
 439       schFcfsAddUeToSchedule(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId);
 440    }
 441 }
 442
 443 /*******************************************************************
 444  *
 445  * @brief Add UE to ueToBeScheduled List
 446  *
 447  * @details
 448  *
 449  *    Function : schFcfsAddUeToSchedule
 450  *
 451  *    Functionality:
 452  *      Search if UE entry present in the list
 453  *      If yes, return.
 454  *      If no, add UE to the list
 455  *
 456  * @params[in] Cell control block
 457  *             Ue Id to be added
 458  *
 459  * @return ROK     - success
 460  *         RFAILED - failure
 461  *
 462  * ****************************************************************/
 463 uint8_t schFcfsAddUeToSchedule(SchCellCb *cellCb, uint16_t ueIdToAdd)
 464 {
 465    SchFcfsCellCb *fcfsCellCb = NULLP;
 466    uint8_t *ueId;
 467    CmLList *node;
 468
 469    fcfsCellCb = (SchFcfsCellCb *)cellCb->schSpcCell;
 470    /* Search if UE entry is already present in ueToBeScheduled list.
 471     * If yes, another entry for same UE not needed. Hence, return */
 472    node = fcfsCellCb->ueToBeScheduled.first;
 473    while(node)
 474    {
 475       ueId = (uint8_t *)node->node;
 476       if(*ueId == ueIdToAdd)
 477          return ROK;
 478       node = node->next;
 479    }
 480
 481    /* If UE entry not present already, add UE to the end of ueToBeScheduled list */
 482    SCH_ALLOC(ueId, sizeof(uint8_t));
 483    if(!ueId)
 484    {
 485       DU_LOG("\nERROR  -->  SCH : Memory allocation failure in schFcfsAddUeToSchedule");
 486       return RFAILED;
 487    }
 488    *ueId = ueIdToAdd;
 489    if(addNodeToLList(&fcfsCellCb->ueToBeScheduled, ueId, NULLP) != ROK)
 490    {
 491       DU_LOG("\nERROR  --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId);
 492       return RFAILED;
 493    }
 494    return ROK;
 495 }
 496
 497 /*******************************************************************
 498  *
 499  * @brief Handled CRC Indication
 500  *
 501  * @details
 502  *
 503  *    Function : schFcfsProcessCrcInd
 504  *
 505  *    Functionality: Processes CRC Indication as required for FCFS
 506  *       scheduling
 507  *
 508  * @params[in] Pointer to Cell control block
 509  *             UE Id
 510  * @return void
 511  *
 512  * ****************************************************************/
 513 void schFcfsProcessCrcInd(SchCellCb *cellCb, uint16_t ueId)
 514 {
 515    schFcfsAddUeToSchedule(cellCb, ueId);
 516 }
 517
 518 /*******************************************************************
 519  *
 520  * @brief Processes Buffer Occupancy report from RLC
 521  *
 522  * @details
 523  *
 524  *    Function : schFcfsDlRlcBoInfo
 525  *
 526  *    Functionality: Process buffer occupany report
 527  *
 528  * @params[in]
 529  * @return
 530  *
 531  * ****************************************************************/
 532 void schFcfsDlRlcBoInfo(SchCellCb *cellCb, uint16_t ueId)
 533 {
 534    schFcfsAddUeToSchedule(cellCb, ueId);
 535 }
 536
 537 /*******************************************************************
 538  *
 539  * @brief Processes BSR request
 540  *
 541  * @details
 542  *
 543  *    Function : schFcfsBsr
 544  *
 545  *    Functionality: Processes BSR as per FCFS scheduling
 546  *
 547  * @params[in] Pointer to Cell
 548  *             UE ID
 549  * @return void
 550  *
 551  * ****************************************************************/
 552 void schFcfsBsr(SchCellCb *cellCb, uint16_t ueId)
 553 {
 554    schFcfsAddUeToSchedule(cellCb, ueId);
 555 }
 556
 557 /*******************************************************************
 558  *
 559  * @brief Processed UCI Indication
 560  *
 561  * @details
 562  *
 563  *    Function : schFcfsSrUciInd
 564  *
 565  *    Functionality: Processing of UCI indication specific to
 566  *       FCFS scheduling
 567  *
 568  * @params[in] Pointer to Cell
 569  *             UE Id
 570  * @return void
 571  *
 572  * ****************************************************************/
 573 void schFcfsSrUciInd(SchCellCb *cellCb, uint16_t ueId)
 574 {
 575    schFcfsAddUeToSchedule(cellCb, ueId);
 576 }
 577
 578 /*******************************************************************
 579  *
 580  * @brief Processing of RACH Indication
 581  *
 582  * @details
 583  *
 584  *    Function : schFcfsProcessRachInd
 585  *
 586  *    Functionality: Processing of RACH Indication specific to
 587  *       FCFS scheduling
 588  *
 589  * @params[in] Pointer to Cell Cb
 590  *             UE Id
 591  * @return void
 592  *
 593  * ****************************************************************/
 594 void schFcfsProcessRachInd(SchCellCb *cellCb, uint16_t ueId)
 595 {
 596    schFcfsAddUeToSchedule(cellCb, ueId);
 597 }
 598
 599 /*******************************************************************
 600  *
 601  * @brief Processing of DL HARQ Indication
 602  *
 603  * @details
 604  *
 605  *    Function : SchFcfsDlHarqInd
 606  *
 607  *    Functionality:
 608  *
 609  * @params[in]
 610  * @return void
 611  *
 612  * ****************************************************************/
 613 void SchFcfsDlHarqInd()
 614 {
 615    return;
 616 }
 617
 618 /*******************************************************************
 619  *
 620  * @brief Processing of Paging indication
 621  *
 622  * @details
 623  *
 624  *    Function : schFcfsPagingInd
 625  *
 626  *    Functionality:
 627  *
 628  * @params[in]
 629  * @return void
 630  *
 631  * ****************************************************************/
 632 void schFcfsPagingInd()
 633 {
 634    return;
 635 }
 636
 637 /*******************************************************************
 638  *
 639  * @brief Processing of RACH Resource Request
 640  *
 641  * @details
 642  *
 643  *    Function : schFcfsRachRsrcReq
 644  *
 645  *    Functionality:
 646  *
 647  * @params[in]
 648  * @return void
 649  *
 650  * ****************************************************************/
 651 void schFcfsRachRsrcReq()
 652 {
 653    return;
 654 }
 655
 656 /*******************************************************************
 657  *
 658  * @brief Processing of RACH Resource Release
 659  *
 660  * @details
 661  *
 662  *    Function : schFcfsRachRsrcRel
 663  *
 664  *    Functionality:
 665  *
 666  * @params[in]
 667  * @return void
 668  *
 669  * ****************************************************************/
 670 void schFcfsRachRsrcRel()
 671 {
 672    return;
 673 }
 674
 675 /*******************************************************************
 676  *
 677  * @brief Remove entry from HARQ retransmission list
 678  *
 679  * @details
 680  *
 681  *    Function : schFcfsRemoveFrmDlHqRetxList
 682  *
 683  *    Functionality: Remove entry from HARQ retransmission list
 684  *
 685  * @params[in] Pointer to UE
 686  *             Node to be deleted
 687  * @return void
 688  *
 689  * ****************************************************************/
 690 void schFcfsRemoveFrmDlHqRetxList(SchUeCb *ueCb, CmLList *node)
 691 {
 692    SchFcfsUeCb *fcfsUeCb;
 693
 694    fcfsUeCb = (SchFcfsUeCb *)ueCb->schSpcUeCb;
 695    cmLListDelFrm(&fcfsUeCb->hqRetxCb.dlRetxHqList, node);
 696 }
 697
 698 /*******************************************************************
 699  *
 700  * @brief Remove entry from HARQ retransmission list
 701  *
 702  * @details
 703  *
 704  *    Function : schFcfsRemoveFrmUlHqRetxList
 705  *
 706  *    Functionality: Remove entry from HARQ retransmission list
 707  *
 708  * @params[in] Pointer to UE
 709  *             Node to be deleted
 710  * @return void
 711  *
 712  * ****************************************************************/
 713 void schFcfsRemoveFrmUlHqRetxList(SchUeCb *ueCb, CmLList *node)
 714 {
 715    SchFcfsUeCb *fcfsUeCb;
 716
 717    fcfsUeCb = (SchFcfsUeCb *)ueCb->schSpcUeCb;
 718    cmLListDelFrm(&fcfsUeCb->hqRetxCb.ulRetxHqList, node);
 719 }
 720
 721 /*******************************************************************
 722  *
 723  * @brief Remove UE from Scheduling List
 724  *
 725  * @details
 726  *
 727  *    Function : schFcfsRemoveUeFrmScheduleLst
 728  *
 729  *    Functionality: Remove UE from Scheduling List
 730  *
 731  * @params[in] Pointer to Cell
 732  *             Node to be removed
 733  * @return void
 734  *
 735  * ****************************************************************/
 736 void schFcfsRemoveUeFrmScheduleLst(SchCellCb *cell, CmLList *node)
 737 {
 738    SchFcfsCellCb *fcfsCell;
 739
 740    fcfsCell = (SchFcfsCellCb *)cell->schSpcCell;
 741    SCH_FREE(node->node, sizeof(uint8_t));
 742    deleteNodeFromLList(&fcfsCell->ueToBeScheduled, node);
 743 }
 744
 745 /*******************************************************************
 746  *
 747  * @brief  Handler to calculate TBS size for BSR requested
 748  *
 749  * @details
 750  *
 751  *    Function :  schFcfsCalculateUlTbs
 752  *
 753  *    Functionality: Function will note the required TBS for each LCGIDX and use
 754  *    the Priority LCG List and RRM policy to allocate the TBS size
 755  *
 756  * @params [in] ueCb (Pointer to UE CB)
 757  *         [in] puschTime (Time slot where PUSCH will be sent)
 758  *         [in] symbLen (No of Symbols used for PUSCH transmission)
 759  *         [out] startPrb(Pointer to startPRB which will be calculated while
 760  *         finding the best Free Block)
 761  *         [out] totTBS(Pointer to total TBS size)
 762  *         [in] isRetx (to indicate retransmission)
 763  *         [in] hqP (UL Harq process pointer)
 764  *
 765  * @return uint8_t : ROK > Scheduling of UL grant is successful
 766  *                   RFAILED > vice versa
 767  *
 768  * ****************************************************************/
 769 uint8_t schFcfsCalculateUlTbs(SchUeCb *ueCb, SlotTimingInfo puschTime, uint8_t symbLen,\
 770                           uint16_t *startPrb, uint32_t *totTBS, bool isRetx, SchUlHqProcCb *hqP, SchFcfsHqProcCb *fcfsHqP)
 771 {
 772    uint16_t mcsIdx = 0;
 773    CmLListCp *lcLL = NULLP;
 774    uint16_t lcgIdx = 0, lcId =0, maxFreePRB = 0;
 775    uint16_t rsvdDedicatedPRB;
 776    *startPrb = 0;
 777    *totTBS = 0;
 778
 779    /* check for BSR */
 780    for(lcgIdx=0; lcgIdx<MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++)
 781    {
 782       if(ueCb->bsrInfo[lcgIdx].dataVol == 0)
 783       {
 784          continue;
 785       }
 786
 787       /*TODO: lcgIdx and LCID has been implemented as one to one mapping.
 788        * Need to check the mapping to figure out the LCID and lcgIdx once L2
 789        * spec specifies any logic*/
 790       lcId = lcgIdx;
 791       if(ueCb->ulInfo.ulLcCtxt[lcId].isDedicated)
 792       {
 793          lcLL = &(fcfsHqP->lcCb.dedLcList);
 794          rsvdDedicatedPRB = ueCb->ulInfo.ulLcCtxt[lcId].rsvdDedicatedPRB;
 795       }
 796       else
 797       {
 798          lcLL = &(fcfsHqP->lcCb.defLcList);
 799       }
 800
 801       /*[Step2]: Update the reqPRB and Payloadsize for this LC in the appropriate List*/
 802       if(updateLcListReqPRB(lcLL, lcId, ueCb->bsrInfo[lcgIdx].dataVol) != ROK)
 803       {
 804          DU_LOG("\nERROR  --> SCH: LcgId:%d updation failed",lcId);
 805          return RFAILED;
 806       }
 807    }
 808
 809    if ((fcfsHqP->lcCb.defLcList.count == 0) && (fcfsHqP->lcCb.dedLcList.count == 0))
 810    {
 811       if( (ueCb->srRcvd) || (isRetx) )
 812       {
 813          *startPrb = MAX_NUM_RB;
 814          *totTBS = schCalcTbSize(UL_GRANT_SIZE);
 815       }
 816       /*Returning true when NO Grant is there for UE as this is not scheduling
 817        * error*/
 818       return ROK;
 819    }
 820
 821    maxFreePRB = searchLargestFreeBlock(ueCb->cellCb, puschTime, startPrb, DIR_UL);
 822
 823    /*[Step4]: Estimation of PRB and BO which can be allocated to each LC in
 824     * the list based on RRM policy*/
 825
 826    /*Either this UE contains no reservedPRB pool fir dedicated S-NSSAI or
 827     * Num of Free PRB available is not enough to reserve Dedicated PRBs*/
 828    if(maxFreePRB != 0)
 829    {
 830       mcsIdx = ueCb->ueCfg.ulModInfo.mcsIndex;
 831       if((fcfsHqP->lcCb.dedLcList.count == 0) || ((maxFreePRB < rsvdDedicatedPRB)))
 832       {
 833          fcfsHqP->lcCb.sharedNumPrb = maxFreePRB;
 834          DU_LOG("\nDEBUG  -->  SCH : UL Only Default Slice is scheduled, sharedPRB Count:%d",\
 835                fcfsHqP->lcCb.sharedNumPrb);
 836
 837          /*PRB Alloc for Default LCs*/
 838          prbAllocUsingRRMPolicy(&(fcfsHqP->lcCb.defLcList), FALSE, mcsIdx, symbLen,\
 839                &(fcfsHqP->lcCb.sharedNumPrb), NULLP, NULLP,&(ueCb->srRcvd));
 840       }
 841       else
 842       {
 843          fcfsHqP->lcCb.sharedNumPrb = maxFreePRB - rsvdDedicatedPRB;
 844
 845          /*PRB Alloc for Dedicated LCs*/
 846          prbAllocUsingRRMPolicy(&(fcfsHqP->lcCb.dedLcList), TRUE, mcsIdx, symbLen,\
 847                &(fcfsHqP->lcCb.sharedNumPrb), &(rsvdDedicatedPRB),\
 848                NULLP, &(ueCb->srRcvd));
 849
 850          /*PRB Alloc for Default LCs*/
 851          prbAllocUsingRRMPolicy(&(fcfsHqP->lcCb.defLcList), FALSE, mcsIdx, symbLen, \
 852                &(fcfsHqP->lcCb.sharedNumPrb), &(rsvdDedicatedPRB),\
 853                NULLP,&(ueCb->srRcvd));
 854       }
 855    }
 856    /*[Step5]:Traverse each LCID in LcList to calculate the exact Scheduled Bytes
 857     * using allocated BO per LC and Update dlMsgAlloc(BO report for MAC*/
 858    if(fcfsHqP->lcCb.dedLcList.count != 0)
 859       updateGrantSizeForBoRpt(&(fcfsHqP->lcCb.dedLcList), NULLP, ueCb->bsrInfo, totTBS);
 860
 861    updateGrantSizeForBoRpt(&(fcfsHqP->lcCb.defLcList), NULLP, ueCb->bsrInfo, totTBS);
 862
 863    /*Below case will hit if NO LC(s) are allocated due to resource crunch*/
 864    if (*totTBS == 0)
 865    {
 866       if(maxFreePRB == 0)
 867       {
 868          DU_LOG("\nERROR  --> SCH : NO FREE PRB!!");
 869       }
 870       else
 871       {
 872          /*Schedule the LC for next slot*/
 873          DU_LOG("\nDEBUG  -->  SCH : No LC has been scheduled");
 874       }
 875       return RFAILED;
 876    }
 877    return ROK;
 878 }
 879
 880 /*******************************************************************
 881  *
 882  * @brief Grants resources to LC in uplink
 883  *
 884  * @details
 885  *
 886  *    Function : schProcessSrOrBsrReq
 887  *
 888  *    Functionality:
 889  *       Grants resources to LC in uplink
 890  *
 891  * @params[in] PDCCH Time
 892  *             PUSCH Time
 893  *             Start Symbol
 894  *             Number of symbols
 895  *             Is retransmission
 896  *             HARQ process
 897  * @return ROK
 898  *         RFAILED
 899  *
 900  *******************************************************************/
 901 uint8_t schFcfsScheduleUlLc(SlotTimingInfo dciTime, SlotTimingInfo puschTime, uint8_t startSymb , uint8_t symbLen, bool isRetx, SchUlHqProcCb **hqP)
 902 {
 903    SchCellCb *cell;
 904    SchFcfsHqProcCb *fcfsHqProcCb;
 905    uint8_t ret = RFAILED;
 906    uint16_t startPrb = 0;
 907    uint32_t totDataReq = 0; /* in bytes */
 908    SchUeCb *ueCb;
 909    SchPuschInfo *puschInfo;
 910    DciInfo  *dciInfo = NULLP;
 911
 912    cell = (*hqP)->hqEnt->cell;
 913    ueCb = (*hqP)->hqEnt->ue;
 914    fcfsHqProcCb = (SchFcfsHqProcCb *)(*hqP)->schSpcUlHqProcCb;
 915    ret = schFcfsCalculateUlTbs(ueCb, puschTime, symbLen, &startPrb, &totDataReq, isRetx, *hqP, fcfsHqProcCb);
 916
 917    if(totDataReq > 0 && ret == ROK)
 918    {
 919       SCH_ALLOC(dciInfo, sizeof(DciInfo));
 920       if(!dciInfo)
 921       {
 922          DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciInfo alloc");
 923          if(isRetx != TRUE)
 924          {
 925             if(fcfsHqProcCb->lcCb.dedLcList.count != 0)
 926                updateBsrAndLcList(&(fcfsHqProcCb->lcCb.dedLcList), ueCb->bsrInfo, RFAILED);
 927
 928             updateBsrAndLcList(&(fcfsHqProcCb->lcCb.defLcList), ueCb->bsrInfo, RFAILED);
 929          }
 930          return RFAILED;
 931       }
 932       cell->schDlSlotInfo[dciTime.slot]->ulGrant = dciInfo;
 933       memset(dciInfo,0,sizeof(DciInfo));
 934
 935       /* Update PUSCH allocation */
 936       if(schFillPuschAlloc(ueCb, puschTime, totDataReq, startSymb, symbLen, startPrb, isRetx, *hqP) == ROK)
 937       {
 938          if(cell->schUlSlotInfo[puschTime.slot]->schPuschInfo)
 939          {
 940             puschInfo = cell->schUlSlotInfo[puschTime.slot]->schPuschInfo;
 941             if(puschInfo != NULLP)
 942             {
 943                /* Fill DCI for UL grant */
 944                schFillUlDci(ueCb, puschInfo, dciInfo, isRetx, *hqP);
 945                ueCb->srRcvd = false;
 946                ueCb->bsrRcvd = false;
 947                cell->schUlSlotInfo[puschTime.slot]->puschUe = ueCb->ueId;
 948                if(fcfsHqProcCb->lcCb.dedLcList.count != 0)
 949                   updateBsrAndLcList(&(fcfsHqProcCb->lcCb.dedLcList), ueCb->bsrInfo, ROK);
 950                updateBsrAndLcList(&(fcfsHqProcCb->lcCb.defLcList), ueCb->bsrInfo, ROK);
 951                cmLListAdd2Tail(&(ueCb->hqUlmap[puschTime.slot]->hqList), &(*hqP)->ulSlotLnk);
 952                return ROK;
 953             }
 954          }
 955       }
 956       if(fcfsHqProcCb->lcCb.dedLcList.count != 0)
 957          updateBsrAndLcList(&(fcfsHqProcCb->lcCb.dedLcList), ueCb->bsrInfo, RFAILED);
 958       updateBsrAndLcList(&(fcfsHqProcCb->lcCb.defLcList), ueCb->bsrInfo, RFAILED);
 959    }
 960    return ROK;
 961 }
 962
 963 /*******************************************************************
 964  *
 965  * @brief Grants resources to LC in downlink
 966  *
 967  * @details
 968  *
 969  *    Function : schFcfsScheduleDlLc
 970  *
 971  *    Functionality: Grants resources to LC in uplink
 972  *
 973  * @params[in] PDCCH Time
 974  *
 975  * @return ROK
 976  *         RFAILED
 977  *
 978  * ****************************************************************/
 979 uint32_t schFcfsScheduleDlLc(SlotTimingInfo pdcchTime, SlotTimingInfo pdschTime, uint8_t pdschNumSymbols, bool isRetx, SchDlHqProcCb **hqP)
 980 {
 981    SchFcfsHqProcCb *fcfsHqProcCb;
 982    SchUeCb *ueCb;
 983    uint8_t lcIdx = 0;
 984    uint16_t startPrb = 0, maxFreePRB = 0;
 985    uint16_t mcsIdx = 0;
 986    uint32_t accumalatedSize = 0;
 987    CmLListCp *lcLL = NULLP;
 988    uint16_t rsvdDedicatedPRB = 0;
 989    DlMsgSchInfo *dciSlotAlloc;
 990
 991    /* TX_PAYLOAD_HDR_LEN: Overhead which is to be Added once for any UE while estimating Accumulated TB Size
 992     * Following flag added to keep the record whether TX_PAYLOAD_HDR_LEN is added to the first Node getting allocated.
 993     * If both Dedicated and Default LC lists are present then First LC in Dedicated List will include this overhead
 994     * else if only Default list is present then first node in this List will add this overhead len*/
 995    bool isTxPayloadLenAdded = FALSE;
 996
 997    ueCb = (*hqP)->hqEnt->ue;
 998    dciSlotAlloc = (*hqP)->hqEnt->cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueCb->ueId -1];
 999    fcfsHqProcCb = (SchFcfsHqProcCb *)((*hqP)->schSpcDlHqProcCb);
1000
1001    if (isRetx == FALSE)
1002    {
1003       /*Re-Initalization per UE*/
1004       /* scheduled LC data fill */
1005       dciSlotAlloc->transportBlock[0].numLc = 0;
1006       isTxPayloadLenAdded = FALSE; /*Re-initlaize the flag for every UE*/
1007       accumalatedSize = 0;
1008
1009       for(lcIdx = 0; lcIdx < MAX_NUM_LC; lcIdx++)
1010       {
1011          if(ueCb->dlInfo.dlLcCtxt[lcIdx].bo)
1012          {
1013             /*Check the LC is Dedicated or default and accordingly LCList will
1014             * be used*/
1015             if(ueCb->dlInfo.dlLcCtxt[lcIdx].isDedicated)
1016             {
1017                lcLL = &(fcfsHqProcCb->lcCb.dedLcList);
1018                rsvdDedicatedPRB = ueCb->dlInfo.dlLcCtxt[lcIdx].rsvdDedicatedPRB;
1019             }
1020             else
1021             {
1022                lcLL = &(fcfsHqProcCb->lcCb.defLcList);
1023             }
1024
1025             /*[Step2]: Update the reqPRB and Payloadsize for this LC in the appropriate List*/
1026             if(updateLcListReqPRB(lcLL, ueCb->dlInfo.dlLcCtxt[lcIdx].lcId,\
1027                      (ueCb->dlInfo.dlLcCtxt[lcIdx].bo + MAC_HDR_SIZE)) != ROK)
1028             {
1029                DU_LOG("\nERROR  --> SCH : Updation in LC List Failed");
1030                /* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
1031                if(!dciSlotAlloc->dlMsgPdschCfg)
1032                {
1033                   SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
1034                   (*hqP)->hqEnt->cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueCb->ueId -1] = NULL;
1035                }
1036                return accumalatedSize;
1037             }
1038          }
1039       }//End of for loop
1040
1041       if ((fcfsHqProcCb->lcCb.defLcList.count == 0) && (fcfsHqProcCb->lcCb.dedLcList.count == 0))
1042       {
1043          DU_LOG("\nDEBUG  -->  SCH : No pending BO for any LC id\n");
1044          UNSET_ONE_BIT((*hqP)->hqEnt->ue->ueId, (*hqP)->hqEnt->cell->boIndBitMap);
1045
1046          /* Free the dl ded msg info allocated in macSchDlRlcBoInfo */
1047          if(!dciSlotAlloc->dlMsgPdschCfg)
1048          {
1049             SCH_FREE(dciSlotAlloc, sizeof(DlMsgSchInfo));
1050             (*hqP)->hqEnt->cell->schDlSlotInfo[pdcchTime.slot]->dlMsgAlloc[ueCb->ueId -1] = NULL;
1051          }
1052          /*TRUE because this UE has nothing to be scheduled*/
1053          return accumalatedSize;
1054       }
1055    }
1056
1057    /*[Step3]: Calculate Best FREE BLOCK with MAX PRB count*/
1058    maxFreePRB = searchLargestFreeBlock((*hqP)->hqEnt->cell, pdschTime, &startPrb, DIR_DL);
1059
1060    /*[Step4]: Estimation of PRB and BO which can be allocated to each LC in
1061     * the list based on RRM policy*/
1062
1063    /*Either this UE contains no reservedPRB pool fir dedicated S-NSSAI or
1064     * Num of Free PRB available is not enough to reserve Dedicated PRBs*/
1065    if(isRetx == FALSE)
1066    {
1067       if(maxFreePRB != 0)
1068       {
1069          mcsIdx = ueCb->ueCfg.dlModInfo.mcsIndex;
1070
1071          if((fcfsHqProcCb->lcCb.dedLcList.count == NULLP) || ((maxFreePRB < rsvdDedicatedPRB)))
1072          {
1073             fcfsHqProcCb->lcCb.sharedNumPrb = maxFreePRB;
1074             DU_LOG("\nDEBUG  --> SCH : DL Only Default Slice is scheduled, sharedPRB Count:%d",\
1075                   fcfsHqProcCb->lcCb.sharedNumPrb);
1076
1077             /*PRB Alloc for Default LCs*/
1078             prbAllocUsingRRMPolicy(&(fcfsHqProcCb->lcCb.defLcList), FALSE, mcsIdx, pdschNumSymbols,\
1079                   &(fcfsHqProcCb->lcCb.sharedNumPrb), NULLP, &isTxPayloadLenAdded, NULLP);
1080          }
1081          else
1082          {
1083             fcfsHqProcCb->lcCb.sharedNumPrb = maxFreePRB - rsvdDedicatedPRB;
1084             /*PRB Alloc for Dedicated LCs*/
1085             prbAllocUsingRRMPolicy(&(fcfsHqProcCb->lcCb.dedLcList), TRUE, mcsIdx, pdschNumSymbols,\
1086                   &(fcfsHqProcCb->lcCb.sharedNumPrb), &(rsvdDedicatedPRB), &isTxPayloadLenAdded, NULLP);
1087
1088             /*PRB Alloc for Default LCs*/
1089             prbAllocUsingRRMPolicy(&(fcfsHqProcCb->lcCb.defLcList), FALSE, mcsIdx, pdschNumSymbols, \
1090                   &(fcfsHqProcCb->lcCb.sharedNumPrb), &(rsvdDedicatedPRB), &isTxPayloadLenAdded, NULLP);
1091          }
1092       }
1093    }
1094
1095    /*[Step5]:Traverse each LCID in LcList to calculate the exact Scheduled Bytes
1096     * using allocated BO per LC and Update dlMsgAlloc BO report for MAC */
1097    if (isRetx == FALSE)
1098    {
1099       if(fcfsHqProcCb->lcCb.dedLcList.count != 0)
1100          updateGrantSizeForBoRpt(&(fcfsHqProcCb->lcCb.dedLcList), dciSlotAlloc, NULLP, &(accumalatedSize));
1101
1102       updateGrantSizeForBoRpt(&(fcfsHqProcCb->lcCb.defLcList), dciSlotAlloc, NULLP, &(accumalatedSize));
1103    }
1104    else
1105    {
1106       accumalatedSize = (*hqP)->tbInfo[0].tbSzReq;
1107    }
1108
1109    /*Below case will hit if NO LC(s) are allocated due to resource crunch*/
1110    if (!accumalatedSize)
1111    {
1112       if(maxFreePRB == 0)
1113       {
1114          DU_LOG("\nERROR  --> SCH : NO FREE PRB!!");
1115       }
1116       else
1117       {
1118          /*Schedule the LC for next slot*/
1119          DU_LOG("\nDEBUG  -->  SCH : No LC has been scheduled");
1120       }
1121       /* Not Freeing dlMsgAlloc as ZERO BO REPORT to be sent to RLC so that
1122        * Allocation can be done in next slot*/
1123       accumalatedSize = 0;
1124    }
1125
1126    return accumalatedSize;
1127 }
1128
1129 /*******************************************************************
1130  *
1131  * @brief Scheduling of Slots in UL And DL
1132  *
1133  * @details
1134  *
1135  *    Function : schFcfsScheduleSlot
1136  *
1137  *    Functionality: Scheduling of slots in UL and DL specific to
1138  *       FCFS scheduling
1139  *
1140  * @params[in] Pointer to Cell
1141  *             Slot timing info
1142  *             Scheduler instance
1143  * @return void
1144  *
1145  * ****************************************************************/
1146 void schFcfsScheduleSlot(SchCellCb *cell, SlotTimingInfo *slotInd, Inst schInst)
1147 {
1148    SchFcfsCellCb  *fcfsCell;
1149    SchFcfsUeCb    *fcfsUeCb;
1150    SchDlHqProcCb  *hqP = NULLP;
1151    SchUlHqProcCb  *ulHqP = NULLP;
1152    CmLList        *pendingUeNode;
1153    CmLList        *node;
1154    uint8_t        ueId;
1155    bool           isRarPending = false, isRarScheduled = false;
1156    bool           isMsg4Pending = false, isMsg4Scheduled = false;
1157    bool           isDlMsgPending = false, isDlMsgScheduled = false;
1158    bool           isUlGrantPending = false, isUlGrantScheduled = false;
1159
1160    fcfsCell = (SchFcfsCellCb *)cell->schSpcCell;
1161
1162    /* Select first UE in the linked list to be scheduled next */
1163    pendingUeNode = fcfsCell->ueToBeScheduled.first;
1164    if(pendingUeNode)
1165    {
1166       if(pendingUeNode->node)
1167       {
1168          ueId = *(uint8_t *)(pendingUeNode->node);
1169          fcfsUeCb = (SchFcfsUeCb *)cell->ueCb[ueId-1].schSpcUeCb;
1170
1171          /* If RAR is pending for this UE, schedule PDCCH,PDSCH to send RAR and
1172           * PUSCH to receive MSG3 as per k0-k2 configuration*/
1173          if(cell->raReq[ueId-1] != NULLP)
1174          {
1175             isRarPending = true;
1176             isRarScheduled = schProcessRaReq(schInst, cell, *slotInd, ueId);
1177          }
1178
1179          /*MSG3 retransmisson*/
1180          if(cell->raCb[ueId-1].retxMsg3HqProc)
1181          {
1182             schMsg3RetxSchedulingForUe(&(cell->raCb[ueId-1]));
1183          }
1184
1185          /* If MSG4 is pending for this UE, schedule PDCCH,PDSCH to send MSG4 and
1186           * PUCCH to receive UL msg as per k0-k1 configuration  */
1187          if (cell->ueCb[ueId-1].retxMsg4HqProc) //should work from dlmap later tbd
1188          {
1189             /* Retransmission of MSG4 */
1190             isMsg4Pending = true;
1191             if(schProcessMsg4Req(cell, *slotInd, ueId, TRUE, &cell->ueCb[ueId-1].retxMsg4HqProc) == ROK)
1192                isMsg4Scheduled = true;
1193          }
1194          else
1195          {
1196             /* First transmission of MSG4 */
1197             if(cell->raCb[ueId-1].msg4recvd)
1198             {
1199                isMsg4Pending = true;
1200                if(schProcessMsg4Req(cell, *slotInd, ueId, FALSE, &cell->ueCb[ueId-1].msg4HqProc) == ROK)
1201                   isMsg4Scheduled = true;
1202
1203                /* If MSG4 scheduling failed, free the newly assigned HARQ process */
1204                if(!isMsg4Scheduled)
1205                   schDlReleaseHqProcess(cell->ueCb[ueId-1].msg4HqProc);
1206             }
1207          }
1208
1209          if(isRarPending || isMsg4Pending)
1210          {
1211             /* If RAR or MSG is successfully scheduled then
1212              * remove UE from linked list since no pending msgs for this UE */
1213             if(isRarScheduled || isMsg4Scheduled)
1214             {
1215                schFcfsRemoveUeFrmScheduleLst(cell, pendingUeNode);
1216             }
1217             /* If RAR/MSG4 is pending but couldnt be scheduled then,
1218              * put this UE at the end of linked list to be scheduled later */
1219             else
1220             {
1221                cmLListAdd2Tail(&fcfsCell->ueToBeScheduled, cmLListDelFrm(&fcfsCell->ueToBeScheduled, pendingUeNode));
1222             }
1223          }
1224
1225 #ifdef NR_DRX
1226          if((cell->ueCb[ueId-1].ueDrxInfoPres == true) && (cell->ueCb[ueId-1].drxUeCb.drxDlUeActiveStatus != true))
1227          {
1228             if(pendingUeNode->node)
1229             {
1230                cmLListAdd2Tail(&fcfsCell->ueToBeScheduled, cmLListDelFrm(&fcfsCell->ueToBeScheduled, pendingUeNode));
1231             }
1232          }
1233          else
1234 #endif
1235          {
1236
1237             /* DL Data */
1238             node = NULLP;
1239             if(fcfsUeCb)
1240                node = fcfsUeCb->hqRetxCb.dlRetxHqList.first;
1241             if(node != NULLP)
1242             {
1243                /* DL Data ReTransmisson */
1244                isDlMsgPending = true;
1245                isDlMsgScheduled = schFillBoGrantDlSchedInfo(cell, *slotInd, ueId, TRUE, ((SchDlHqProcCb**) &(node->node)));
1246                if(isDlMsgScheduled)
1247                {
1248 #ifdef NR_DRX
1249                   schDrxStopDlHqRetxTmr(cell, &cell->ueCb[ueId-1], ((SchDlHqProcCb**) &(node->node)));
1250 #endif
1251                   schFcfsRemoveFrmDlHqRetxList(&cell->ueCb[ueId-1], node);
1252                }
1253             }
1254             else
1255             {
1256                /* DL Data new transmission */
1257                if((cell->boIndBitMap) & (1<<ueId))
1258                {
1259                   isDlMsgPending = true;
1260                   isDlMsgScheduled = schFillBoGrantDlSchedInfo(cell, *slotInd, ueId, FALSE, &hqP);
1261
1262                   /* If DL scheduling failed, free the newly assigned HARQ process */
1263                   if(!isDlMsgScheduled)
1264                      schDlReleaseHqProcess(hqP);
1265                   else
1266                   {
1267 #ifdef NR_DRX
1268                      schHdlDrxInActvStrtTmr(cell, &cell->ueCb[ueId-1], PHY_DELTA_DL + SCHED_DELTA);
1269 #endif
1270                   }
1271                }
1272             }
1273
1274             /* Scheduling of UL grant */
1275             node = NULLP;
1276             if(fcfsUeCb)
1277                node = fcfsUeCb->hqRetxCb.ulRetxHqList.first;
1278             if(node != NULLP)
1279             {
1280                /* UL Data ReTransmisson */
1281                isUlGrantPending = true;
1282                isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, TRUE, (SchUlHqProcCb**) &(node->node));
1283                if(isUlGrantScheduled)
1284                {
1285 #ifdef NR_DRX
1286                   schDrxStopUlHqRetxTmr(cell, &cell->ueCb[ueId-1], ((SchUlHqProcCb**) &(node->node)));
1287 #endif
1288                   schFcfsRemoveFrmUlHqRetxList(&cell->ueCb[ueId-1], node);
1289                }
1290             }
1291             else
1292             {
1293                /* UL Data new transmission */
1294                if(cell->ueCb[ueId-1].srRcvd || cell->ueCb[ueId-1].bsrRcvd)
1295                {
1296                   isUlGrantPending = true;
1297                   isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, FALSE, &ulHqP);
1298                   if(!isUlGrantScheduled)
1299                      schUlReleaseHqProcess(ulHqP, FALSE);
1300                   else
1301                   {
1302 #ifdef NR_DRX
1303                      schHdlDrxInActvStrtTmr(cell, &cell->ueCb[ueId-1], PHY_DELTA_UL + SCHED_DELTA);
1304 #endif
1305                   }
1306                }
1307             }
1308
1309             if(!isUlGrantPending && !isDlMsgPending)
1310             {
1311                /* No action required */
1312             }
1313             else if((isUlGrantPending && !isUlGrantScheduled) || (isDlMsgPending && !isDlMsgScheduled))
1314             {
1315                cmLListAdd2Tail(&fcfsCell->ueToBeScheduled, cmLListDelFrm(&fcfsCell->ueToBeScheduled, pendingUeNode));
1316             }
1317             else
1318             {
1319                schFcfsRemoveUeFrmScheduleLst(cell, pendingUeNode);
1320             }
1321          }
1322       }
1323    }
1324 }
1325
1326 /*******************************************************************
1327  *
1328  * @brief Initializes all function pointers to FCFS function handler
1329  *
1330  * @details
1331  *
1332  *    Function : schFcfsAllApisInit
1333  *
1334  *    Functionality: Initializes all function pointers to FCFS
1335  *       function handler
1336  *
1337  * @params[in] Function pointer array
1338  * @return void
1339  *
1340  * ****************************************************************/
1341 void schFcfsAllApisInit(SchAllApis *allFcfsApi)
1342 {
1343     /* Interface API function pointers */
1344     allFcfsApi->SchCellCfgReq = schFcfsCellCfgReq;
1345     allFcfsApi->SchCellDeleteReq = schFcfsCellDelReq;
1346     allFcfsApi->SchAddUeConfigReq = SchFcfsAddUeConfigReq;
1347     allFcfsApi->SchModUeConfigReq = SchFcfsModUeConfigReq;
1348     allFcfsApi->SchUeDeleteReq = SchFcfsUeDeleteReq;
1349     allFcfsApi->SchDlHarqInd = SchFcfsDlHarqInd;
1350     allFcfsApi->SchCrcInd = schFcfsProcessCrcInd;
1351     allFcfsApi->SchRachInd = schFcfsProcessRachInd;
1352     allFcfsApi->SchPagingInd = schFcfsPagingInd;
1353     allFcfsApi->SchRachRsrcReq = schFcfsRachRsrcReq;
1354     allFcfsApi->SchRachRsrcRel = schFcfsRachRsrcRel;
1355     allFcfsApi->SchDlRlcBoInfo = schFcfsDlRlcBoInfo;
1356     allFcfsApi->SchSrUciInd = schFcfsSrUciInd;
1357     allFcfsApi->SchBsr = schFcfsBsr;
1358
1359     /* Internal API function pointers */
1360     allFcfsApi->SchAddToDlHqRetxList = schFcfsAddToDlHqRetxList;
1361     allFcfsApi->SchAddToUlHqRetxList = schFcfsAddToUlHqRetxList;
1362     allFcfsApi->SchRemoveFrmDlHqRetxList = schFcfsRemoveFrmDlHqRetxList;
1363     allFcfsApi->SchRemoveFrmUlHqRetxList = schFcfsRemoveFrmUlHqRetxList;
1364     allFcfsApi->SchAddUeToSchedule = schFcfsAddUeToSchedule;
1365     allFcfsApi->SchRemoveUeFrmScheduleLst = schFcfsRemoveUeFrmScheduleLst;
1366     allFcfsApi->SchInitDlHqProcCb = schFcfsInitDlHqProcCb;
1367     allFcfsApi->SchInitUlHqProcCb = schFcfsInitUlHqProcCb;
1368     allFcfsApi->SchFreeDlHqProcCb = schFcfsFreeDlHqProcCb;
1369     allFcfsApi->SchFreeUlHqProcCb = schFcfsFreeUlHqProcCb;
1370     allFcfsApi->SchDeleteDlHqProcCb = schFcfsDeleteDlHqProcCb;
1371     allFcfsApi->SchDeleteUlHqProcCb = schFcfsDeleteUlHqProcCb;
1372     allFcfsApi->SchScheduleSlot = schFcfsScheduleSlot;
1373     allFcfsApi->SchScheduleDlLc = schFcfsScheduleDlLc;
1374     allFcfsApi->SchScheduleUlLc = schFcfsScheduleUlLc;
1375 }
1376 /**********************************************************************
1377     End of file
1378 **********************************************************************/
1379