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