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