src/5gnrmac/lwr_mac_fsm.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 #include <stdlib.h>
  20 #include <stdint.h>
  21 #include <stdbool.h>
  22
  23 /* header include files -- defines (.h) */
  24 #include "envopt.h"        /* environment options */
  25 #include "envdep.h"        /* environment dependent */
  26 #include "envind.h"        /* environment independent */
  27 #include "gen.h"           /* general layer */
  28 #include "ssi.h"           /* system service interface */
  29 #include "cm_hash.h"       /* common hash list */
  30 #include "cm_mblk.h"       /* common memory link list library */
  31 #include "cm_llist.h"      /* common linked list library */
  32 #include "cm_err.h"        /* common error */
  33 #include "cm_lte.h"        /* common LTE */
  34 #include "lrg.h"           /* Layer manager interface includes*/
  35 #include "crg.h"           /* CRG interface includes*/
  36 #include "rgu.h"           /* RGU interface includes*/
  37 #include "tfu.h"           /* TFU interface includes */
  38 #include "rg_sch_inf.h"    /* SCH interface includes */
  39 #include "rg_prg.h"       /* PRG (MAC-MAC) interface includes*/
  40 #include "rg_env.h"       /* MAC environmental includes*/
  41 #include "rg.h"           /* MAC includes*/
  42 #include "rg_err.h"       /* MAC error includes*/
  43 #include "du_log.h"
  44 #include "lwr_mac_fsm.h"
  45
  46 /* header/extern include files (.x) */
  47 #include "gen.x"           /* general layer typedefs */
  48 #include "ssi.x"           /* system services typedefs */
  49 #include "cm5.x"           /* common timers */
  50 #include "cm_hash.x"       /* common hash list */
  51 #include "cm_lib.x"        /* common library */
  52 #include "cm_llist.x"      /* common linked list */
  53 #include "cm_mblk.x"       /* memory management */
  54 #include "cm_tkns.x"       /* common tokens */
  55 #include "cm_lte.x"       /* common tokens */
  56 #include "rgu.x"           /* RGU types */
  57 #include "tfu.x"           /* RGU types */
  58 #include "lrg.x"           /* layer management typedefs for MAC */
  59 #include "crg.x"           /* CRG interface includes */
  60 #include "rg_sch_inf.x"    /* SCH interface typedefs */
  61 #include "rg_prg.x"        /* PRG (MAC-MAC) Interface typedefs */
  62 #include "du_app_mac_inf.h"
  63 #include "mac.h"
  64 #include "rg.x"            /* typedefs for MAC */
  65 #include "lwr_mac_phy.h"
  66 #include "common_def.h"
  67 #include "math.h"
  68
  69 #define MIB_SFN_BITMASK 0xFC
  70 #define PDCCH_PDU_TYPE 0
  71 #define PDSCH_PDU_TYPE 1
  72 #define SSB_PDU_TYPE 3
  73 #define PRACH_PDU_TYPE 0
  74 #define PUSCH_PDU_TYPE 1
  75 #define PDU_PRESENT 1
  76 #define SET_MSG_LEN(x, size) x += size
  77
  78 extern void fapiMacConfigRsp();
  79 extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
  80
  81 /* Global variables */
  82 uint8_t slotIndIdx;
  83 uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo);
  84
  85 void lwrMacInit()
  86 {
  87 #ifdef INTEL_WLS
  88    uint8_t  idx;
  89
  90    /* Initializing WLS free mem list */
  91    slotIndIdx = 1;
  92    for(idx = 0; idx < WLS_MEM_FREE_PRD; idx++)
  93    {
  94       cmLListInit(&wlsBlockToFreeList[idx]);
  95    }
  96 #endif
  97 }
  98
  99  /*******************************************************************
 100   *
 101   * @brief Handles Invalid Request Event
 102   *
 103   * @details
 104   *
 105   *    Function : lwr_mac_handleInvalidEvt
 106   *
 107   *    Functionality:
 108   *         - Displays the PHY state when the invalid event occurs
 109   *
 110   * @params[in]
 111   * @return ROK     - success
 112   *         RFAILED - failure
 113   *
 114   * ****************************************************************/
 115 S16 lwr_mac_handleInvalidEvt(void *msg)
 116 {
 117    printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
 118    RETVALUE(ROK);
 119 }
 120
 121 #ifdef FAPI
 122 /*******************************************************************
 123   *
 124   * @brief Fills FAPI message header
 125   *
 126   * @details
 127   *
 128   *    Function : fillMsgHeader
 129   *
 130   *    Functionality:
 131   *         -Fills FAPI message header
 132   *
 133   * @params[in] Pointer to header
 134   *             Number of messages
 135   *             Messae Type
 136   *             Length of message
 137   * @return void
 138   *
 139   * ****************************************************************/
 140 PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
 141 {
 142    hdr->message_type_id = msgType;
 143    hdr->length = msgLen;
 144 }
 145
 146 /*******************************************************************
 147   *
 148   * @brief Fills FAPI Config Request message header
 149   *
 150   * @details
 151   *
 152   *    Function : fillTlvs
 153   *
 154   *    Functionality:
 155   *         -Fills FAPI Config Request message header
 156   *
 157   * @params[in] Pointer to TLV
 158   *             Tag
 159   *             Length
 160   *             Value
 161   *             MsgLen
 162   * @return void
 163   *
 164   * ****************************************************************/
 165 PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length,
 166 uint16_t value, uint32_t *msgLen)
 167 {
 168    tlv->tl.tag    = tag;
 169    tlv->tl.length = length;
 170    tlv->value     = value;
 171    *msgLen        = *msgLen + sizeof(tag) + sizeof(length) + length;
 172 }
 173  /*******************************************************************
 174   *
 175   * @brief fills the cyclic prefix by comparing the bitmask
 176   *
 177   * @details
 178   *
 179   *    Function : fillCyclicPrefix
 180   *
 181   *    Functionality:
 182   *         -checks the value with the bitmask and
 183   *          fills the cellPtr's cyclic prefix.
 184   *
 185   * @params[in] Pointer to ClCellParam
 186   *             Value to be compared
 187   * @return void
 188   *
 189   ********************************************************************/
 190 PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
 191 {
 192    if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
 193    {
 194       (*cellPtr)->cyclicPrefix   = NORMAL_CYCLIC_PREFIX_MASK;
 195    }
 196    else if((value & FAPI_EXTENDED_CYCLIC_PREFIX_MASK) == FAPI_EXTENDED_CYCLIC_PREFIX_MASK)
 197    {
 198       (*cellPtr)->cyclicPrefix   = EXTENDED_CYCLIC_PREFIX_MASK;
 199    }
 200    else
 201    {
 202       (*cellPtr)->cyclicPrefix = INVALID_VALUE;
 203    }
 204 }
 205
 206  /*******************************************************************
 207   *
 208   * @brief fills the subcarrier spacing of Downlink by comparing the bitmask
 209   *
 210   * @details
 211   *
 212   *    Function : fillSubcarrierSpaceDl
 213   *
 214   *    Functionality:
 215   *         -checks the value with the bitmask and
 216   *          fills the cellPtr's subcarrier spacing in DL
 217   *
 218   * @params[in] Pointer to ClCellParam
 219   *             Value to be compared
 220   * @return void
 221   *
 222   * ****************************************************************/
 223
 224 PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
 225 {
 226    if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
 227    {
 228       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_15_KHZ;
 229    }
 230    else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
 231    {
 232       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_30_KHZ;
 233    }
 234    else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
 235    {
 236       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_60_KHZ;
 237    }
 238    else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
 239    {
 240       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_120_KHZ;
 241    }
 242    else
 243    {
 244       (*cellPtr)->supportedSubcarrierSpacingDl = INVALID_VALUE;
 245    }
 246 }
 247
 248  /*******************************************************************
 249   *
 250   * @brief fills the downlink bandwidth by comparing the bitmask
 251   *
 252   * @details
 253   *
 254   *    Function : fillBandwidthDl
 255   *
 256   *    Functionality:
 257   *         -checks the value with the bitmask and
 258   *         -fills the cellPtr's DL Bandwidth
 259   *
 260   * @params[in] Pointer to ClCellParam
 261   *             Value to be compared
 262   * @return void
 263   *
 264   * ****************************************************************/
 265
 266 PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
 267 {
 268    if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
 269    {
 270       (*cellPtr)->supportedBandwidthDl = BW_5MHZ;
 271    }
 272    else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
 273    {
 274       (*cellPtr)->supportedBandwidthDl = BW_10MHZ;
 275    }
 276    else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
 277    {
 278       (*cellPtr)->supportedBandwidthDl = BW_15MHZ;
 279    }
 280    else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
 281    {
 282       (*cellPtr)->supportedBandwidthDl = BW_20MHZ;
 283    }
 284    else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
 285    {
 286       (*cellPtr)->supportedBandwidthDl = BW_40MHZ;
 287    }
 288    else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
 289    {
 290       (*cellPtr)->supportedBandwidthDl = BW_50MHZ;
 291    }
 292    else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
 293    {
 294       (*cellPtr)->supportedBandwidthDl = BW_60MHZ;
 295    }
 296    else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
 297    {
 298       (*cellPtr)->supportedBandwidthDl = BW_70MHZ;
 299    }
 300    else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
 301    {
 302       (*cellPtr)->supportedBandwidthDl = BW_80MHZ;
 303    }
 304    else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
 305    {
 306       (*cellPtr)->supportedBandwidthDl = BW_90MHZ;
 307    }
 308    else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
 309    {
 310       (*cellPtr)->supportedBandwidthDl = BW_100MHZ;
 311    }
 312    else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
 313    {
 314       (*cellPtr)->supportedBandwidthDl = BW_200MHZ;
 315    }
 316    else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
 317    {
 318       (*cellPtr)->supportedBandwidthDl = BW_400MHZ;
 319    }
 320    else
 321    {
 322       (*cellPtr)->supportedBandwidthDl = INVALID_VALUE;
 323    }
 324 }
 325
 326  /*******************************************************************
 327   *
 328   * @brief fills the subcarrier spacing of Uplink by comparing the bitmask
 329   *
 330   * @details
 331   *
 332   *    Function : fillSubcarrierSpaceUl
 333   *
 334   *    Functionality:
 335   *         -checks the value with the bitmask and
 336   *         -fills cellPtr's subcarrier spacing in UL
 337   *
 338   * @params[in] Pointer to ClCellParam
 339   *             Value to be compared
 340   * @return void
 341   *
 342   * ****************************************************************/
 343
 344 PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
 345 {
 346    if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
 347    {
 348       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_15_KHZ;
 349    }
 350    else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
 351    {
 352       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_30_KHZ;
 353    }
 354    else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
 355    {
 356       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_60_KHZ;
 357    }
 358    else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
 359    {
 360       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_120_KHZ;
 361    }
 362    else
 363    {
 364       (*cellPtr)->supportedSubcarrierSpacingsUl = INVALID_VALUE;
 365    }
 366 }
 367
 368  /*******************************************************************
 369   *
 370   * @brief fills the uplink bandwidth by comparing the bitmask
 371   *
 372   * @details
 373   *
 374   *    Function : fillBandwidthUl
 375   *
 376   *    Functionality:
 377   *         -checks the value with the bitmask and
 378   *          fills the cellPtr's UL Bandwidth
 379   *
 380   *
 381   *
 382   * @params[in] Pointer to ClCellParam
 383   *             Value to be compared
 384   * @return void
 385   *
 386   *
 387   * ****************************************************************/
 388
 389 PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
 390 {
 391    if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
 392    {
 393       (*cellPtr)->supportedBandwidthUl = BW_5MHZ;
 394    }
 395    else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
 396    {
 397       (*cellPtr)->supportedBandwidthUl = BW_10MHZ;
 398    }
 399    else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
 400    {
 401       (*cellPtr)->supportedBandwidthUl = BW_15MHZ;
 402    }
 403    else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
 404    {
 405       (*cellPtr)->supportedBandwidthUl = BW_20MHZ;
 406    }
 407    else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
 408    {
 409       (*cellPtr)->supportedBandwidthUl = BW_40MHZ;
 410    }
 411    else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
 412    {
 413       (*cellPtr)->supportedBandwidthUl = BW_50MHZ;
 414    }
 415    else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
 416    {
 417       (*cellPtr)->supportedBandwidthUl = BW_60MHZ;
 418    }
 419    else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
 420    {
 421       (*cellPtr)->supportedBandwidthUl = BW_70MHZ;
 422    }
 423    else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
 424    {
 425       (*cellPtr)->supportedBandwidthUl = BW_80MHZ;
 426    }
 427    else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
 428    {
 429       (*cellPtr)->supportedBandwidthUl = BW_90MHZ;
 430    }
 431    else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
 432    {
 433       (*cellPtr)->supportedBandwidthUl = BW_100MHZ;
 434    }
 435    else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
 436    {
 437       (*cellPtr)->supportedBandwidthUl = BW_200MHZ;
 438    }
 439    else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
 440    {
 441       (*cellPtr)->supportedBandwidthUl = BW_400MHZ;
 442    }
 443    else
 444    {
 445       (*cellPtr)->supportedBandwidthUl = INVALID_VALUE;
 446    }
 447 }
 448  /*******************************************************************
 449   *
 450   * @brief fills the CCE maping by comparing the bitmask
 451   *
 452   * @details
 453   *
 454   *    Function : fillCCEmaping
 455   *
 456   *    Functionality:
 457   *         -checks the value with the bitmask and
 458   *          fills the cellPtr's CCE Mapping Type
 459   *
 460   *
 461   * @params[in] Pointer to ClCellParam
 462   *             Value to be compared
 463   * @return void
 464   *
 465   * ****************************************************************/
 466
 467 PUBLIC void fillCCEmaping(uint8_t value,  ClCellParam **cellPtr)
 468 {
 469    if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
 470    {
 471       (*cellPtr)->cceMappingType = CCE_MAPPING_INTERLEAVED_MASK;
 472    }
 473    else if((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_NONINTERLVD_MASK)
 474    {
 475       (*cellPtr)->cceMappingType = CCE_MAPPING_NONINTERLVD_MASK;
 476    }
 477    else
 478    {
 479       (*cellPtr)->cceMappingType = INVALID_VALUE;
 480    }
 481 }
 482
 483  /*******************************************************************
 484   *
 485   * @brief fills the PUCCH format by comparing the bitmask
 486   *
 487   * @details
 488   *
 489   *    Function : fillPucchFormat
 490   *
 491   *    Functionality:
 492   *         -checks the value with the bitmask and
 493   *          fills the cellPtr's pucch format
 494   *
 495   *
 496   * @params[in] Pointer to ClCellParam
 497   *             Value to be compared
 498   * @return void
 499   *
 500   * ****************************************************************/
 501
 502 PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
 503 {
 504    if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
 505    {
 506       (*cellPtr)->pucchFormats    = FORMAT_0;
 507    }
 508    else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
 509    {
 510       (*cellPtr)->pucchFormats    = FORMAT_1;
 511    }
 512    else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
 513    {
 514       (*cellPtr)->pucchFormats    = FORMAT_2;
 515    }
 516    else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
 517    {
 518       (*cellPtr)->pucchFormats    = FORMAT_3;
 519    }
 520    else if((value & FAPI_FORMAT_4_MASK) == FAPI_FORMAT_4_MASK)
 521    {
 522       (*cellPtr)->pucchFormats    = FORMAT_4;
 523    }
 524    else
 525    {
 526       (*cellPtr)->pucchFormats    = INVALID_VALUE;
 527    }
 528 }
 529
 530  /*******************************************************************
 531   *
 532   * @brief fills the PDSCH Mapping Type by comparing the bitmask
 533   *
 534   * @details
 535   *
 536   *    Function : fillPdschMappingType
 537   *
 538   *    Functionality:
 539   *         -checks the value with the bitmask and
 540   *          fills the cellPtr's PDSCH MappingType
 541   *
 542   * @params[in] Pointer to ClCellParam
 543   *             Value to be compared
 544   * @return void
 545   *
 546   * ****************************************************************/
 547
 548 PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
 549 {
 550    if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
 551    {
 552       (*cellPtr)->pdschMappingType = MAPPING_TYPE_A;
 553    }
 554    else if((value & FAPI_PDSCH_MAPPING_TYPE_B_MASK) == FAPI_PDSCH_MAPPING_TYPE_B_MASK)
 555    {
 556       (*cellPtr)->pdschMappingType = MAPPING_TYPE_B;
 557    }
 558    else
 559    {
 560       (*cellPtr)->pdschMappingType = INVALID_VALUE;
 561    }
 562 }
 563
 564 /*******************************************************************
 565   *
 566   * @brief fills the PDSCH Allocation Type by comparing the bitmask
 567   *
 568   * @details
 569   *
 570   *    Function : fillPdschAllocationType
 571   *
 572   *    Functionality:
 573   *         -checks the value with the bitmask and
 574   *          fills the cellPtr's PDSCH AllocationType
 575   *
 576   * @params[in] Pointer to ClCellParam
 577   *             Value to be compared
 578   * @return void
 579   *
 580   * ****************************************************************/
 581
 582 PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
 583 {
 584    if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
 585    {
 586       (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_0;
 587    }
 588    else if((value & FAPI_PDSCH_ALLOC_TYPE_1_MASK) == FAPI_PDSCH_ALLOC_TYPE_1_MASK)
 589    {
 590       (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_1;
 591    }
 592    else
 593    {
 594       (*cellPtr)->pdschAllocationTypes = INVALID_VALUE;
 595    }
 596 }
 597
 598 /*******************************************************************
 599   *
 600   * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask
 601   *
 602   * @details
 603   *
 604   *    Function : fillPrbMappingType
 605   *
 606   *    Functionality:
 607   *         -checks the value with the bitmask and
 608   *          fills the cellPtr's PRB Mapping Type
 609   *
 610   * @params[in] Pointer to ClCellParam
 611   *             Value to be compared
 612   * @return void
 613   *
 614   ******************************************************************/
 615 PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
 616 {
 617    if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
 618    {
 619       (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
 620    }
 621    else if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
 622    {
 623       (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
 624    }
 625    else
 626    {
 627       (*cellPtr)->pdschVrbToPrbMapping = INVALID_VALUE;
 628    }
 629 }
 630
 631 /*******************************************************************
 632   *
 633   * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask
 634   *
 635   * @details
 636   *
 637   *    Function : fillPdschDmrsConfigType
 638   *
 639   *    Functionality:
 640   *         -checks the value with the bitmask and
 641   *          fills the cellPtr's DmrsConfig Type
 642   *
 643   * @params[in] Pointer to ClCellParam
 644   *             Value to be compared
 645   * @return void
 646   *
 647   ******************************************************************/
 648
 649 PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
 650 {
 651    if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
 652    {
 653       (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
 654    }
 655    else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK)
 656    {
 657       (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
 658    }
 659    else
 660    {
 661       (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE;
 662    }
 663 }
 664
 665 /*******************************************************************
 666   *
 667   * @brief fills the PDSCH DmrsLength by comparing the bitmask
 668   *
 669   * @details
 670   *
 671   *    Function : fillPdschDmrsLength
 672   *
 673   *    Functionality:
 674   *         -checks the value with the bitmask and
 675   *          fills the cellPtr's PdschDmrsLength
 676   *
 677   * @params[in] Pointer to ClCellParam
 678   *             Value to be compared
 679   * @return void
 680   *
 681   ******************************************************************/
 682 PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
 683 {
 684    if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
 685    {
 686       (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_1;
 687    }
 688    else if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_2)
 689    {
 690       (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_2;
 691    }
 692    else
 693    {
 694       (*cellPtr)->pdschDmrsMaxLength = INVALID_VALUE;
 695    }
 696 }
 697
 698 /*******************************************************************
 699   *
 700   * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask
 701   *
 702   * @details
 703   *
 704   *    Function : fillPdschDmrsAddPos
 705   *
 706   *    Functionality:
 707   *         -checks the value with the bitmask and
 708   *          fills the cellPtr's Pdsch DmrsAddPos
 709   *
 710   * @params[in] Pointer to ClCellParam
 711   *             Value to be compared
 712   * @return void
 713   *
 714   ******************************************************************/
 715
 716 PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
 717 {
 718    if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
 719    {
 720       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
 721    }
 722    else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
 723    {
 724       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
 725    }
 726    else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
 727    {
 728       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
 729    }
 730    else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
 731    {
 732       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
 733    }
 734    else
 735    {
 736       (*cellPtr)->pdschDmrsAdditionalPos = INVALID_VALUE;
 737    }
 738 }
 739
 740 /*******************************************************************
 741   *
 742   * @brief fills the Modulation Order in DL by comparing the bitmask
 743   *
 744   * @details
 745   *
 746   *    Function : fillModulationOrderDl
 747   *
 748   *    Functionality:
 749   *         -checks the value with the bitmask and
 750   *          fills the cellPtr's ModulationOrder in DL.
 751   *
 752   * @params[in] Pointer to ClCellParam
 753   *             Value to be compared
 754   * @return void
 755   *
 756   ******************************************************************/
 757 PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
 758 {
 759    if(value == 0 )
 760    {
 761       (*cellPtr)->supportedMaxModulationOrderDl = MOD_QPSK;
 762    }
 763    else if(value == 1)
 764    {
 765       (*cellPtr)->supportedMaxModulationOrderDl = MOD_16QAM;
 766    }
 767    else if(value == 2)
 768    {
 769       (*cellPtr)->supportedMaxModulationOrderDl = MOD_64QAM;
 770    }
 771    else if(value == 3)
 772    {
 773       (*cellPtr)->supportedMaxModulationOrderDl = MOD_256QAM;
 774    }
 775    else
 776    {
 777       (*cellPtr)->supportedMaxModulationOrderDl = INVALID_VALUE;
 778    }
 779 }
 780
 781 /*******************************************************************
 782   *
 783   * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask
 784   *
 785   * @details
 786   *
 787   *    Function : fillPuschDmrsConfigType
 788   *
 789   *    Functionality:
 790   *         -checks the value with the bitmask and
 791   *          fills the cellPtr's PUSCH DmrsConfigType
 792   *
 793   * @params[in] Pointer to ClCellParam
 794   *             Value to be compared
 795   * @return void
 796   *
 797   ******************************************************************/
 798
 799 PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
 800 {
 801    if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
 802    {
 803       (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
 804    }
 805    else if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK)
 806    {
 807       (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
 808    }
 809    else
 810    {
 811       (*cellPtr)->puschDmrsConfigTypes = INVALID_VALUE;
 812    }
 813 }
 814
 815 /*******************************************************************
 816   *
 817   * @brief fills the PUSCH DmrsLength by comparing the bitmask
 818   *
 819   * @details
 820   *
 821   *    Function : fillPuschDmrsLength
 822   *
 823   *    Functionality:
 824   *         -checks the value with the bitmask and
 825   *          fills the cellPtr's PUSCH DmrsLength
 826   *
 827   * @params[in] Pointer to ClCellParam
 828   *             Value to be compared
 829   * @return void
 830   *
 831   ******************************************************************/
 832
 833 PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
 834 {
 835    if(value  == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
 836    {
 837       (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_1;
 838    }
 839    else if(value  == FAPI_PUSCH_DMRS_MAX_LENGTH_2)
 840    {
 841       (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_2;
 842    }
 843    else
 844    {
 845       (*cellPtr)->puschDmrsMaxLength = INVALID_VALUE;
 846    }
 847 }
 848
 849 /*******************************************************************
 850   *
 851   * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask
 852   *
 853   * @details
 854   *
 855   *    Function : fillPuschDmrsAddPos
 856   *
 857   *    Functionality:
 858   *         -checks the value with the bitmask and
 859   *          fills the cellPtr's PUSCH DmrsAddPos
 860   *
 861   * @params[in] Pointer to ClCellParam
 862   *             Value to be compared
 863   * @return void
 864   *
 865   ******************************************************************/
 866
 867 PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
 868 {
 869    if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
 870    {
 871       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
 872    }
 873    else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
 874    {
 875       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
 876    }
 877    else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
 878    {
 879       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
 880    }
 881    else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
 882    {
 883       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
 884    }
 885    else
 886    {
 887       (*cellPtr)->puschDmrsAdditionalPos = INVALID_VALUE;
 888    }
 889 }
 890
 891 /*******************************************************************
 892   *
 893   * @brief fills the PUSCH Mapping Type by comparing the bitmask
 894   *
 895   * @details
 896   *
 897   *    Function : fillPuschMappingType
 898   *
 899   *    Functionality:
 900   *         -checks the value with the bitmask and
 901   *          fills the cellPtr's PUSCH MappingType
 902   *
 903   * @params[in] Pointer to ClCellParam
 904   *             Value to be compared
 905   * @return void
 906   *
 907   ******************************************************************/
 908
 909 PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
 910 {
 911    if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
 912    {
 913       (*cellPtr)->puschMappingType = MAPPING_TYPE_A;
 914    }
 915    else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK)
 916    {
 917       (*cellPtr)->puschMappingType = MAPPING_TYPE_B;
 918    }
 919    else
 920    {
 921       (*cellPtr)->puschMappingType = INVALID_VALUE;
 922    }
 923 }
 924
 925 /*******************************************************************
 926   *
 927   * @brief fills the PUSCH Allocation Type by comparing the bitmask
 928   *
 929   * @details
 930   *
 931   *    Function : fillPuschAllocationType
 932   *
 933   *    Functionality:
 934   *         -checks the value with the bitmask and
 935   *          fills the cellPtr's PUSCH AllocationType
 936   *
 937   * @params[in] Pointer to ClCellParam
 938   *             Value to be compared
 939   * @return void
 940   *
 941   ******************************************************************/
 942
 943 PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
 944 {
 945    if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
 946    {
 947       (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_0;
 948    }
 949    else if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
 950    {
 951       (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_1;
 952    }
 953    else
 954    {
 955       (*cellPtr)->puschAllocationTypes = INVALID_VALUE;
 956    }
 957 }
 958
 959 /*******************************************************************
 960   *
 961   * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask
 962   *
 963   * @details
 964   *
 965   *    Function : fillPuschPrbMappingType
 966   *
 967   *    Functionality:
 968   *         -checks the value with the bitmask and
 969   *          fills the cellPtr's PUSCH PRB MApping Type
 970   *
 971   * @params[in] Pointer to ClCellParam
 972   *             Value to be compared
 973   * @return void
 974   *
 975   ******************************************************************/
 976
 977 PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
 978 {
 979    if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
 980    {
 981       (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
 982    }
 983    else if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
 984    {
 985       (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
 986    }
 987    else
 988    {
 989       (*cellPtr)->puschVrbToPrbMapping = INVALID_VALUE;
 990    }
 991 }
 992
 993 /*******************************************************************
 994   *
 995   * @brief fills the Modulation Order in Ul by comparing the bitmask
 996   *
 997   * @details
 998   *
 999   *    Function : fillModulationOrderUl
1000   *
1001   *    Functionality:
1002   *         -checks the value with the bitmask and
1003   *          fills the cellPtr's Modualtsion Order in UL.
1004   *
1005   * @params[in] Pointer to ClCellParam
1006   *             Value to be compared
1007   * @return void
1008   *
1009   ******************************************************************/
1010
1011 PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
1012 {
1013    if(value == 0)
1014    {
1015       (*cellPtr)->supportedModulationOrderUl = MOD_QPSK;
1016    }
1017    else if(value == 1)
1018    {
1019       (*cellPtr)->supportedModulationOrderUl = MOD_16QAM;
1020    }
1021    else if(value == 2)
1022    {
1023       (*cellPtr)->supportedModulationOrderUl = MOD_64QAM;
1024    }
1025    else if(value == 3)
1026    {
1027       (*cellPtr)->supportedModulationOrderUl = MOD_256QAM;
1028    }
1029    else
1030    {
1031       (*cellPtr)->supportedModulationOrderUl = INVALID_VALUE;
1032    }
1033 }
1034
1035 /*******************************************************************
1036   *
1037   * @brief fills the PUSCH Aggregation Factor by comparing the bitmask
1038   *
1039   * @details
1040   *
1041   *    Function : fillPuschAggregationFactor
1042   *
1043   *    Functionality:
1044   *         -checks the value with the bitmask and
1045   *          fills the cellPtr's PUSCH Aggregation Factor
1046   *
1047   * @params[in] Pointer to ClCellParam
1048   *             Value to be compared
1049   * @return void
1050   *
1051   ******************************************************************/
1052
1053 PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
1054 {
1055    if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
1056    {
1057       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_1;
1058    }
1059    else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
1060    {
1061       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_2;
1062    }
1063    else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
1064    {
1065       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_4;
1066    }
1067    else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
1068    {
1069       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_8;
1070    }
1071    else
1072    {
1073       (*cellPtr)->puschAggregationFactor    = INVALID_VALUE;
1074    }
1075 }
1076
1077 /*******************************************************************
1078   *
1079   * @brief fills the PRACH Long Format by comparing the bitmask
1080   *
1081   * @details
1082   *
1083   *    Function : fillPrachLongFormat
1084   *
1085   *    Functionality:
1086   *         -checks the value with the bitmask and
1087   *          fills the cellPtr's PRACH Long Format
1088   *
1089   * @params[in] Pointer to ClCellParam
1090   *             Value to be compared
1091   * @return void
1092   *
1093   ******************************************************************/
1094
1095 PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
1096 {
1097    if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
1098    {
1099       (*cellPtr)->prachLongFormats    = FORMAT_0;
1100    }
1101    else if((value & FAPI_PRACH_LF_FORMAT_1_MASK) == FAPI_PRACH_LF_FORMAT_1_MASK)
1102    {
1103       (*cellPtr)->prachLongFormats    = FORMAT_1;
1104    }
1105    else if((value & FAPI_PRACH_LF_FORMAT_2_MASK) == FAPI_PRACH_LF_FORMAT_2_MASK)
1106    {
1107       (*cellPtr)->prachLongFormats    = FORMAT_2;
1108    }
1109    else if((value & FAPI_PRACH_LF_FORMAT_3_MASK) == FAPI_PRACH_LF_FORMAT_3_MASK)
1110    {
1111       (*cellPtr)->prachLongFormats    = FORMAT_3;
1112    }
1113    else
1114    {
1115       (*cellPtr)->prachLongFormats    = INVALID_VALUE;
1116    }
1117 }
1118
1119 /*******************************************************************
1120   *
1121   * @brief fills the PRACH Short Format by comparing the bitmask
1122   *
1123   * @details
1124   *
1125   *    Function : fillPrachShortFormat
1126   *
1127   *    Functionality:
1128   *         -checks the value with the bitmask and
1129   *          fills the cellPtr's PRACH ShortFormat
1130   *
1131   * @params[in] Pointer to ClCellParam
1132   *             Value to be compared
1133   * @return void
1134   *
1135   ******************************************************************/
1136
1137 PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
1138 {
1139    if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
1140    {
1141       (*cellPtr)->prachShortFormats    = SF_FORMAT_A1;
1142    }
1143    else if((value & FAPI_PRACH_SF_FORMAT_A2_MASK) == FAPI_PRACH_SF_FORMAT_A2_MASK)
1144    {
1145       (*cellPtr)->prachShortFormats    = SF_FORMAT_A2;
1146    }
1147    else if((value & FAPI_PRACH_SF_FORMAT_A3_MASK) == FAPI_PRACH_SF_FORMAT_A3_MASK)
1148    {
1149       (*cellPtr)->prachShortFormats    = SF_FORMAT_A3;
1150    }
1151    else if((value & FAPI_PRACH_SF_FORMAT_B1_MASK) == FAPI_PRACH_SF_FORMAT_B1_MASK)
1152    {
1153       (*cellPtr)->prachShortFormats    = SF_FORMAT_B1;
1154    }
1155    else if((value & FAPI_PRACH_SF_FORMAT_B2_MASK) == FAPI_PRACH_SF_FORMAT_B2_MASK)
1156    {
1157       (*cellPtr)->prachShortFormats    = SF_FORMAT_B2;
1158    }
1159    else if((value & FAPI_PRACH_SF_FORMAT_B3_MASK) == FAPI_PRACH_SF_FORMAT_B3_MASK)
1160    {
1161       (*cellPtr)->prachShortFormats    = SF_FORMAT_B3;
1162    }
1163    else if((value & FAPI_PRACH_SF_FORMAT_B4_MASK) == FAPI_PRACH_SF_FORMAT_B4_MASK)
1164    {
1165       (*cellPtr)->prachShortFormats    = SF_FORMAT_B4;
1166    }
1167    else if((value & FAPI_PRACH_SF_FORMAT_C0_MASK) == FAPI_PRACH_SF_FORMAT_C0_MASK)
1168    {
1169       (*cellPtr)->prachShortFormats    = SF_FORMAT_C0;
1170    }
1171    else if((value & FAPI_PRACH_SF_FORMAT_C2_MASK) == FAPI_PRACH_SF_FORMAT_C2_MASK)
1172    {
1173       (*cellPtr)->prachShortFormats    = SF_FORMAT_C2;
1174    }
1175    else
1176    {
1177       (*cellPtr)->prachShortFormats    = INVALID_VALUE;
1178    }
1179 }
1180
1181 /*******************************************************************
1182   *
1183   * @brief fills the Fd Occasions Type by comparing the bitmask
1184   *
1185   * @details
1186   *
1187   *    Function : fillFdOccasions
1188   *
1189   *    Functionality:
1190   *         -checks the value with the bitmask and
1191   *          fills the cellPtr's Fd Occasions
1192   *
1193   * @params[in] Pointer to ClCellParam
1194   *             Value to be compared
1195   * @return void
1196   *
1197   ******************************************************************/
1198
1199 PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
1200 {
1201    if(value == 0)
1202    {
1203       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_1;
1204    }
1205    else if(value == 1)
1206    {
1207       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_2;
1208    }
1209    else if(value == 3)
1210    {
1211       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_4;
1212    }
1213    else if(value == 4)
1214    {
1215       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_8;
1216    }
1217    else
1218    {
1219       (*cellPtr)->maxPrachFdOccasionsInASlot = INVALID_VALUE;
1220    }
1221 }
1222
1223 /*******************************************************************
1224   *
1225   * @brief fills the RSSI Measurement by comparing the bitmask
1226   *
1227   * @details
1228   *
1229   *    Function : fillRssiMeas
1230   *
1231   *    Functionality:
1232   *         -checks the value with the bitmask and
1233   *          fills the cellPtr's RSSI Measurement report
1234   *
1235   * @params[in] Pointer to ClCellParam
1236   *             Value to be compared
1237   * @return void
1238   *
1239   ******************************************************************/
1240
1241 PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
1242 {
1243    if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
1244    {
1245       (*cellPtr)->rssiMeasurementSupport    = RSSI_REPORT_DBM;
1246    }
1247    else if((value & FAPI_RSSI_REPORT_IN_DBFS_MASK) == FAPI_RSSI_REPORT_IN_DBFS_MASK)
1248    {
1249       (*cellPtr)->rssiMeasurementSupport    = RSSI_REPORT_DBFS;
1250    }
1251    else
1252    {
1253       (*cellPtr)->rssiMeasurementSupport    = INVALID_VALUE;
1254    }
1255 }
1256
1257  /*******************************************************************
1258   *
1259   * @brief Returns the TLVs value
1260   *
1261   * @details
1262   *
1263   *    Function : getParamValue
1264   *
1265   *    Functionality:
1266   *         -return TLVs value
1267   *
1268   * @params[in]
1269   * @return ROK     - temp
1270   *         RFAILED - failure
1271   *
1272   * ****************************************************************/
1273
1274 uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
1275 {
1276    //uint16_t valueLen;
1277    void *posPtr;
1278    //valueLen = tlv->tl.length;
1279    posPtr   = &tlv->tl.tag;
1280    posPtr   += sizeof(tlv->tl.tag);
1281    posPtr   += sizeof(tlv->tl.length);
1282    /*TO DO: malloc to SSI memory */
1283    if(type == FAPI_UINT_8)
1284    {
1285       //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
1286       //memcpy(temp, posPtr, valueLen);
1287       return(*(uint8_t *)posPtr);
1288    }
1289    else if(type == FAPI_UINT_16)
1290    {
1291       return(*(uint16_t *)posPtr);
1292    }
1293    else if(type == FAPI_UINT_32)
1294    {
1295       return(*(uint32_t *)posPtr);
1296    }
1297    else
1298    {
1299      DU_LOG("\nLWR_MAC: Value Extraction failed" );
1300      return RFAILED;
1301    }
1302 }
1303 #endif /* FAPI */
1304  /*******************************************************************
1305   *
1306   * @brief Sends FAPI Param req to PHY
1307   *
1308   * @details
1309   *
1310   *    Function : lwr_mac_handleParamReqEvt
1311   *
1312   *    Functionality:
1313   *         -Sends FAPI Param req to PHY
1314   *
1315   * @params[in]
1316   * @return ROK     - success
1317   *         RFAILED - failure
1318   *
1319   * ****************************************************************/
1320
1321 S16 lwr_mac_handleParamReqEvt(void *msg)
1322 {
1323 #ifdef FAPI
1324    /* startGuardTimer(); */
1325    uint32_t msgLen = 0;             //Length of message Body
1326    fapi_param_req_t *paramReq = NULL;
1327
1328    LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
1329    if(paramReq != NULL)
1330    {
1331       fillMsgHeader(&paramReq->header, FAPI_PARAM_REQUEST, msgLen);
1332
1333       DU_LOG("\nLWR_MAC: Sending Param Request to Phy");
1334       LwrMacSendToPhy(paramReq->header.message_type_id, \
1335          sizeof(fapi_param_req_t), (void *)paramReq);
1336    }
1337    else
1338    {
1339       DU_LOG("\nLWR_MAC: Failed to allocate memory for Param Request");
1340       return RFAILED;
1341    }
1342 #endif
1343    return ROK;
1344 }
1345
1346  /*******************************************************************
1347   *
1348   * @brief Sends FAPI Param Response to MAC via PHY
1349   *
1350   * @details
1351   *
1352   *    Function : lwr_mac_handleParamRspEvt
1353   *
1354   *    Functionality:
1355   *         -Sends FAPI Param rsp to MAC via PHY
1356   *
1357   * @params[in]
1358   * @return ROK     - success
1359   *         RFAILED - failure
1360   *
1361   * ****************************************************************/
1362
1363 S16 lwr_mac_handleParamRspEvt(void *msg)
1364 {
1365 #ifdef FAPI
1366   /* stopGuardTimer(); */
1367    uint8_t index;
1368    uint32_t encodedVal;
1369    fapi_param_resp_t *paramRsp;
1370    ClCellParam *cellParam = NULLP;
1371
1372    paramRsp = (fapi_param_resp_t *)msg;
1373    DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1374
1375    if(paramRsp != NULLP)
1376    {
1377       MAC_ALLOC(cellParam, sizeof(ClCellParam));
1378       if(cellParam != NULLP)
1379       {
1380          DU_LOG("\n LWR_MAC: Filling TLVS into MAC API");
1381          if(paramRsp->error_code == MSG_OK)
1382          {
1383             for(index = 0; index < paramRsp->number_of_tlvs; index++)
1384             {
1385                switch(paramRsp->tlvs[index].tl.tag)
1386                {
1387                   case FAPI_RELEASE_CAPABILITY_TAG:
1388                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1389                      if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
1390                      {
1391                         cellParam->releaseCapability = RELEASE_15;
1392                      }
1393                      break;
1394
1395                   case FAPI_PHY_STATE_TAG:
1396                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1397                      if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
1398                      {
1399                         printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
1400                         RETVALUE(RFAILED);
1401                      }
1402                      break;
1403
1404                   case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
1405                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1406                      if(encodedVal != RFAILED && encodedVal != 0)
1407                      {
1408                         cellParam->skipBlankDlConfig = SUPPORTED;
1409                      }
1410                      else
1411                      {
1412                         cellParam->skipBlankDlConfig = NOT_SUPPORTED;
1413                      }
1414                      break;
1415
1416                   case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
1417                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1418                      if(encodedVal != RFAILED && encodedVal != 0)
1419                      {
1420                         cellParam->skipBlankUlConfig = SUPPORTED;
1421                      }
1422                      else
1423                      {
1424                         cellParam->skipBlankUlConfig = NOT_SUPPORTED;
1425                      }
1426                      break;
1427
1428                   case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
1429                      cellParam->numTlvsToReport = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1430                      break;
1431
1432                   case FAPI_CYCLIC_PREFIX_TAG:
1433                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1434                      if(encodedVal != RFAILED)
1435                      {
1436                         fillCyclicPrefix(encodedVal, &cellParam);
1437                      }
1438                      break;
1439
1440                   case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
1441                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1442                      if(encodedVal != RFAILED)
1443                      {
1444                         fillSubcarrierSpaceDl(encodedVal, &cellParam);
1445                      }
1446                      break;
1447
1448                   case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
1449                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1450                      if(encodedVal != RFAILED)
1451                      {
1452                         fillBandwidthDl(encodedVal, &cellParam);
1453                      }
1454                      break;
1455
1456                   case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
1457                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1458                      if(encodedVal != RFAILED)
1459                      {
1460                         fillSubcarrierSpaceUl(encodedVal, &cellParam);
1461                      }
1462                      break;
1463
1464                   case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
1465                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1466                      if(encodedVal != RFAILED)
1467                      {
1468                         fillBandwidthUl(encodedVal, &cellParam);
1469                      }
1470                      break;
1471
1472                   case FAPI_CCE_MAPPING_TYPE_TAG:
1473                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1474                      if(encodedVal != RFAILED)
1475                      {
1476                         fillCCEmaping(encodedVal, &cellParam);
1477                      }
1478                      break;
1479
1480                   case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
1481                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1482                      if(encodedVal != RFAILED && encodedVal != 0)
1483                      {
1484                         cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
1485                      }
1486                      else
1487                      {
1488                         cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
1489                      }
1490                      break;
1491
1492                   case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
1493                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1494                      if(encodedVal != RFAILED && encodedVal != 0)
1495                      {
1496                         cellParam->precoderGranularityCoreset = SUPPORTED;
1497                      }
1498                      else
1499                      {
1500                         cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
1501                      }
1502                      break;
1503
1504                   case FAPI_PDCCH_MU_MIMO_TAG:
1505                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1506                      if(encodedVal != RFAILED && encodedVal != 0)
1507                      {
1508                         cellParam->pdcchMuMimo = SUPPORTED;
1509                      }
1510                      else
1511                      {
1512                         cellParam->pdcchMuMimo = NOT_SUPPORTED;
1513                      }
1514                      break;
1515
1516                   case FAPI_PDCCH_PRECODER_CYCLING_TAG:
1517                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1518                      if(encodedVal != RFAILED && encodedVal != 0)
1519                      {
1520                         cellParam->pdcchPrecoderCycling = SUPPORTED;
1521                      }
1522                      else
1523                      {
1524                         cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
1525                      }
1526                      break;
1527
1528                   case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
1529                      cellParam->maxPdcchsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1530                      break;
1531
1532                   case FAPI_PUCCH_FORMATS_TAG:
1533                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1534                      if(encodedVal != RFAILED)
1535                      {
1536                         fillPucchFormat(encodedVal, &cellParam);
1537                      }
1538                      break;
1539
1540                   case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
1541                    cellParam->maxPucchsPerSlot   = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1542                      break;
1543
1544                   case FAPI_PDSCH_MAPPING_TYPE_TAG:
1545                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1546                      if(encodedVal != RFAILED)
1547                      {
1548                         fillPdschMappingType(encodedVal, &cellParam);
1549                      }
1550                      break;
1551
1552                   case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
1553                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1554                      if(encodedVal != RFAILED)
1555                      {
1556                         fillPdschAllocationType(encodedVal, &cellParam);
1557                      }
1558                      break;
1559
1560                   case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
1561                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1562                      if(encodedVal != RFAILED)
1563                      {
1564                         fillPrbMappingType(encodedVal, &cellParam);
1565                      }
1566                      break;
1567
1568                   case FAPI_PDSCH_CBG_TAG:
1569                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1570                      if(encodedVal != RFAILED && encodedVal != 0)
1571                      {
1572                         cellParam->pdschCbg = SUPPORTED;
1573                      }
1574                      else
1575                      {
1576                         cellParam->pdschCbg = NOT_SUPPORTED;
1577                      }
1578                      break;
1579
1580                   case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
1581                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1582                      if(encodedVal != RFAILED)
1583                      {
1584                         fillPdschDmrsConfigType(encodedVal, &cellParam);
1585                      }
1586                      break;
1587
1588                   case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
1589                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1590                      if(encodedVal != RFAILED)
1591                      {
1592                         fillPdschDmrsLength(encodedVal, &cellParam);
1593                      }
1594                      break;
1595
1596                   case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
1597                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1598                      if(encodedVal != RFAILED)
1599                      {
1600                         fillPdschDmrsAddPos(encodedVal, &cellParam);
1601                      }
1602                      break;
1603
1604                   case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
1605                      cellParam->maxPdschsTBsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1606                      break;
1607
1608                   case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
1609                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1610                      if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
1611                      {
1612                         cellParam->maxNumberMimoLayersPdsch   = encodedVal;
1613                      }
1614                      break;
1615
1616                   case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
1617                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1618                      if(encodedVal != RFAILED)
1619                      {
1620                         fillModulationOrderDl(encodedVal, &cellParam);
1621                      }
1622                      break;
1623
1624                   case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
1625                      cellParam->maxMuMimoUsersDl         = \
1626                                                            getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1627                      break;
1628
1629                   case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
1630                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1631                      if(encodedVal != RFAILED && encodedVal != 0)
1632                      {
1633                         cellParam->pdschDataInDmrsSymbols = SUPPORTED;
1634                      }
1635                      else
1636                      {
1637                         cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
1638                      }
1639                      break;
1640
1641                   case FAPI_PREMPTIONSUPPORT_TAG:
1642                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1643                      if(encodedVal != RFAILED && encodedVal != 0)
1644                      {
1645                         cellParam->premptionSupport = SUPPORTED;
1646                      }
1647                      else
1648                      {
1649                         cellParam->premptionSupport = NOT_SUPPORTED;
1650                      }
1651                      break;
1652
1653                   case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
1654                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1655                      if(encodedVal != RFAILED && encodedVal != 0)
1656                      {
1657                         cellParam->pdschNonSlotSupport = SUPPORTED;
1658                      }
1659                      else
1660                      {
1661                         cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
1662                      }
1663                      break;
1664
1665                   case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
1666                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1667                      if(encodedVal != RFAILED && encodedVal != 0)
1668                      {
1669                         cellParam->uciMuxUlschInPusch = SUPPORTED;
1670                      }
1671                      else
1672                      {
1673                         cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
1674                      }
1675                      break;
1676
1677                   case FAPI_UCI_ONLY_PUSCH_TAG:
1678                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1679                      if(encodedVal != RFAILED && encodedVal != 0)
1680                      {
1681                         cellParam->uciOnlyPusch = SUPPORTED;
1682                      }
1683                      else
1684                      {
1685                         cellParam->uciOnlyPusch = NOT_SUPPORTED;
1686                      }
1687                      break;
1688
1689                   case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
1690                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1691                      if(encodedVal != RFAILED && encodedVal != 0)
1692                      {
1693                         cellParam->puschFrequencyHopping = SUPPORTED;
1694                      }
1695                      else
1696                      {
1697                         cellParam->puschFrequencyHopping = NOT_SUPPORTED;
1698                      }
1699                      break;
1700
1701                  case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
1702                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1703                     if(encodedVal != RFAILED)
1704                     {
1705                        fillPuschDmrsConfig(encodedVal, &cellParam);
1706                     }
1707                     break;
1708
1709                  case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
1710                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1711                     if(encodedVal != RFAILED)
1712                     {
1713                        fillPuschDmrsLength(encodedVal, &cellParam);
1714                     }
1715                     break;
1716
1717                  case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
1718                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1719                     if(encodedVal != RFAILED)
1720                     {
1721                        fillPuschDmrsAddPos(encodedVal, &cellParam);
1722                     }
1723                     break;
1724
1725                  case FAPI_PUSCH_CBG_TAG:
1726                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1727                     if(encodedVal != RFAILED && encodedVal != 0)
1728                     {
1729                        cellParam->puschCbg = SUPPORTED;
1730                     }
1731                     else
1732                     {
1733                        cellParam->puschCbg = NOT_SUPPORTED;
1734                     }
1735                     break;
1736
1737                 case FAPI_PUSCH_MAPPING_TYPE_TAG:
1738                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1739                    if(encodedVal != RFAILED)
1740                    {
1741                       fillPuschMappingType(encodedVal, &cellParam);
1742                    }
1743                    break;
1744
1745                 case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
1746                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1747                    if(encodedVal != RFAILED)
1748                    {
1749                       fillPuschAllocationType(encodedVal, &cellParam);
1750                    }
1751                    break;
1752
1753                 case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
1754                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1755                    if(encodedVal != RFAILED)
1756                    {
1757                       fillPuschPrbMappingType(encodedVal, &cellParam);
1758                    }
1759                    break;
1760
1761                 case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
1762                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1763                    if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
1764                    {
1765                       cellParam->puschMaxPtrsPorts = encodedVal;
1766                    }
1767                    break;
1768
1769                 case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
1770                    cellParam->maxPduschsTBsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1771                    break;
1772
1773                 case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
1774                    cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1775                    break;
1776
1777                 case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
1778                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1779                    if(encodedVal != RFAILED)
1780                    {
1781                       fillModulationOrderUl(encodedVal, &cellParam);
1782                    }
1783                    break;
1784
1785                 case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
1786                    cellParam->maxMuMimoUsersUl = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1787                    break;
1788
1789                 case FAPI_DFTS_OFDM_SUPPORT_TAG:
1790                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1791                    if(encodedVal != RFAILED && encodedVal != 0)
1792                    {
1793                       cellParam->dftsOfdmSupport = SUPPORTED;
1794                    }
1795                    else
1796                    {
1797                       cellParam->dftsOfdmSupport = NOT_SUPPORTED;
1798                    }
1799                    break;
1800
1801                 case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
1802                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1803                    if(encodedVal != RFAILED)
1804                    {
1805                       fillPuschAggregationFactor(encodedVal, &cellParam);
1806                    }
1807                    break;
1808
1809                 case FAPI_PRACH_LONG_FORMATS_TAG:
1810                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1811                    if(encodedVal != RFAILED)
1812                    {
1813                       fillPrachLongFormat(encodedVal, &cellParam);
1814                    }
1815                    break;
1816
1817                 case FAPI_PRACH_SHORT_FORMATS_TAG:
1818                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1819                    if(encodedVal != RFAILED)
1820                    {
1821                       fillPrachShortFormat(encodedVal, &cellParam);
1822                    }
1823                    break;
1824
1825                 case FAPI_PRACH_RESTRICTED_SETS_TAG:
1826                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1827                    if(encodedVal != RFAILED && encodedVal != 0)
1828                    {
1829                       cellParam->prachRestrictedSets = SUPPORTED;
1830                    }
1831                    else
1832                    {
1833                       cellParam->prachRestrictedSets = NOT_SUPPORTED;
1834                    }
1835                    break;
1836
1837                case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
1838                   encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1839                   if(encodedVal != RFAILED)
1840                   {
1841                      fillFdOccasions(encodedVal, &cellParam);
1842                   }
1843                   break;
1844
1845                case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
1846                   encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1847                   if(encodedVal != RFAILED)
1848                   {
1849                      fillRssiMeas(encodedVal, &cellParam);
1850                   }
1851                   break;
1852                default:
1853                //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
1854                break;
1855               }
1856            }
1857            MAC_FREE(cellParam, sizeof(ClCellParam));
1858            sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL);
1859            return ROK;
1860          }
1861          else
1862          {
1863             DU_LOG("\n LWR_MAC: Invalid error code %d", paramRsp->error_code);
1864             return RFAILED;
1865          }
1866      }
1867      else
1868      {
1869         DU_LOG("\nLWR_MAC: Failed to allocate memory for cell param");
1870         return RFAILED;
1871      }
1872    }
1873    else
1874    {
1875        DU_LOG("\nLWR_MAC:  Param Response received from PHY is NULL");
1876        return RFAILED;
1877    }
1878 #else
1879    return ROK;
1880 #endif
1881 }
1882
1883  /*******************************************************************
1884   *
1885   * @brief Sends FAPI Config req to PHY
1886   *
1887   * @details
1888   *
1889   *    Function : lwr_mac_handleConfigReqEvt
1890   *
1891   *    Functionality:
1892   *         -Sends FAPI Config Req to PHY
1893   *
1894   * @params[in]
1895   * @return ROK     - success
1896   *         RFAILED - failure
1897   *
1898   * ****************************************************************/
1899
1900 S16 lwr_mac_handleConfigReqEvt(void *msg)
1901 {
1902 #ifdef FAPI
1903    Inst inst = 0;
1904    uint8_t idx = 0;
1905    uint8_t index = 0;
1906    uint32_t msgLen = 0;
1907    uint32_t configReqSize;
1908    RgCellCb  *cellParams;
1909    MacCellCfg macCfgParams;
1910    fapi_config_req_t *configReq;
1911
1912    DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, \
1913       clGlobalCp.phyState);
1914
1915    cellParams = rgCb[inst].cell;
1916    macCfgParams = cellParams->macCellCfg;
1917
1918    configReqSize = sizeof(fapi_config_req_t);
1919    LWR_MAC_ALLOC(configReq, configReqSize);
1920    if(configReq != NULL)
1921    {
1922       msgLen = sizeof(macCfgParams.numTlv);
1923       configReq->number_of_tlvs = macCfgParams.numTlv;
1924
1925       if(macCfgParams.dlCarrCfg.pres)
1926       {
1927          fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG,           \
1928             sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen);
1929          fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG,           \
1930             sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
1931          fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG,                  \
1932             sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
1933          fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG,            \
1934             sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
1935          fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG,             \
1936             sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
1937       }
1938       if(macCfgParams.ulCarrCfg.pres)
1939       {
1940          fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG,       \
1941             sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen);
1942          fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG,       \
1943             sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen);
1944          fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG,                  \
1945             sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen);
1946          fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG,           \
1947             sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen);
1948          fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG,             \
1949             sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen);
1950       }
1951       fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG,   \
1952          sizeof(uint8_t), macCfgParams.freqShft, &msgLen);
1953
1954       /* fill cell config */
1955       fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG,               \
1956          sizeof(uint8_t), macCfgParams.phyCellId, &msgLen);
1957       fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG,         \
1958          sizeof(uint8_t), macCfgParams.dupType, &msgLen);
1959
1960       /* fill SSB configuration */
1961       fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG,             \
1962          sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
1963       fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG,               \
1964          sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
1965       fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG,                \
1966          sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
1967
1968       /* fill PRACH configuration */
1969       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG,     \
1970          sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
1971       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG,        \
1972          sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
1973       fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG,     \
1974          sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
1975       fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,
1976          sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen);
1977       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, \
1978          sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
1979       fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG,        \
1980          sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
1981       fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG,                        \
1982          sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
1983       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG ,     \
1984          sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
1985       fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, \
1986          sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
1987       if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq)
1988       {
1989          for(idx = 0; idx < macCfgParams.prachCfg.fdm[0].numUnusedRootSeq; idx++)
1990             fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,   \
1991                sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].unsuedRootSeq[idx], \
1992                &msgLen);
1993       }
1994       else
1995       {
1996          macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL;
1997       }
1998
1999       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG,              \
2000          sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
2001       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG,  \
2002          sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
2003
2004       /* fill SSB table */
2005       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG,        \
2006          sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
2007       fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG,                  \
2008          sizeof(uint8_t),  macCfgParams.ssbCfg.betaPss, &msgLen);
2009       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG,                \
2010          sizeof(uint8_t),  macCfgParams.ssbCfg.ssbPeriod, &msgLen);
2011       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG,     \
2012          sizeof(uint8_t),  macCfgParams.ssbCfg.ssbScOffset, &msgLen);
2013       fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG ,                      \
2014          sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen);
2015       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG,                  \
2016          sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
2017       fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG,                   \
2018          sizeof(uint8_t),  macCfgParams.ssbCfg.beamId[0], &msgLen);
2019       fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, \
2020          sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
2021       fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, \
2022          sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
2023
2024       /* fill TDD table */
2025       fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG,                \
2026          sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen);
2027       fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG,               \
2028          sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen);
2029
2030       /* fill measurement config */
2031       fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG,           \
2032          sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
2033
2034       /* fill DMRS Type A Pos */
2035                 fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG,           \
2036                    sizeof(uint8_t), macCfgParams.dmrsTypeAPos, &msgLen);
2037
2038       fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
2039
2040       DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
2041       LwrMacSendToPhy(configReq->header.message_type_id, configReqSize, (void *)configReq);
2042    }
2043    else
2044    {
2045       DU_LOG("\nLWR_MAC: Failed to allocate memory for config Request");
2046       return RFAILED;
2047    }
2048 #endif
2049
2050    return ROK;
2051 } /* lwr_mac_handleConfigReqEvt */
2052
2053 /*******************************************************************
2054  *
2055  * @brief Processes config response from phy
2056  *
2057  * @details
2058  *
2059  *    Function : lwr_mac_handleConfigRspEvt
2060  *
2061  *    Functionality:
2062  *          Processes config response from phy
2063  *
2064  * @params[in] FAPI message pointer
2065  * @return ROK     - success
2066  *         RFAILED - failure
2067  *
2068  * ****************************************************************/
2069
2070 S16 lwr_mac_handleConfigRspEvt(void *msg)
2071 {
2072 #ifdef FAPI
2073    fapi_config_resp_t *configRsp;
2074    configRsp = (fapi_config_resp_t *)msg;
2075
2076    DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, \
2077       clGlobalCp.phyState);
2078
2079    if(configRsp != NULL)
2080    {
2081       if(configRsp->error_code == MSG_OK)
2082       {
2083          DU_LOG("\nLWR_MAC: PHY has moved to Configured state \n");
2084          clGlobalCp.phyState = PHY_STATE_CONFIGURED;
2085          /* TODO :
2086           * Store config response into an intermediate struture and send to MAC
2087           * Support LC and LWLC for sending config rsp to MAC
2088           */
2089          fapiMacConfigRsp();
2090       }
2091       else
2092       {
2093          DU_LOG("\n LWR_MAC: Invalid error code %d", configRsp->error_code);
2094          return RFAILED;
2095       }
2096    }
2097    else
2098    {
2099       DU_LOG("\nLWR_MAC: Config Response received from PHY is NULL");
2100       return RFAILED;
2101    }
2102 #endif
2103
2104    return ROK;
2105 } /* lwr_mac_handleConfigRspEvt */
2106
2107 /*******************************************************************
2108  *
2109  * @brief Build and send start request to phy
2110  *
2111  * @details
2112  *
2113  *    Function : lwr_mac_handleStartReqEvt
2114  *
2115  *    Functionality:
2116  *       Build and send start request to phy
2117  *
2118  * @params[in] FAPI message pointer
2119  * @return ROK     - success
2120  *         RFAILED - failure
2121  *
2122  * ****************************************************************/
2123 S16 lwr_mac_handleStartReqEvt(void *msg)
2124 {
2125 #ifdef FAPI
2126    uint32_t msgLen = 0;
2127    fapi_start_req_t *startReq;
2128
2129    LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
2130    if(startReq != NULL)
2131    {
2132       fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
2133
2134       DU_LOG("\nLWR_MAC: Sending Start Request to PHY");
2135       LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t),\
2136          (void *)startReq);
2137    }
2138    else
2139    {
2140       DU_LOG("\nLWR_MAC: Failed to allocate memory for Start Request");
2141       return RFAILED;
2142    }
2143 #endif
2144    return ROK;
2145 } /* lwr_mac_handleStartReqEvt */
2146
2147  /*******************************************************************
2148   *
2149   * @brief Sends FAPI Stop Req to PHY
2150   *
2151   * @details
2152   *
2153   *    Function : lwr_mac_handleStopReqEvt
2154   *
2155   *    Functionality:
2156   *         -Sends FAPI Stop Req to PHY
2157   *
2158   * @params[in]
2159   * @return ROK     - success
2160   *         RFAILED - failure
2161   *
2162   ********************************************************************/
2163
2164 S16 lwr_mac_handleStopReqEvt(void *msg)
2165 {
2166 #ifdef FAPI
2167    uint32_t msgLen = 0;
2168    fapi_stop_req_t *stopReq = NULLP;
2169    LWR_MAC_ALLOC(stopReq, sizeof(fapi_stop_req_t));
2170    if(stopReq != NULLP)
2171    {
2172       fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, msgLen);
2173       DU_LOG("\nLOWER MAC: Sending Stop Request to PHY");
2174       LwrMacSendToPhy(stopReq->header.message_type_id, sizeof(fapi_stop_req_t), (void *)stopReq);
2175    }
2176    else
2177    {
2178       DU_LOG("\nLOWER MAC: Failed to allocate memory for Stop Request");
2179       return RFAILED;
2180    }
2181 #endif
2182    return ROK;
2183 }
2184
2185 /*******************************************************************
2186  *
2187  * @brief Modifes the received mibPdu to uint32 bit
2188  *        and stores it in MacCellCfg
2189  *
2190  * @details
2191  *
2192  *    Function : setMibPdu
2193  *
2194  *    Functionality:
2195  *         -Sets the MibPdu
2196  *
2197  * @params[in] Pointer to mibPdu
2198  *             pointer to modified value
2199  ******************************************************************/
2200
2201 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
2202 {
2203    *mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK);
2204    *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2205     DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
2206 }
2207
2208 #ifdef FAPI
2209 /*******************************************************************
2210  *
2211  * @brief fills SSB PDU required for DL TTI info in MAC
2212  *
2213  * @details
2214  *
2215  *    Function : fillSsbPdu
2216  *
2217  *    Functionality:
2218  *         -Fills the SSB PDU info
2219  *          stored in MAC
2220  *
2221  * @params[in] Pointer to FAPI DL TTI Req
2222  *             Pointer to RgCellCb
2223  *             Pointer to msgLen of DL TTI Info
2224  * @return ROK
2225  *
2226  ******************************************************************/
2227
2228 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2229    MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn)
2230 {
2231    uint32_t mibPayload = 0;
2232    if(dlTtiReqPdu != NULL)
2233    {
2234       dlTtiReqPdu->pduType = SSB_PDU_TYPE;     /* SSB PDU */
2235       dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2236       dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2237       dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx;
2238       dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2239       /* ssbOfPdufstA to be filled in ssbCfg */
2240       dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2241       dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2242       /* Bit manipulation for SFN */
2243       setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn);
2244       dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2245       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2246       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2247       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2248       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2249       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2250          pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2251       dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t);  /* Size of SSB PDU */
2252       SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2253          sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_ssb_pdu_t)));
2254       return ROK;
2255     }
2256     else
2257     {
2258        return RFAILED;
2259     }
2260 }
2261
2262 /*******************************************************************
2263  *
2264  * @brief fills Dl DCI PDU required for DL TTI info in MAC
2265  *
2266  * @details
2267  *
2268  *    Function : fillSib1DlDciPdu
2269  *
2270  *    Functionality:
2271  *         -Fills the Dl DCI PDU
2272  *
2273  * @params[in] Pointer to fapi_dl_dci_t
2274  *             Pointer to PdcchCfg
2275  * @return ROK
2276  *
2277  ******************************************************************/
2278
2279 void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo)
2280 {
2281    if(dlDciPtr != NULLP)
2282    {
2283       uint8_t numBytes;
2284       uint8_t bytePos;
2285       uint8_t bitPos;
2286
2287       uint16_t coreset0Size;
2288       uint16_t rbStart;
2289       uint16_t rbLen;
2290       uint32_t freqDomResAssign;
2291       uint32_t timeDomResAssign;
2292       uint8_t  VRB2PRBMap;
2293       uint32_t modNCodScheme;
2294       uint8_t  redundancyVer;
2295       uint32_t sysInfoInd;
2296       uint32_t reserved;
2297
2298       /* Size(in bits) of each field in DCI format 0_1
2299        * as mentioned in spec 38.214 */
2300       uint8_t freqDomResAssignSize;
2301       uint8_t timeDomResAssignSize = 4;
2302       uint8_t VRB2PRBMapSize       = 1;
2303       uint8_t modNCodSchemeSize    = 5;
2304       uint8_t redundancyVerSize    = 2;
2305       uint8_t sysInfoIndSize       = 1;
2306       uint8_t reservedSize         = 15;
2307
2308       dlDciPtr->rnti = sib1PdcchInfo->dci.rnti;
2309       dlDciPtr->scramblingId = sib1PdcchInfo->dci.scramblingId;
2310       dlDciPtr->scramblingRnti = sib1PdcchInfo->dci.scramblingRnti;
2311       dlDciPtr->cceIndex = sib1PdcchInfo->dci.cceIndex;
2312       dlDciPtr->aggregationLevel = sib1PdcchInfo->dci.aggregLevel;
2313       dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->dci.beamPdcchInfo.numPrgs;
2314       dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->dci.beamPdcchInfo.prgSize;
2315       dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2316       dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2317       dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2318       dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue;
2319       dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2320
2321       /* Calculating freq domain resource allocation field value and size
2322        * coreset0Size = Size of coreset 0
2323        * RBStart = Starting Virtual Rsource block
2324        * RBLen = length of contiguously allocted RBs
2325        * Spec 38.214 Sec 5.1.2.2.2
2326        */
2327       coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size;
2328       rbStart = 0;              /* For SIB1 */
2329       //rbStart = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
2330       rbLen = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
2331
2332       if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2333       {
2334          if((rbLen - 1) <= floor(coreset0Size / 2))
2335             freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2336          else
2337             freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2338                + (coreset0Size - 1 - rbStart);
2339
2340          freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2341       }
2342
2343       /* Fetching DCI field values */
2344       timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->pdschTimeAlloc.
2345                          rowIndex -1;
2346       VRB2PRBMap       = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.\
2347                          vrbPrbMapping;
2348       modNCodScheme    = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2349       redundancyVer    = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2350       sysInfoInd       = 0;           /* 0 for SIB1; 1 for SI messages */
2351       reserved         = 0;
2352
2353       /* Reversing bits in each DCI field */
2354       freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2355       timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2356       VRB2PRBMap       = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2357       modNCodScheme    = reverseBits(modNCodScheme, modNCodSchemeSize);
2358       redundancyVer    = reverseBits(redundancyVer, redundancyVerSize);
2359       sysInfoInd       = reverseBits(sysInfoInd, sysInfoIndSize);
2360
2361      /* Calulating total number of bytes in buffer */
2362      dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2363               + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
2364               + sysInfoIndSize + reservedSize;
2365
2366      numBytes = dlDciPtr->payloadSizeBits / 8;
2367      if(dlDciPtr->payloadSizeBits % 8)
2368         numBytes += 1;
2369
2370      if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2371      {
2372         DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2373         return;
2374      }
2375
2376      /* Initialize buffer */
2377      for(bytePos = 0; bytePos < numBytes; bytePos++)
2378         dlDciPtr->payload[bytePos] = 0;
2379
2380      bytePos = numBytes - 1;
2381      bitPos = 0;
2382
2383      /* Packing DCI format fields */
2384      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2385         freqDomResAssign, freqDomResAssignSize);
2386      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2387         timeDomResAssign, timeDomResAssignSize);
2388      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2389         VRB2PRBMap, VRB2PRBMapSize);
2390      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2391         modNCodScheme, modNCodSchemeSize);
2392      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2393         redundancyVer, redundancyVerSize);
2394      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2395         sysInfoInd, sysInfoIndSize);
2396      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2397         reserved, reservedSize);
2398
2399    }
2400 } /* fillSib1DlDciPdu */
2401
2402 /*******************************************************************
2403  *
2404  * @brief fills Dl DCI PDU required for DL TTI info in MAC
2405  *
2406  * @details
2407  *
2408  *    Function : fillRarDlDciPdu
2409  *
2410  *    Functionality:
2411  *         -Fills the Dl DCI PDU
2412  *
2413  * @params[in] Pointer to fapi_dl_dci_t
2414  *             Pointer to PdcchCfg
2415  * @return ROK
2416  *
2417  ******************************************************************/
2418
2419 void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo)
2420 {
2421    if(dlDciPtr != NULLP)
2422    {
2423       uint8_t numBytes;
2424       uint8_t bytePos;
2425       uint8_t bitPos;
2426
2427       uint16_t coreset0Size;
2428       uint16_t rbStart;
2429       uint16_t rbLen;
2430       uint32_t freqDomResAssign;
2431       uint8_t timeDomResAssign;
2432       uint8_t  VRB2PRBMap;
2433       uint8_t modNCodScheme;
2434       uint8_t tbScaling;
2435       uint32_t reserved;
2436
2437       /* Size(in bits) of each field in DCI format 1_0 */
2438       uint8_t freqDomResAssignSize;
2439       uint8_t timeDomResAssignSize = 4;
2440       uint8_t VRB2PRBMapSize       = 1;
2441       uint8_t modNCodSchemeSize    = 5;
2442       uint8_t tbScalingSize        = 2;
2443       uint8_t reservedSize         = 16;
2444
2445       dlDciPtr->rnti = rarPdcchInfo->dci.rnti;
2446       dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId;
2447       dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti;
2448       dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex;
2449       dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel;
2450       dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs;
2451       dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize;
2452       dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2453       dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2454       dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2455       dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue;
2456       dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2457
2458       /* Calculating freq domain resource allocation field value and size
2459        * coreset0Size = Size of coreset 0
2460        * RBStart = Starting Virtual Rsource block
2461        * RBLen = length of contiguously allocted RBs
2462        * Spec 38.214 Sec 5.1.2.2.2
2463        */
2464
2465       /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2466       coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size;
2467       rbStart = 0;              /* For SIB1 */
2468       //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2469       rbLen = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
2470
2471       if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2472       {
2473          if((rbLen - 1) <= floor(coreset0Size / 2))
2474             freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2475          else
2476             freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2477                                + (coreset0Size - 1 - rbStart);
2478
2479          freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2480       }
2481
2482       /* Fetching DCI field values */
2483       timeDomResAssign = rarPdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
2484       VRB2PRBMap       = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
2485       modNCodScheme    = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2486       tbScaling        = 0; /* configured to 0 scaling */
2487       reserved         = 0;
2488
2489       /* Reversing bits in each DCI field */
2490       freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2491       timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2492       VRB2PRBMap       = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2493       modNCodScheme    = reverseBits(modNCodScheme, modNCodSchemeSize);
2494       tbScaling        = reverseBits(tbScaling, tbScalingSize);
2495
2496       /* Calulating total number of bytes in buffer */
2497       dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2498                                   + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize;
2499
2500       numBytes = dlDciPtr->payloadSizeBits / 8;
2501       if(dlDciPtr->payloadSizeBits % 8)
2502          numBytes += 1;
2503
2504       if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2505       {
2506          DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2507          return;
2508       }
2509
2510       /* Initialize buffer */
2511       for(bytePos = 0; bytePos < numBytes; bytePos++)
2512          dlDciPtr->payload[bytePos] = 0;
2513
2514       bytePos = numBytes - 1;
2515       bitPos = 0;
2516
2517       /* Packing DCI format fields */
2518       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2519             freqDomResAssign, freqDomResAssignSize);
2520       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2521             timeDomResAssign, timeDomResAssignSize);
2522       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2523             VRB2PRBMap, VRB2PRBMapSize);
2524       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2525             modNCodScheme, modNCodSchemeSize);
2526       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2527             tbScaling, tbScalingSize);
2528       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2529             reserved, reservedSize);
2530    }
2531 } /* fillRarDlDciPdu */
2532
2533 /*******************************************************************
2534  *
2535  * @brief fills msg4 Dl DCI PDU required for DL TTI info in MAC
2536  *
2537  * @details
2538  *
2539  *    Function : fillMsg4DlDciPdu
2540  *
2541  *    Functionality:
2542  *         -Fills the Msg4 Dl DCI PDU
2543  *
2544  * @params[in] Pointer to fapi_dl_dci_t
2545  *             Pointer to PdcchCfg
2546  * @return ROK
2547  *
2548  ******************************************************************/
2549 void fillMsg4DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *msg4PdcchInfo,\
2550 Msg4Info *msg4Info)
2551 {
2552    if(dlDciPtr != NULLP)
2553    {
2554       uint8_t numBytes;
2555       uint8_t bytePos;
2556       uint8_t bitPos;
2557
2558       uint16_t coreset0Size = 0;
2559       uint16_t rbStart = 0;
2560       uint16_t rbLen = 0;
2561       uint8_t  dciFormatId;
2562       uint32_t freqDomResAssign;
2563       uint8_t  timeDomResAssign;
2564       uint8_t  VRB2PRBMap;
2565       uint8_t  modNCodScheme;
2566       uint8_t  ndi = 0;
2567       uint8_t  redundancyVer = 0;
2568       uint8_t  harqProcessNum = 0;
2569       uint8_t  dlAssignmentIdx = 0;
2570       uint8_t  pucchTpc = 0;
2571       uint8_t  pucchResoInd = 0;
2572       uint8_t  harqFeedbackInd = 0;
2573
2574       /* Size(in bits) of each field in DCI format 1_0 */
2575       uint8_t dciFormatIdSize    = 1;
2576       uint8_t freqDomResAssignSize;
2577       uint8_t timeDomResAssignSize = 4;
2578       uint8_t VRB2PRBMapSize       = 1;
2579       uint8_t modNCodSchemeSize    = 5;
2580       uint8_t ndiSize              = 1;
2581       uint8_t redundancyVerSize    = 2;
2582       uint8_t harqProcessNumSize   = 4;
2583       uint8_t dlAssignmentIdxSize  = 2;
2584       uint8_t pucchTpcSize         = 2;
2585       uint8_t pucchResoIndSize     = 3;
2586       uint8_t harqFeedbackIndSize  = 3;
2587
2588       dlDciPtr->rnti = msg4PdcchInfo->dci.rnti;
2589       dlDciPtr->scramblingId = msg4PdcchInfo->dci.scramblingId;
2590       dlDciPtr->scramblingRnti = msg4PdcchInfo->dci.scramblingRnti;
2591       dlDciPtr->cceIndex = msg4PdcchInfo->dci.cceIndex;
2592       dlDciPtr->aggregationLevel = msg4PdcchInfo->dci.aggregLevel;
2593       dlDciPtr->pc_and_bform.numPrgs = msg4PdcchInfo->dci.beamPdcchInfo.numPrgs;
2594       dlDciPtr->pc_and_bform.prgSize = msg4PdcchInfo->dci.beamPdcchInfo.prgSize;
2595       dlDciPtr->pc_and_bform.digBfInterfaces = msg4PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2596       dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2597       dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2598       dlDciPtr->beta_pdcch_1_0 = msg4PdcchInfo->dci.txPdcchPower.powerValue;
2599       dlDciPtr->powerControlOfssetSS = msg4PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2600
2601       /* Calculating freq domain resource allocation field value and size
2602        * coreset0Size = Size of coreset 0
2603        * RBStart = Starting Virtual Rsource block
2604        * RBLen = length of contiguously allocted RBs
2605        * Spec 38.214 Sec 5.1.2.2.2
2606        */
2607
2608       /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2609       coreset0Size = msg4PdcchInfo->coreset0Cfg.coreSet0Size;
2610       //rbStart = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2611       rbLen = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
2612
2613       if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2614       {
2615          if((rbLen - 1) <= floor(coreset0Size / 2))
2616             freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2617          else
2618             freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2619                                + (coreset0Size - 1 - rbStart);
2620
2621          freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2622       }
2623
2624       /* Fetching DCI field values */
2625       dciFormatId      = msg4Info->dciFormatId; /* DCI indentifier for DL */
2626       timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
2627       VRB2PRBMap       = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
2628       modNCodScheme    = msg4PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2629       ndi              = msg4Info->ndi;
2630       redundancyVer    = msg4PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2631       harqProcessNum   = msg4Info->harqProcNum;
2632       dlAssignmentIdx  = msg4Info->dlAssignIdx;
2633       pucchTpc         = msg4Info->pucchTpc;
2634       pucchResoInd     = msg4Info->pucchResInd;
2635       harqFeedbackInd  = msg4Info->harqFeedbackInd;
2636
2637       /* Reversing bits in each DCI field */
2638       dciFormatId      = reverseBits(dciFormatId, dciFormatIdSize);
2639       freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2640       timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2641       VRB2PRBMap       = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2642       modNCodScheme    = reverseBits(modNCodScheme, modNCodSchemeSize);
2643       ndi              = reverseBits(ndi, ndiSize);
2644       redundancyVer    = reverseBits(redundancyVer, redundancyVerSize);
2645       harqProcessNum   = reverseBits(harqProcessNum, harqProcessNumSize);
2646       dlAssignmentIdx  = reverseBits(dlAssignmentIdx , dlAssignmentIdxSize);
2647       pucchTpc         = reverseBits(pucchTpc, pucchTpcSize);
2648       pucchResoInd     = reverseBits(pucchResoInd, pucchResoIndSize);
2649       harqFeedbackInd  = reverseBits(harqFeedbackInd, harqFeedbackIndSize);
2650
2651
2652       /* Calulating total number of bytes in buffer */
2653       dlDciPtr->payloadSizeBits = (dciFormatIdSize + freqDomResAssignSize\
2654       + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\
2655       + ndiSize + redundancyVerSize + harqProcessNumSize + dlAssignmentIdxSize\
2656       + pucchTpcSize + pucchResoIndSize + harqFeedbackIndSize);
2657
2658       numBytes = dlDciPtr->payloadSizeBits / 8;
2659       if(dlDciPtr->payloadSizeBits % 8)
2660          numBytes += 1;
2661
2662       if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2663       {
2664          DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2665          return;
2666       }
2667
2668       /* Initialize buffer */
2669       for(bytePos = 0; bytePos < numBytes; bytePos++)
2670          dlDciPtr->payload[bytePos] = 0;
2671
2672       bytePos = numBytes - 1;
2673       bitPos = 0;
2674
2675       /* Packing DCI format fields */
2676       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2677             dciFormatId, dciFormatIdSize);
2678       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2679             freqDomResAssign, freqDomResAssignSize);
2680       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2681             timeDomResAssign, timeDomResAssignSize);
2682       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2683             VRB2PRBMap, VRB2PRBMapSize);
2684       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2685             modNCodScheme, modNCodSchemeSize);
2686       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2687             ndi, ndiSize);
2688       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2689             redundancyVer, redundancyVerSize);
2690       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2691             redundancyVer, redundancyVerSize);
2692       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2693             harqProcessNum, harqProcessNumSize);
2694       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2695             dlAssignmentIdx, dlAssignmentIdxSize);
2696       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2697             pucchTpc, pucchTpcSize);
2698       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2699             pucchResoInd, pucchResoIndSize);
2700       fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2701             harqFeedbackInd, harqFeedbackIndSize);
2702    }
2703 } /* fillMsg4DlDciPdu */
2704
2705 /*******************************************************************
2706  *
2707  * @brief fills PDCCH PDU required for DL TTI info in MAC
2708  *
2709  * @details
2710  *
2711  *    Function : fillPdcchPdu
2712  *
2713  *    Functionality:
2714  *         -Fills the Pdcch PDU info
2715  *          stored in MAC
2716  *
2717  * @params[in] Pointer to FAPI DL TTI Req
2718  *             Pointer to PdcchCfg
2719  *             Pointer to msgLen of DL TTI Info
2720  * @return ROK
2721  *
2722  ******************************************************************/
2723 S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, uint32_t *msgLen, RntiType rntiType)
2724 {
2725    if(dlTtiReqPdu != NULLP)
2726    {
2727       PdcchCfg *pdcchInfo = NULLP;
2728       BwpCfg *bwp = NULLP;
2729
2730       dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \
2731          (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \
2732          (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*)));
2733
2734       if(rntiType == SI_RNTI_TYPE)
2735       {
2736          pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
2737          bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp;
2738          fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2739       }
2740       else if(rntiType == RA_RNTI_TYPE)
2741       {
2742          pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg;
2743          bwp = &dlInfo->rarAlloc->bwp;
2744          fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2745       }
2746       else if(rntiType == TC_RNTI_TYPE)
2747       {
2748          pdcchInfo = &dlInfo->msg4Alloc->msg4PdcchCfg;
2749          bwp = &dlInfo->msg4Alloc->bwp;
2750          fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\
2751             &dlInfo->msg4Alloc->msg4Info);
2752       }
2753       else
2754       {
2755          DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu");
2756          return RFAILED;;
2757       }
2758       dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
2759       dlTtiReqPdu->u.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb;
2760       dlTtiReqPdu->u.pdcch_pdu.bwpPart = bwp->freqAlloc.startPrb;
2761       dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing;
2762       dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = bwp->cyclicPrefix;
2763       dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex;
2764       dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols;
2765       memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6);
2766       dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType;
2767       dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize;
2768       dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize;
2769       dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType;
2770       dlTtiReqPdu->u.pdcch_pdu.shiftIndex =  pdcchInfo->coreset0Cfg.shiftIndex;
2771       dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity;
2772       dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
2773
2774       /* Calculating PDU length. Considering only one dl dci pdu for now */
2775       dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t);
2776       SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2777          sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize));
2778
2779     }
2780
2781     return ROK;
2782 }
2783
2784 /*******************************************************************
2785  *
2786  * @brief fills PDSCH PDU required for DL TTI info in MAC
2787  *
2788  * @details
2789  *
2790  *    Function : fillPdschPdu
2791  *
2792  *    Functionality:
2793  *         -Fills the Pdsch PDU info
2794  *          stored in MAC
2795  *
2796  * @params[in] Pointer to FAPI DL TTI Req
2797  *             Pointer to PdschCfg
2798  *             Pointer to msgLen of DL TTI Info
2799  * @return ROK
2800  *
2801  ******************************************************************/
2802
2803 void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
2804    BwpCfg bwp,uint32_t *msgLen, uint16_t pduIndex)
2805 {
2806     uint8_t idx;
2807
2808     if(dlTtiReqPdu != NULLP)
2809     {
2810        dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
2811        dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap;
2812        dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti;
2813        dlTtiReqPdu->u.pdsch_pdu.pduIndex = pduIndex;
2814        dlTtiReqPdu->u.pdsch_pdu.bwpSize = bwp.freqAlloc.numPrb;
2815        dlTtiReqPdu->u.pdsch_pdu.bwpStart = bwp.freqAlloc.startPrb;
2816        dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing;
2817        dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = bwp.cyclicPrefix;
2818        dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
2819        for(idx = 0; idx < MAX_CODEWORDS ; idx++)
2820        {
2821           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
2822           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
2823           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
2824           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
2825           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
2826           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
2827        }
2828        dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId;
2829        dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = pdschInfo->numLayers;
2830        dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme;
2831        dlTtiReqPdu->u.pdsch_pdu.refPoint = pdschInfo->refPoint;
2832        dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos;
2833        dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType;
2834        dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId;
2835        dlTtiReqPdu->u.pdsch_pdu.scid = pdschInfo->dmrs.scid;
2836        dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData;
2837        dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts;
2838        dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->pdschFreqAlloc.resourceAllocType;
2839        /* since we are using type-1, hence rbBitmap excluded */
2840        dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->pdschFreqAlloc.freqAlloc.startPrb;
2841        dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->pdschFreqAlloc.freqAlloc.numPrb;
2842        dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->pdschFreqAlloc.vrbPrbMapping;
2843        dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->pdschTimeAlloc.timeAlloc.startSymb;
2844        dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->pdschTimeAlloc.timeAlloc.numSymb;
2845        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs;
2846        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize;
2847        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces;
2848        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2849           pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
2850        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2851           beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
2852        dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;
2853        dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
2854        dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
2855
2856        SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2857           sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_pdsch_pdu_t)));
2858
2859     }
2860
2861 }
2862
2863 /***********************************************************************
2864  *
2865  * @brief calculates the total size to be allocated for DL TTI Req
2866  *
2867  * @details
2868  *
2869  *    Function : calcDlTtiReqPduCount
2870  *
2871  *    Functionality:
2872  *         -calculates the total pdu count to be allocated for DL TTI Req
2873  *
2874  * @params[in]    DlBrdcstAlloc *cellBroadcastInfo
2875  * @return count
2876  *
2877  * ********************************************************************/
2878 uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
2879 {
2880    uint8_t count = 0;
2881    uint8_t idx = 0;
2882
2883    if(dlInfo->isBroadcastPres)
2884    {
2885       if(dlInfo->brdcstAlloc.ssbTrans)
2886       {
2887          for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
2888          {
2889             /* SSB PDU is filled */
2890             count++;
2891          }
2892       }
2893       if(dlInfo->brdcstAlloc.sib1Trans)
2894       {
2895          /* PDCCH and PDSCH PDU is filled */
2896          count += 2;
2897       }
2898    }
2899    if(dlInfo->rarAlloc != NULLP)
2900    {
2901       /* PDCCH and PDSCH PDU is filled */
2902       count += 2;
2903    }
2904    if(dlInfo->msg4Alloc != NULLP)
2905    {
2906       /* PDCCH and PDSCH PDU is filled */
2907       count += 2;
2908    }
2909
2910    return count;
2911 }
2912
2913 /***********************************************************************
2914  *
2915  * @brief calculates the total size to be allocated for DL TTI Req
2916  *
2917  * @details
2918  *
2919  *    Function : calcTxDataReqPduCount
2920  *
2921  *    Functionality:
2922  *         -calculates the total pdu count to be allocated for DL TTI Req
2923  *
2924  * @params[in]    DlBrdcstAlloc *cellBroadcastInfo
2925  * @return count
2926  *
2927  * ********************************************************************/
2928 uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo)
2929 {
2930    uint8_t count = 0;
2931
2932    if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
2933    {
2934       count++;
2935    }
2936    if(dlInfo->rarAlloc != NULLP)
2937    {
2938       count++;
2939    }
2940    if(dlInfo->msg4Alloc != NULLP)
2941    {
2942       count++;
2943    }
2944
2945    return count;
2946 }
2947 /***********************************************************************
2948  *
2949  * @brief fills the SIB1 TX-DATA request message
2950  *
2951  * @details
2952  *
2953  *    Function : fillSib1TxDataReq
2954  *
2955  *    Functionality:
2956  *         - fills the SIB1 TX-DATA request message
2957  *
2958  * @params[in]    fapi_tx_pdu_desc_t *pduDesc
2959  * @params[in]    macCellCfg consist of SIB1 pdu
2960  * @params[in]    uint32_t *msgLen
2961  * @params[in]    uint16_t pduIndex
2962  * @return ROK
2963  *
2964  * ********************************************************************/
2965 uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg,
2966    uint32_t *msgLen, uint16_t pduIndex)
2967 {
2968    uint32_t pduLen = 0;
2969    uint32_t *sib1TxdataValue = NULLP;
2970
2971    pduDesc[pduIndex].pduIndex = pduIndex;
2972    pduDesc[pduIndex].numTlvs = 1;
2973
2974    /* fill the TLV */
2975    /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
2976    pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
2977    pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen;
2978    LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2979    if(sib1TxdataValue == NULLP)
2980    {
2981       return RFAILED;
2982    }
2983    memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu,
2984       macCellCfg->sib1Cfg.sib1PduLen);
2985    pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue;
2986
2987    /* The total length of the PDU description and   PDU data */
2988    pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
2989    pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
2990    pduDesc[pduIndex].pduLength = pduLen;
2991    msgLen += pduLen;
2992
2993 #ifndef INTEL_WLS
2994    MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2995 #endif
2996
2997    return ROK;
2998 }
2999
3000 /***********************************************************************
3001  *
3002  * @brief fills the RAR TX-DATA request message
3003  *
3004  * @details
3005  *
3006  *    Function : fillRarTxDataReq
3007  *
3008  *    Functionality:
3009  *         - fills the RAR TX-DATA request message
3010  *
3011  * @params[in]    fapi_tx_pdu_desc_t *pduDesc
3012  * @params[in]    RarInfo *rarInfo
3013  * @params[in]    uint32_t *msgLen
3014  * @params[in]    uint16_t pduIndex
3015  * @return ROK
3016  *
3017  * ********************************************************************/
3018 uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
3019    uint32_t *msgLen, uint16_t pduIndex)
3020 {
3021    uint32_t pduLen = 0;
3022    uint32_t *rarTxdataValue = NULLP;
3023
3024    pduDesc[pduIndex].pduIndex = pduIndex;
3025    pduDesc[pduIndex].numTlvs = 1;
3026
3027    /* fill the TLV */
3028    /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
3029    pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
3030    pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen;
3031    LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen);
3032    if(rarTxdataValue == NULLP)
3033    {
3034       return RFAILED;
3035    }
3036    memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen);
3037    pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue;
3038
3039    /* The total length of the PDU description and   PDU data */
3040    pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
3041    pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
3042    pduDesc[pduIndex].pduLength = pduLen;
3043    msgLen += pduLen;
3044
3045 /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
3046  * But since we did not implement WLS, this has to be done here
3047  */
3048 #ifndef INTEL_WLS
3049    MAC_FREE(rarTxdataValue,rarInfo->rarPduLen);
3050 #endif
3051
3052    return ROK;
3053 }
3054
3055 /***********************************************************************
3056  *
3057  * @brief fills the Msg4 TX-DATA request message
3058  *
3059  * @details
3060  *
3061  *    Function : fillMsg4TxDataReq
3062  *
3063  *    Functionality:
3064  *         - fills the Msg4 TX-DATA request message
3065  *
3066  * @params[in]    fapi_tx_pdu_desc_t *pduDesc
3067  * @params[in]    Msg4Info *msg4Info
3068  * @params[in]    uint32_t *msgLen
3069  * @params[in]    uint16_t pduIndex
3070  * @return ROK
3071  *
3072  * ********************************************************************/
3073 uint8_t fillMsg4TxDataReq(fapi_tx_pdu_desc_t *pduDesc, Msg4Info *msg4Info,
3074    uint32_t *msgLen, uint16_t pduIndex)
3075 {
3076    uint32_t pduLen = 0;
3077    uint32_t *msg4TxDataValue = NULLP;
3078
3079    pduDesc[pduIndex].pduIndex = pduIndex;
3080    pduDesc[pduIndex].numTlvs = 1;
3081
3082    /* fill the TLV */
3083    /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
3084    pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
3085    pduDesc[pduIndex].tlvs[0].tl.length = msg4Info->msg4PduLen;
3086    LWR_MAC_ALLOC(msg4TxDataValue, msg4Info->msg4PduLen);
3087    if(msg4TxDataValue == NULLP)
3088    {
3089       return RFAILED;
3090    }
3091    memcpy(msg4TxDataValue, msg4Info->msg4Pdu, msg4Info->msg4PduLen);
3092    pduDesc[pduIndex].tlvs[0].value = (uint32_t)msg4TxDataValue;
3093
3094    /* The total length of the PDU description and PDU data */
3095    pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
3096    pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
3097    pduDesc[pduIndex].pduLength = pduLen;
3098    msgLen += pduLen;
3099
3100    /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
3101     * But since we did not implement WLS, this has to be done here
3102     */
3103    #ifndef INTEL_WLS
3104       MAC_FREE(msg4TxDataValue, msg4Info->msg4PduLen);
3105    #endif
3106
3107    return ROK;
3108 }
3109
3110 #endif /* FAPI */
3111 /*******************************************************************
3112  *
3113  * @brief Sends DL TTI Request to PHY
3114  *
3115  * @details
3116  *
3117  *    Function : handleDlTtiReq
3118  *
3119  *    Functionality:
3120  *         -Sends FAPI DL TTI req to PHY
3121  *
3122  * @params[in]    timing info
3123  * @return ROK     - success
3124  *         RFAILED - failure
3125  *
3126  * ****************************************************************/
3127 uint16_t handleDlTtiReq(SlotIndInfo currTimingInfo)
3128 {
3129 #ifdef FAPI
3130    uint8_t idx;
3131    uint8_t nPdu = 0;
3132    uint8_t numPduEncoded = 0;
3133    uint16_t pduIndex = 0;
3134    uint32_t msgLen = 0;
3135    uint32_t dlTtiReqMsgSize = 0;
3136
3137    fapi_dl_tti_req_t *dlTtiReq = NULLP;
3138    SlotIndInfo dlTtiReqTimingInfo;
3139
3140    RgCellCb  *cellCbParams = NULLP;
3141    MacDlSlot *currDlSlot = NULLP;
3142    MacCellCfg macCellCfg;
3143    memset(&macCellCfg, 0, sizeof(MacCellCfg));
3144    Inst inst = 0;
3145    RntiType rntiType;
3146
3147    if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3148    {
3149       /* consider phy delay */
3150       ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA);
3151
3152       cellCbParams = rgCb[inst].cell;
3153                 macCellCfg = cellCbParams->macCellCfg;
3154
3155                 currDlSlot = &macCb.macCell->dlSlot[dlTtiReqTimingInfo.slot];
3156                 nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
3157                 dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
3158                                 sizeof(fapi_dl_tti_req_pdu_t));
3159                 if(nPdu > 0)
3160                 {
3161                         if(currDlSlot->dlInfo.isBroadcastPres)
3162                         {
3163                                 if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
3164                                 {
3165                                         dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3166                                 }
3167                         }
3168                         if(currDlSlot->dlInfo.rarAlloc != NULLP)
3169                         {
3170                                 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3171                         }
3172                         if(currDlSlot->dlInfo.msg4Alloc != NULLP)
3173                         {
3174                                 dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
3175                         }
3176                 }
3177                 LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
3178                 if(dlTtiReq != NULLP)
3179                 {
3180                         memset(dlTtiReq, 0, dlTtiReqMsgSize);
3181                         dlTtiReq->sfn  = dlTtiReqTimingInfo.sfn;
3182                         dlTtiReq->slot = dlTtiReqTimingInfo.slot;
3183                         dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo);  /* get total Pdus */
3184                         nPdu = dlTtiReq->nPdus;
3185                         dlTtiReq->nGroup = 0;
3186
3187                         if(dlTtiReq->nPdus > 0)
3188                         {
3189                                 dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \
3190                                                 (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*)));
3191                                 if(!dlTtiReq->pdus)
3192                                 {
3193                                         DU_LOG("\nLWR_MAC: Memory allocation failed");
3194                                         return RFAILED;
3195                                 }
3196
3197                                 if(currDlSlot->dlInfo.isBroadcastPres)
3198                                 {
3199                                         if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
3200                                         {
3201                                                 if(dlTtiReq->pdus != NULLP)
3202                                                 {
3203                                                         for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
3204                                                         {
3205                                                                 fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\
3206                                                                                 currDlSlot, &msgLen, idx, dlTtiReq->sfn);
3207                                                                 numPduEncoded++;
3208                                                         }
3209                                                 }
3210                                                 printf("\033[1;31m");
3211                                                 DU_LOG("\nLWR_MAC: MIB sent..");
3212                                                 printf("\033[0m");
3213                                         }
3214                                         if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
3215                                         {
3216                                                 /* Filling SIB1 param */
3217                                                 if(numPduEncoded != nPdu)
3218                                                 {
3219                                                         rntiType = SI_RNTI_TYPE;
3220                                                         fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\
3221                                                                         &msgLen, rntiType);
3222                                                         numPduEncoded++;
3223                                                         fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3224                                                                         &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg,
3225                                                                         currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp,
3226                                                                         &msgLen, pduIndex);
3227                                                         pduIndex++;
3228                                                         numPduEncoded++;
3229                                                 }
3230                                                 printf("\033[1;34m");
3231                                                 DU_LOG("\nLWR_MAC: SIB1 sent...");
3232                                                 printf("\033[0m");
3233                                         }
3234                                 }
3235                                 if(currDlSlot->dlInfo.rarAlloc != NULLP)
3236                                 {
3237                                         /* Filling RAR param */
3238                                         rntiType = RA_RNTI_TYPE;
3239                                         fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
3240                                                         &currDlSlot->dlInfo, &msgLen, rntiType);
3241                                         numPduEncoded++;
3242                                         fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3243                                                         &currDlSlot->dlInfo.rarAlloc->rarPdschCfg,
3244                                                         currDlSlot->dlInfo.rarAlloc->bwp,
3245                                                         &msgLen, pduIndex);
3246                                         numPduEncoded++;
3247                                         pduIndex++;
3248
3249                                         printf("\033[1;32m");
3250                                         DU_LOG("\nLWR_MAC: RAR sent...");
3251                                         printf("\033[0m");
3252                                 }
3253                                 if(currDlSlot->dlInfo.msg4Alloc != NULLP)
3254                                 {
3255                                         /* Filling Msg4 param */
3256                                         rntiType = TC_RNTI_TYPE;
3257                                         fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
3258                                                         &currDlSlot->dlInfo, &msgLen, rntiType);
3259                                         numPduEncoded++;
3260                                         fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
3261                                                         &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg,
3262                                                         currDlSlot->dlInfo.msg4Alloc->bwp,
3263                                                         &msgLen, pduIndex);
3264                                         numPduEncoded++;
3265                                         pduIndex++;
3266
3267                                         printf("\033[1;32m");
3268                                         DU_LOG("\nLWR_MAC: MSG4 sent...");
3269                                         printf("\033[0m");
3270                                 }
3271                                 msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
3272                                 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
3273                                 LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
3274                                                 (void *)dlTtiReq);
3275
3276                                 /* send Tx-DATA req message */
3277                                 sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
3278                         }
3279                         else
3280                         {
3281                                 msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
3282                                 fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
3283                                 LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
3284                         }
3285                         return ROK;
3286                 }
3287                 else
3288                 {
3289                         DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
3290                         return RFAILED;
3291                 }
3292         }
3293    else
3294    {
3295        lwr_mac_handleInvalidEvt(&currTimingInfo);
3296        return RFAILED;
3297    }
3298 #endif
3299    return ROK;
3300 }
3301
3302 /*******************************************************************
3303  *
3304  * @brief Sends TX data Request to PHY
3305  *
3306  * @details
3307  *
3308  *    Function : sendTxDataReq
3309  *
3310  *    Functionality:
3311  *         -Sends FAPI TX data req to PHY
3312  *
3313  * @params[in]    timing info
3314  * @return ROK     - success
3315  *         RFAILED - failure
3316  *
3317  * ****************************************************************/
3318 uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo)
3319 {
3320 #ifdef FAPI
3321    uint8_t nPdu = 0;
3322    uint32_t msgLen = 0;
3323    uint16_t pduIndex = 0;
3324    uint32_t txDataReqMsgSize = 0;
3325    fapi_tx_data_req_t *txDataReq = NULLP;
3326    Inst inst = 0;
3327
3328    /* send TX_Data request message */
3329    nPdu = calcTxDataReqPduCount(dlInfo);
3330    if(nPdu > 0)
3331    {
3332       txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \
3333          (nPdu * sizeof(fapi_tx_pdu_desc_t));
3334       if(dlInfo->brdcstAlloc.sib1Trans)
3335       {
3336          txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen;
3337       }
3338       if(dlInfo->rarAlloc != NULLP)
3339       {
3340          txDataReqMsgSize += dlInfo->rarAlloc->rarInfo.rarPduLen;
3341       }
3342       if(dlInfo->msg4Alloc != NULLP)
3343       {
3344          txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen;
3345       }
3346
3347       LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize);
3348       if(txDataReq == NULLP)
3349       {
3350          DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
3351          return RFAILED;
3352       }
3353
3354       memset(txDataReq, 0, txDataReqMsgSize);
3355                 txDataReq->sfn  = currTimingInfo.sfn;
3356                 txDataReq->slot = currTimingInfo.slot;
3357       txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \
3358          (sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *)));
3359
3360       if(dlInfo->brdcstAlloc.sib1Trans)
3361       {
3362          fillSib1TxDataReq(txDataReq->pduDesc,
3363                &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex);
3364          pduIndex++;
3365          txDataReq->numPdus++;
3366       }
3367       if(dlInfo->rarAlloc != NULLP)
3368       {
3369          fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc->rarInfo, &msgLen, pduIndex);
3370          pduIndex++;
3371          txDataReq->numPdus++;
3372
3373          MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc));
3374          dlInfo->rarAlloc = NULLP;
3375       }
3376       if(dlInfo->msg4Alloc != NULLP)
3377       {
3378          fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\
3379              msg4Info, &msgLen, pduIndex);
3380          pduIndex++;
3381          txDataReq->numPdus++;
3382
3383          MAC_FREE(dlInfo->msg4Alloc,sizeof(Msg4Alloc));
3384          dlInfo->msg4Alloc = NULLP;
3385       }
3386       msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t);
3387       fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen);
3388       LwrMacSendToPhy(txDataReq->header.message_type_id, txDataReqMsgSize, \
3389          (void *)txDataReq);
3390    }
3391 #endif
3392    return ROK;
3393 }
3394
3395 /***********************************************************************
3396  *
3397  * @brief calculates the total size to be allocated for UL TTI Req
3398  *
3399  * @details
3400  *
3401  *    Function : getnPdus
3402  *
3403  *    Functionality:
3404  *         -calculates the total pdu count to be allocated for UL TTI Req
3405  *
3406  * @params[in] Pointer to fapi Ul TTI Req
3407  *             Pointer to CurrUlSlot
3408  * @return count
3409  * ********************************************************************/
3410 #ifdef FAPI
3411 uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot)
3412 {
3413    uint8_t pduCount = 0;
3414
3415    if(ulTtiReq && currUlSlot)
3416         {
3417                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
3418                 {
3419                         pduCount++;
3420                         ulTtiReq->rachPresent = PDU_PRESENT;
3421                 }
3422                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
3423                 {
3424                         pduCount++;
3425                         ulTtiReq->nUlsch++;
3426                 }
3427                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
3428                 {
3429                         pduCount++;
3430                         ulTtiReq->nUlsch++;
3431                         ulTtiReq->nUlsch = PDU_PRESENT;
3432                 }
3433                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI)
3434                 {
3435                         pduCount++;
3436                         ulTtiReq->nUlcch = PDU_PRESENT;
3437                 }
3438                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS)
3439                 {
3440                         pduCount++;
3441                 }
3442         }
3443    return pduCount;
3444 }
3445 #endif
3446
3447 /***********************************************************************
3448  *
3449  * @brief Set the value of zero correlation config in PRACH PDU
3450  *
3451  * @details
3452  *
3453  *    Function : setNumCs
3454  *
3455  *    Functionality:
3456  *         -Set the value of zero correlation config in PRACH PDU
3457  *
3458  * @params[in] Pointer to zero correlation config
3459  *             Pointer to MacCellCfg
3460  * ********************************************************************/
3461
3462 void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg)
3463 {
3464 #ifdef FAPI
3465    uint8_t idx;
3466    if(macCellCfg != NULLP)
3467    {
3468       idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg;
3469       *numCs = UnrestrictedSetNcsTable[idx];
3470    }
3471 #endif
3472 }
3473
3474 /***********************************************************************
3475  *
3476  * @brief Fills the PRACH PDU in UL TTI Request
3477  *
3478  * @details
3479  *
3480  *    Function : fillPrachPdu
3481  *
3482  *    Functionality:
3483  *         -Fills the PRACH PDU in UL TTI Request
3484  *
3485  * @params[in] Pointer to Prach Pdu
3486  *             Pointer to CurrUlSlot
3487  *             Pointer to macCellCfg
3488  *             Pointer to msgLen
3489  * ********************************************************************/
3490
3491 #ifdef FAPI
3492 void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3493 {
3494    if(ulTtiReqPdu != NULLP)
3495    {
3496       ulTtiReqPdu->pduType = PRACH_PDU_TYPE;
3497       ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId;
3498       ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulInfo.prachSchInfo.numPrachOcas;
3499       ulTtiReqPdu->u.prach_pdu.prachFormat = \
3500       currUlSlot->ulInfo.prachSchInfo.prachFormat;
3501       ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa;
3502       ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \
3503       currUlSlot->ulInfo.prachSchInfo.prachStartSymb;
3504       setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg);
3505       ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0;
3506       ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0;
3507       ulTtiReqPdu->u.prach_pdu.beamforming.digBfInterfaces = 0;
3508       ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0;
3509       ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0;
3510       ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t);
3511
3512       SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3513          sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t)));
3514    }
3515 }
3516
3517 void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3518 {
3519    if(ulTtiReqPdu != NULLP)
3520    {
3521       ulTtiReqPdu->pduType = PUSCH_PDU_TYPE;
3522       ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1;
3523       ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulInfo.crnti;
3524                 /* TODO : Fill handle in raCb when scheduling pusch and access here */
3525       ulTtiReqPdu->u.pusch_pdu.handle = 100;
3526       ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
3527       ulTtiReqPdu->u.pusch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb;
3528       ulTtiReqPdu->u.pusch_pdu.subCarrierSpacing = \
3529                    macCellCfg->initialUlBwp.bwp.scs;
3530       ulTtiReqPdu->u.pusch_pdu.cyclicPrefix = \
3531                    macCellCfg->initialUlBwp.bwp.cyclicPrefix;
3532       ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308;
3533       ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2;
3534       ulTtiReqPdu->u.pusch_pdu.mcsIndex = \
3535                    currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs;
3536       ulTtiReqPdu->u.pusch_pdu.mcsTable = 0;
3537       ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1;
3538       ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId;
3539       ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1;
3540       ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4;
3541       ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0;
3542       ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId;
3543       ulTtiReqPdu->u.pusch_pdu.scid = 0;
3544       ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1;
3545       ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0;
3546       ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \
3547                    currUlSlot->ulInfo.schPuschInfo.resAllocType;
3548       ulTtiReqPdu->u.pusch_pdu.rbStart = \
3549                    currUlSlot->ulInfo.schPuschInfo.fdAlloc.startPrb;
3550       ulTtiReqPdu->u.pusch_pdu.rbSize = \
3551                    currUlSlot->ulInfo.schPuschInfo.fdAlloc.numPrb;
3552       ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0;
3553       ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0;
3554       ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0;
3555       ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0;
3556       ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \
3557                    currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb;
3558       ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \
3559                    currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb;
3560       ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \
3561                    currUlSlot->ulInfo.schPuschInfo.tbInfo.rv;
3562       ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \
3563                    currUlSlot->ulInfo.schPuschInfo.harqProcId;
3564       ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \
3565                    currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi;
3566       ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \
3567                    currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize;
3568                 /* numCb is 0 for new transmission */
3569       ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0;
3570
3571       ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t);
3572
3573       SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3574          sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t)));
3575    }
3576 }
3577 #endif
3578
3579 /*******************************************************************
3580  *
3581  * @brief Sends UL TTI Request to PHY
3582  *
3583  * @details
3584  *
3585  *    Function : handleUlTtiReq
3586  *
3587  *    Functionality:
3588  *         -Sends FAPI Param req to PHY
3589  *
3590  * @params[in]  Pointer to CmLteTimingInfo
3591  * @return ROK     - success
3592  *         RFAILED - failure
3593  *
3594  ******************************************************************/
3595 uint16_t handleUlTtiReq(SlotIndInfo currTimingInfo)
3596 {
3597 #ifdef FAPI
3598    uint8_t    pduIdx = -1;
3599    uint8_t    numPdu = 0;
3600    uint32_t   msgLen = 0;
3601    uint32_t   msgSize = 0;
3602
3603    fapi_ul_tti_req_t *ulTtiReq = NULLP;
3604    SlotIndInfo ulTtiReqTimingInfo;
3605
3606    RgCellCb  *cellCbParams = NULLP;
3607    MacUlSlot *currUlSlot = NULLP;
3608    MacCellCfg macCellCfg;
3609    Inst inst = 0;
3610
3611    if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3612         {
3613                 cellCbParams = rgCb[inst].cell;
3614                 macCellCfg = cellCbParams->macCellCfg;
3615
3616                 /* add PHY delta */
3617                 ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA);
3618
3619                 currUlSlot = &macCb.macCell->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED];
3620                 numPdu = getnPdus(NULL, currUlSlot);
3621                 msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu*sizeof(fapi_ul_tti_req_pdu_t));
3622                 LWR_MAC_ALLOC(ulTtiReq, msgSize);
3623
3624                 if(ulTtiReq != NULLP)
3625                 {
3626                         memset(ulTtiReq, 0, msgSize);
3627                         ulTtiReq->sfn  = currTimingInfo.sfn;
3628                         ulTtiReq->slot = currTimingInfo.slot;
3629                         ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
3630                         ulTtiReq->nGroup = 0;
3631                         if(ulTtiReq->nPdus > 0)
3632                         {
3633                                 ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
3634                                                 (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
3635                                 /* Fill Prach Pdu */
3636                                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
3637                                 {
3638                                         pduIdx++;
3639                                         fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3640                                 }
3641
3642                                 /* Fill PUSCH PDU */
3643                                 if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
3644                                 {
3645                                         pduIdx++;
3646                                         fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3647                                 }
3648
3649                                 if((currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) || \
3650                                                 (currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH))
3651                                 {
3652                                         msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
3653                                         fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3654
3655                                         DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3656                                         LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3657                                 }
3658                         }
3659                         else
3660                         {
3661                                 msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
3662                                 fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3663
3664                                 DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3665                                 LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3666                         }
3667                         memset(&currUlSlot, 0, sizeof(MacUlSlot));
3668                         return ROK;
3669                 }
3670                 else
3671                 {
3672                         DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
3673                         memset(&currUlSlot, 0, sizeof(MacUlSlot));
3674                         return RFAILED;
3675                 }
3676         }
3677    else
3678    {
3679        lwr_mac_handleInvalidEvt(&currTimingInfo);
3680    }
3681 #endif
3682    return ROK;
3683 }
3684
3685 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
3686 {
3687    {
3688       /* PHY_STATE_IDLE */
3689        lwr_mac_handleParamReqEvt,
3690        lwr_mac_handleParamRspEvt,
3691        lwr_mac_handleConfigReqEvt,
3692        lwr_mac_handleConfigRspEvt,
3693        lwr_mac_handleInvalidEvt,
3694        lwr_mac_handleInvalidEvt,
3695    },
3696    {
3697        /* PHY_STATE_CONFIGURED */
3698        lwr_mac_handleParamReqEvt,
3699        lwr_mac_handleParamRspEvt,
3700        lwr_mac_handleConfigReqEvt,
3701        lwr_mac_handleConfigRspEvt,
3702        lwr_mac_handleStartReqEvt,
3703        lwr_mac_handleInvalidEvt,
3704    },
3705    {
3706        /* PHY_STATE_RUNNING */
3707        lwr_mac_handleInvalidEvt,
3708        lwr_mac_handleInvalidEvt,
3709        lwr_mac_handleConfigReqEvt,
3710        lwr_mac_handleConfigRspEvt,
3711        lwr_mac_handleInvalidEvt,
3712        lwr_mac_handleStopReqEvt,
3713    }
3714 };
3715
3716 /*******************************************************************
3717  *
3718  * @brief Sends message to LWR_MAC Fsm Event Handler
3719  *
3720  * @details
3721  *
3722  *    Function : sendToLowerMac
3723  *
3724  *    Functionality:
3725  *         -Sends message to LowerMac
3726  *
3727  * @params[in] Message Type
3728  *             Message Length
3729  *             Messaga Pointer
3730  *
3731  * @return void
3732  *
3733 ******************************************************************/
3734 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
3735 {
3736    clGlobalCp.event = msgType;
3737    fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
3738 }
3739 /**********************************************************************
3740          End of file
3741 **********************************************************************/