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 S16 lwr_mac_handleStopReqEvt(void *msg)
2142 {
2143 #ifdef FAPI
2144    /* stop TX and RX operation return PHy to configured State
2145       send stop.indication to l2/l3 */
2146 #endif
2147    return ROK;
2148 }
2149
2150 /*******************************************************************
2151  *
2152  * @brief Modifes the received mibPdu to uint32 bit
2153  *        and stores it in MacCellCfg
2154  *
2155  * @details
2156  *
2157  *    Function : setMibPdu
2158  *
2159  *    Functionality:
2160  *         -Sets the MibPdu
2161  *
2162  * @params[in] Pointer to mibPdu
2163  *             pointer to modified value
2164  ******************************************************************/
2165
2166 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val)
2167 {
2168    *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK);
2169    *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2170     DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
2171 }
2172
2173 #ifdef FAPI
2174 /*******************************************************************
2175  *
2176  * @brief fills SSB PDU required for DL TTI info in MAC
2177  *
2178  * @details
2179  *
2180  *    Function : fillSsbPdu
2181  *
2182  *    Functionality:
2183  *         -Fills the SSB PDU info
2184  *          stored in MAC
2185  *
2186  * @params[in] Pointer to FAPI DL TTI Req
2187  *             Pointer to RgCellCb
2188  *             Pointer to msgLen of DL TTI Info
2189  * @return ROK
2190  *
2191  ******************************************************************/
2192
2193 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2194         MacDlSlot *currDlSlot,
2195         uint32_t *msgLen, uint8_t ssbIdxCount)
2196 {
2197    uint32_t mibPayload = 0;
2198    if(dlTtiReqPdu != NULL)
2199    {
2200       dlTtiReqPdu->pduType = SSB_PDU_TYPE;     /* SSB PDU */
2201       dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2202       dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2203       dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx;
2204       dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2205       /* ssbOfPdufstA to be filled in ssbCfg */
2206       dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2207       dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2208       /* Bit manipulation for SFN */
2209       setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload);
2210       dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2211       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2212       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2213       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2214       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2215       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2216          pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2217       dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t);  /* Size of SSB PDU */
2218       SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2219          sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_ssb_pdu_t)));
2220       return ROK;
2221     }
2222     else
2223     {
2224        return RFAILED;
2225     }
2226 }
2227
2228 /*******************************************************************
2229  *
2230  * @brief fills Dl DCI PDU required for DL TTI info in MAC
2231  *
2232  * @details
2233  *
2234  *    Function : fillSib1DlDciPdu
2235  *
2236  *    Functionality:
2237  *         -Fills the Dl DCI PDU
2238  *
2239  * @params[in] Pointer to fapi_dl_dci_t
2240  *             Pointer to PdcchCfg
2241  * @return ROK
2242  *
2243  ******************************************************************/
2244
2245 void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo)
2246 {
2247    if(dlDciPtr != NULLP)
2248    {
2249       uint8_t numBytes;
2250       uint8_t bytePos;
2251       uint8_t bitPos;
2252
2253       uint16_t coreset0Size;
2254       uint16_t rbStart;
2255       uint16_t rbLen;
2256       uint32_t freqDomResAssign;
2257       uint32_t timeDomResAssign;
2258       uint8_t  VRB2PRBMap;
2259       uint32_t modNCodScheme;
2260       uint8_t  redundancyVer;
2261       uint32_t sysInfoInd;
2262       uint32_t reserved;
2263
2264       /* Size(in bits) of each field in DCI format 0_1
2265                  * as mentioned in spec 38.214 */
2266       uint8_t freqDomResAssignSize;
2267       uint8_t timeDomResAssignSize = 4;
2268       uint8_t VRB2PRBMapSize       = 1;
2269       uint8_t modNCodSchemeSize    = 5;
2270       uint8_t redundancyVerSize    = 2;
2271       uint8_t sysInfoIndSize       = 1;
2272       uint8_t reservedSize         = 15;
2273
2274       dlDciPtr->rnti = sib1PdcchInfo->dci.rnti;
2275       dlDciPtr->scramblingId = sib1PdcchInfo->dci.scramblingId;
2276       dlDciPtr->scramblingRnti = sib1PdcchInfo->dci.scramblingRnti;
2277       dlDciPtr->cceIndex = sib1PdcchInfo->dci.cceIndex;
2278       dlDciPtr->aggregationLevel = sib1PdcchInfo->dci.aggregLevel;
2279       dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->dci.beamPdcchInfo.numPrgs;
2280       dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->dci.beamPdcchInfo.prgSize;
2281       dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2282       dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2283       dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2284       dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue;
2285       dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2286
2287       /* Calculating freq domain resource allocation field value and size
2288        * coreset0Size = Size of coreset 0
2289        * RBStart = Starting Virtual Rsource block
2290        * RBLen = length of contiguously allocted RBs
2291        * Spec 38.214 Sec 5.1.2.2.2
2292        */
2293       coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size;
2294                 rbStart = 0;              /* For SIB1 */
2295       //rbStart = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2296       rbLen = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
2297
2298       if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2299       {
2300          if((rbLen - 1) <= floor(coreset0Size / 2))
2301             freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2302          else
2303             freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2304                + (coreset0Size - 1 - rbStart);
2305
2306          freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2307       }
2308
2309       /* Fetching DCI field values */
2310       timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->timeAlloc.
2311                          rowIndex -1;
2312       VRB2PRBMap       = sib1PdcchInfo->dci.pdschCfg->freqAlloc.\
2313                          vrbPrbMapping;
2314       modNCodScheme    = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2315       redundancyVer    = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
2316       sysInfoInd       = 0;           /* 0 for SIB1; 1 for SI messages */
2317       reserved         = 0;
2318
2319       /* Reversing bits in each DCI field */
2320       freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2321       timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2322       VRB2PRBMap       = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2323       modNCodScheme    = reverseBits(modNCodScheme, modNCodSchemeSize);
2324       redundancyVer    = reverseBits(redundancyVer, redundancyVerSize);
2325       sysInfoInd       = reverseBits(sysInfoInd, sysInfoIndSize);
2326
2327      /* Calulating total number of bytes in buffer */
2328      dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2329               + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
2330               + sysInfoIndSize + reservedSize;
2331
2332      numBytes = dlDciPtr->payloadSizeBits / 8;
2333      if(dlDciPtr->payloadSizeBits % 8)
2334         numBytes += 1;
2335
2336      if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2337      {
2338         DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2339         return;
2340      }
2341
2342      /* Initialize buffer */
2343      for(bytePos = 0; bytePos < numBytes; bytePos++)
2344         dlDciPtr->payload[bytePos] = 0;
2345
2346      bytePos = numBytes - 1;
2347      bitPos = 0;
2348
2349      /* Packing DCI format fields */
2350      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2351         freqDomResAssign, freqDomResAssignSize);
2352      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2353         timeDomResAssign, timeDomResAssignSize);
2354      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2355         VRB2PRBMap, VRB2PRBMapSize);
2356      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2357         modNCodScheme, modNCodSchemeSize);
2358      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2359         redundancyVer, redundancyVerSize);
2360      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2361         sysInfoInd, sysInfoIndSize);
2362      fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2363         reserved, reservedSize);
2364
2365    }
2366 } /* fillSib1DlDciPdu */
2367
2368 /*******************************************************************
2369  *
2370  * @brief fills Dl DCI PDU required for DL TTI info in MAC
2371  *
2372  * @details
2373  *
2374  *    Function : fillRarDlDciPdu
2375  *
2376  *    Functionality:
2377  *         -Fills the Dl DCI PDU
2378  *
2379  * @params[in] Pointer to fapi_dl_dci_t
2380  *             Pointer to PdcchCfg
2381  * @return ROK
2382  *
2383  ******************************************************************/
2384
2385 void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo)
2386 {
2387         if(dlDciPtr != NULLP)
2388         {
2389                 uint8_t numBytes;
2390                 uint8_t bytePos;
2391                 uint8_t bitPos;
2392
2393                 uint16_t coreset0Size;
2394                 uint16_t rbStart;
2395                 uint16_t rbLen;
2396                 uint32_t freqDomResAssign;
2397                 uint8_t timeDomResAssign;
2398                 uint8_t  VRB2PRBMap;
2399                 uint8_t modNCodScheme;
2400                 uint8_t tbScaling;
2401                 uint32_t reserved;
2402
2403                 /* Size(in bits) of each field in DCI format 1_0 */
2404                 uint8_t freqDomResAssignSize;
2405                 uint8_t timeDomResAssignSize = 4;
2406                 uint8_t VRB2PRBMapSize       = 1;
2407                 uint8_t modNCodSchemeSize    = 5;
2408                 uint8_t tbScalingSize        = 2;
2409                 uint8_t reservedSize         = 16;
2410
2411                 dlDciPtr->rnti = rarPdcchInfo->dci.rnti;
2412                 dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId;
2413                 dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti;
2414                 dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex;
2415                 dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel;
2416                 dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs;
2417                 dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize;
2418                 dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces;
2419                 dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
2420                 dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
2421                 dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue;
2422                 dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
2423
2424                 /* Calculating freq domain resource allocation field value and size
2425                  * coreset0Size = Size of coreset 0
2426                  * RBStart = Starting Virtual Rsource block
2427                  * RBLen = length of contiguously allocted RBs
2428                  * Spec 38.214 Sec 5.1.2.2.2
2429                  */
2430
2431                 /* TODO: Fill values of coreset0Size, rbStart and rbLen */
2432                 coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size;
2433                 rbStart = 0;              /* For SIB1 */
2434                 //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
2435                 rbLen = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
2436
2437                 if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
2438                 {
2439                         if((rbLen - 1) <= floor(coreset0Size / 2))
2440                                 freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart;
2441                         else
2442                                 freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \
2443                                                                                  + (coreset0Size - 1 - rbStart);
2444
2445                         freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
2446                 }
2447
2448                 /* Fetching DCI field values */
2449                 timeDomResAssign = rarPdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1;
2450                 VRB2PRBMap       = rarPdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping;
2451                 modNCodScheme    = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
2452                 tbScaling        = 0; /* configured to 0 scaling */
2453                 reserved         = 0;
2454
2455                 /* Reversing bits in each DCI field */
2456                 freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
2457                 timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
2458                 VRB2PRBMap       = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
2459                 modNCodScheme    = reverseBits(modNCodScheme, modNCodSchemeSize);
2460                 tbScaling        = reverseBits(tbScaling, tbScalingSize);
2461
2462                 /* Calulating total number of bytes in buffer */
2463                 dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
2464                                                                                          + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize;
2465
2466                 numBytes = dlDciPtr->payloadSizeBits / 8;
2467                 if(dlDciPtr->payloadSizeBits % 8)
2468                         numBytes += 1;
2469
2470                 if(numBytes > DCI_PAYLOAD_BYTE_LEN)
2471                 {
2472                         DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
2473                         return;
2474                 }
2475
2476                 /* Initialize buffer */
2477                 for(bytePos = 0; bytePos < numBytes; bytePos++)
2478                         dlDciPtr->payload[bytePos] = 0;
2479
2480                 bytePos = numBytes - 1;
2481                 bitPos = 0;
2482
2483                 /* Packing DCI format fields */
2484                 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2485                                 freqDomResAssign, freqDomResAssignSize);
2486                 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2487                                 timeDomResAssign, timeDomResAssignSize);
2488                 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2489                                 VRB2PRBMap, VRB2PRBMapSize);
2490                 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2491                                 modNCodScheme, modNCodSchemeSize);
2492                 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2493                                 tbScaling, tbScalingSize);
2494                 fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
2495                                 reserved, reservedSize);
2496         }
2497 } /* fillRarDlDciPdu */
2498
2499 /*******************************************************************
2500  *
2501  * @brief fills PDCCH PDU required for DL TTI info in MAC
2502  *
2503  * @details
2504  *
2505  *    Function : fillPdcchPdu
2506  *
2507  *    Functionality:
2508  *         -Fills the Pdcch PDU info
2509  *          stored in MAC
2510  *
2511  * @params[in] Pointer to FAPI DL TTI Req
2512  *             Pointer to PdcchCfg
2513  *             Pointer to msgLen of DL TTI Info
2514  * @return ROK
2515  *
2516  ******************************************************************/
2517
2518 S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdcchCfg *pdcchInfo,
2519 uint32_t *msgLen)
2520 {
2521     if(dlTtiReqPdu != NULLP)
2522     {
2523        dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
2524        dlTtiReqPdu->u.pdcch_pdu.bwpSize = pdcchInfo->pdcchBwpCfg.BWPSize;
2525        dlTtiReqPdu->u.pdcch_pdu.bwpPart = pdcchInfo->pdcchBwpCfg.BWPStart;
2526        dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = pdcchInfo->pdcchBwpCfg.subcarrierSpacing;
2527        dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = pdcchInfo->pdcchBwpCfg.cyclicPrefix;
2528        dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex;
2529        dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols;
2530        memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6);
2531        dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType;
2532        dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize;
2533        dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize;
2534        dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType;
2535        dlTtiReqPdu->u.pdcch_pdu.shiftIndex =  pdcchInfo->coreset0Cfg.shiftIndex;
2536        dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity;
2537        dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
2538        dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \
2539           (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \
2540           (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*)));
2541
2542        if(pdcchInfo->dci.rnti == SI_RNTI)
2543                  {
2544           fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2545        }
2546                  else
2547                  {
2548           fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
2549                  }
2550
2551         /* Calculating PDU length. Considering only one dl dci pdu for now */
2552        dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t);
2553        SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2554           sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize));
2555
2556     }
2557     return ROK;
2558
2559 }
2560
2561 /*******************************************************************
2562  *
2563  * @brief fills PDSCH PDU required for DL TTI info in MAC
2564  *
2565  * @details
2566  *
2567  *    Function : fillPdschPdu
2568  *
2569  *    Functionality:
2570  *         -Fills the Pdsch PDU info
2571  *          stored in MAC
2572  *
2573  * @params[in] Pointer to FAPI DL TTI Req
2574  *             Pointer to PdschCfg
2575  *             Pointer to msgLen of DL TTI Info
2576  * @return ROK
2577  *
2578  ******************************************************************/
2579
2580 void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
2581 uint32_t *msgLen, uint16_t pduIndex)
2582 {
2583     uint8_t idx;
2584
2585     if(dlTtiReqPdu != NULLP)
2586     {
2587        dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
2588        dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap;
2589        dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti;
2590        dlTtiReqPdu->u.pdsch_pdu.pduIndex = pduIndex;
2591        dlTtiReqPdu->u.pdsch_pdu.bwpSize = pdschInfo->pdschBwpCfg.BWPSize;
2592        dlTtiReqPdu->u.pdsch_pdu.bwpStart = pdschInfo->pdschBwpCfg.BWPStart;
2593        dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = pdschInfo->pdschBwpCfg.subcarrierSpacing;
2594        dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = pdschInfo->pdschBwpCfg.cyclicPrefix;
2595        dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
2596        for(idx = 0; idx < MAX_CODEWORDS ; idx++)
2597        {
2598           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
2599           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
2600           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
2601           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
2602           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
2603           dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
2604        }
2605        dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId;
2606        dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = pdschInfo->numLayers;
2607        dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme;
2608        dlTtiReqPdu->u.pdsch_pdu.refPoint = pdschInfo->refPoint;
2609        dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos;
2610        dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType;
2611        dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId;
2612        dlTtiReqPdu->u.pdsch_pdu.scid = pdschInfo->dmrs.scid;
2613        dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData;
2614        dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts;
2615        dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->freqAlloc.resourceAlloc;
2616        /* since we are using type-1, hence rbBitmap excluded */
2617        dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->freqAlloc.rbStart;
2618        dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->freqAlloc.rbSize;
2619        dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->freqAlloc.vrbPrbMapping;
2620        dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->timeAlloc.startSymbolIndex;
2621        dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->timeAlloc.numSymbols;
2622        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs;
2623        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize;
2624        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces;
2625        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2626           pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
2627        dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
2628           beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
2629        dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;
2630        dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
2631        dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
2632
2633        SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
2634           sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_pdsch_pdu_t)));
2635
2636     }
2637
2638 }
2639
2640 /***********************************************************************
2641  *
2642  * @brief calculates the total size to be allocated for DL TTI Req
2643  *
2644  * @details
2645  *
2646  *    Function : calcDlTtiReqPduCount
2647  *
2648  *    Functionality:
2649  *         -calculates the total pdu count to be allocated for DL TTI Req
2650  *
2651  * @params[in]    DlBrdcstAlloc *cellBroadcastInfo
2652  * @return count
2653  *
2654  * ********************************************************************/
2655 uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo)
2656 {
2657    uint8_t count = 0;
2658    uint8_t idx = 0;
2659         if(dlInfo->isBroadcastPres)
2660         {
2661       if(dlInfo->brdcstAlloc.ssbTrans)
2662       {
2663          for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
2664          {
2665             count++;
2666          }
2667       }
2668       if(dlInfo->brdcstAlloc.sib1Trans)
2669       {
2670          count += 2;
2671       }
2672    }
2673         if(dlInfo->isRarPres)
2674         {
2675            count += 2;
2676         }
2677    return count;
2678 }
2679
2680 /***********************************************************************
2681  *
2682  * @brief calculates the total size to be allocated for DL TTI Req
2683  *
2684  * @details
2685  *
2686  *    Function : calcTxDataReqPduCount
2687  *
2688  *    Functionality:
2689  *         -calculates the total pdu count to be allocated for DL TTI Req
2690  *
2691  * @params[in]    DlBrdcstAlloc *cellBroadcastInfo
2692  * @return count
2693  *
2694  * ********************************************************************/
2695 uint8_t calcTxDataReqPduCount(DlAlloc *dlInfo)
2696 {
2697    uint8_t count = 0;
2698         if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
2699         {
2700          count++;
2701    }
2702         if(dlInfo->isRarPres)
2703         {
2704            count++;
2705         }
2706    return count;
2707 }
2708 /***********************************************************************
2709  *
2710  * @brief fills the SIB1 TX-DATA request message
2711  *
2712  * @details
2713  *
2714  *    Function : fillSib1TxDataReq
2715  *
2716  *    Functionality:
2717  *         - fills the SIB1 TX-DATA request message
2718  *
2719  * @params[in]    fapi_tx_pdu_desc_t *pduDesc
2720  * @params[in]    macCellCfg consist of SIB1 pdu
2721  * @params[in]    uint32_t *msgLen
2722  * @params[in]    uint16_t pduIndex
2723  * @return ROK
2724  *
2725  * ********************************************************************/
2726 uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg,
2727    uint32_t *msgLen, uint16_t pduIndex)
2728 {
2729    uint32_t pduLen = 0;
2730         uint32_t *sib1TxdataValue = NULLP;
2731
2732         pduDesc[pduIndex].pduIndex = pduIndex;
2733         pduDesc[pduIndex].numTlvs = 1;
2734
2735         /* fill the TLV */
2736         /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
2737         pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
2738         pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen;
2739         LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2740         if(sib1TxdataValue == NULLP)
2741         {
2742            return RFAILED;
2743         }
2744         memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu,
2745            macCellCfg->sib1Cfg.sib1PduLen);
2746         pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue;
2747
2748    /* The total length of the PDU description and       PDU data */
2749         pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
2750         pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
2751    pduDesc[pduIndex].pduLength = pduLen;
2752         msgLen += pduLen;
2753
2754 #ifndef INTEL_WLS
2755    MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
2756 #endif
2757
2758
2759         return ROK;
2760 }
2761
2762 /***********************************************************************
2763  *
2764  * @brief fills the RAR TX-DATA request message
2765  *
2766  * @details
2767  *
2768  *    Function : fillRarTxDataReq
2769  *
2770  *    Functionality:
2771  *         - fills the RAR TX-DATA request message
2772  *
2773  * @params[in]    fapi_tx_pdu_desc_t *pduDesc
2774  * @params[in]    RarInfo *rarInfo
2775  * @params[in]    uint32_t *msgLen
2776  * @params[in]    uint16_t pduIndex
2777  * @return ROK
2778  *
2779  * ********************************************************************/
2780 uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
2781    uint32_t *msgLen, uint16_t pduIndex)
2782 {
2783    uint32_t pduLen = 0;
2784         uint32_t *rarTxdataValue = NULLP;
2785
2786         pduDesc[pduIndex].pduIndex = pduIndex;
2787         pduDesc[pduIndex].numTlvs = 1;
2788
2789         /* fill the TLV */
2790         /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
2791         pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */
2792         pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen;
2793         LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen);
2794         if(rarTxdataValue == NULLP)
2795         {
2796            return RFAILED;
2797         }
2798         memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen);
2799         pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue;
2800
2801    /* The total length of the PDU description and       PDU data */
2802         pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */
2803         pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */
2804    pduDesc[pduIndex].pduLength = pduLen;
2805         msgLen += pduLen;
2806
2807 /* TODO: The pointer value which was stored, needs to be free-ed at PHY *
2808  * But since we did not implement WLS, this has to be done here
2809  */
2810 #ifndef INTEL_WLS
2811    MAC_FREE(rarTxdataValue,rarInfo->rarPduLen);
2812 #endif
2813
2814         return ROK;
2815 }
2816
2817 #endif
2818
2819 /*******************************************************************
2820  *
2821  * @brief Sends DL TTI Request to PHY
2822  *
2823  * @details
2824  *
2825  *    Function : handleDlTtiReq
2826  *
2827  *    Functionality:
2828  *         -Sends FAPI DL TTI req to PHY
2829  *
2830  * @params[in]    timing info
2831  * @return ROK     - success
2832  *         RFAILED - failure
2833  *
2834  * ****************************************************************/
2835 uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo)
2836 {
2837 #ifdef FAPI
2838         uint8_t idx;
2839         uint8_t nPdu = 0;
2840         uint8_t numPduEncoded = 0;
2841         uint16_t pduIndex = 0;
2842         uint32_t msgLen = 0;
2843         uint32_t dlTtiReqMsgSize = 0;
2844         fapi_dl_tti_req_t *dlTtiReq = NULLP;
2845         RgCellCb  *cellCbParams = NULLP;
2846         MacDlSlot *currDlSlot = NULLP;
2847         MacCellCfg macCellCfg;
2848         memset(&macCellCfg, 0, sizeof(MacCellCfg));
2849         Inst inst = 0;
2850
2851         if(clGlobalCp.phyState == PHY_STATE_RUNNING)
2852         {
2853                 cellCbParams = rgCb[inst].cell;
2854                 macCellCfg = cellCbParams->macCellCfg;
2855
2856                 if(currTimingInfo != NULLP)
2857                 {
2858          currDlSlot = &macCb.macCell->dlSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED];
2859          nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
2860          dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
2861                      sizeof(fapi_dl_tti_req_pdu_t));
2862          if(nPdu > 0)
2863          {
2864             if(currDlSlot->dlInfo.isBroadcastPres)
2865             {
2866                if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
2867                {
2868                   dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
2869                }
2870
2871             }
2872             if(currDlSlot->dlInfo.isRarPres)
2873             {
2874                dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
2875             }
2876          }
2877                    LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
2878
2879                         if(dlTtiReq != NULLP)
2880                         {
2881                            memset(dlTtiReq, 0, dlTtiReqMsgSize);
2882
2883                                 dlTtiReq->sfn = currTimingInfo->sfn;
2884                                 dlTtiReq->slot = currTimingInfo->slot;
2885                                 dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo);  /* get total Pdus */
2886                                 nPdu = dlTtiReq->nPdus;
2887                                 dlTtiReq->nGroup = 0;
2888                                 if(dlTtiReq->nPdus > 0)
2889                                 {
2890                dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \
2891                   (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*)));
2892                if(!dlTtiReq->pdus)
2893                {
2894                   DU_LOG("\nLWR_MAC: Memory allocation failed");
2895                   return RFAILED;
2896                }
2897
2898                                         if(currDlSlot->dlInfo.isBroadcastPres)
2899                                         {
2900                                                 if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
2901                                                 {
2902                                                         if(dlTtiReq->pdus != NULLP)
2903                                                         {
2904                                                                 for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
2905                                                                 {
2906                                                                         fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg, currDlSlot, &msgLen, idx);
2907                                                                         numPduEncoded++;
2908                                                                 }
2909                                                         }
2910                                                         printf("\033[1;31m");
2911                                                         DU_LOG("\nLWR_MAC: MIB sent..");
2912                                                         printf("\033[0m");
2913                                                 }
2914                                                 if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
2915                                                 {
2916                                                         /* Filling SIB1 param */
2917                                                         if(numPduEncoded != nPdu)
2918                                                         {
2919                                                                 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\
2920                                                                                 sib1Alloc.sib1PdcchCfg, &msgLen);
2921                                                                 numPduEncoded++;
2922                                                                 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\
2923                                                                                 sib1Alloc.sib1PdschCfg, &msgLen, pduIndex);
2924                                                                 pduIndex++;
2925                                                                 numPduEncoded++;
2926                                                         }
2927                                                         printf("\033[1;34m");
2928                                                         DU_LOG("\nLWR_MAC: SIB1 sent...");
2929                                                         printf("\033[0m");
2930                                                 }
2931                                         }
2932                                         if(currDlSlot->dlInfo.isRarPres)
2933                                         {
2934                                                 /* Filling RAR param */
2935                                  fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo);
2936                                                 fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdcchCfg, &msgLen);
2937                                                 numPduEncoded++;
2938                                                 fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdschCfg,
2939                                                    &msgLen, pduIndex);
2940                                                 numPduEncoded++;
2941                                                 pduIndex++;
2942
2943                                                 printf("\033[1;32m");
2944                                                 DU_LOG("\nLWR_MAC: RAR sent...");
2945                                                 printf("\033[0m");
2946                                         }
2947
2948                                         msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2949                                         fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2950                                         LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
2951                   (void *)dlTtiReq);
2952
2953                                         /* send Tx-DATA req message */
2954                                         sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
2955                                 }
2956                                 else
2957                                 {
2958                                         msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2959                                         fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2960                                         LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
2961                                 }
2962                                 return ROK;
2963                         }
2964                         else
2965                         {
2966                                 DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
2967                                 return RFAILED;
2968                         }
2969                 }
2970       else
2971       {
2972          DU_LOG("\nLWR_MAC: Current TTI Info is NULL");
2973          return RFAILED;
2974       }
2975    }
2976    else
2977    {
2978        lwr_mac_handleInvalidEvt(currTimingInfo);
2979                  return RFAILED;
2980    }
2981 #endif
2982    return ROK;
2983 }
2984
2985 /*******************************************************************
2986  *
2987  * @brief Sends TX data Request to PHY
2988  *
2989  * @details
2990  *
2991  *    Function : sendTxDataReq
2992  *
2993  *    Functionality:
2994  *         -Sends FAPI TX data req to PHY
2995  *
2996  * @params[in]    timing info
2997  * @return ROK     - success
2998  *         RFAILED - failure
2999  *
3000  * ****************************************************************/
3001 uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo)
3002 {
3003 #ifdef FAPI
3004         uint8_t nPdu = 0;
3005         uint32_t msgLen = 0;
3006    uint16_t pduIndex = 0;
3007         uint32_t txDataReqMsgSize = 0;
3008         fapi_tx_data_req_t *txDataReq = NULLP;
3009         Inst inst = 0;
3010
3011         /* send TX_Data request message */
3012         nPdu = calcTxDataReqPduCount(dlInfo);
3013         if(nPdu > 0)
3014         {
3015            txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \
3016               (nPdu * sizeof(fapi_tx_pdu_desc_t));
3017       if(dlInfo->brdcstAlloc.sib1Trans)
3018            {
3019               txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen;
3020            }
3021            if(dlInfo->isRarPres)
3022            {
3023               txDataReqMsgSize += dlInfo->rarAlloc.rarInfo.rarPduLen;
3024       }
3025
3026       LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize);
3027            if(txDataReq == NULLP)
3028            {
3029               DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
3030                    return RFAILED;
3031            }
3032
3033            memset(txDataReq, 0, txDataReqMsgSize);
3034                 txDataReq->sfn = currTimingInfo->sfn;
3035                 txDataReq->slot = currTimingInfo->slot;
3036                 txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \
3037                    (sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *)));
3038
3039                 if(dlInfo->brdcstAlloc.sib1Trans)
3040                 {
3041                         fillSib1TxDataReq(txDataReq->pduDesc,
3042                                         &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex);
3043                         pduIndex++;
3044                         txDataReq->numPdus++;
3045                 }
3046                 if(dlInfo->isRarPres)
3047                 {
3048                         /* mux and form RAR pdu */
3049                         //fillRarPdu(&dlInfo->rarAlloc.rarInfo);
3050                         fillRarTxDataReq(txDataReq->pduDesc,
3051                                         &dlInfo->rarAlloc.rarInfo, &msgLen, pduIndex);
3052                         pduIndex++;
3053                         txDataReq->numPdus++;
3054                 }
3055
3056                 msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t);
3057                 fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen);
3058                 LwrMacSendToPhy(txDataReq->header.message_type_id, txDataReqMsgSize, \
3059                    (void *)txDataReq);
3060         }
3061 #endif
3062         return ROK;
3063 }
3064
3065 /***********************************************************************
3066  *
3067  * @brief calculates the total size to be allocated for UL TTI Req
3068  *
3069  * @details
3070  *
3071  *    Function : getnPdus
3072  *
3073  *    Functionality:
3074  *         -calculates the total pdu count to be allocated for UL TTI Req
3075  *
3076  * @params[in] Pointer to fapi Ul TTI Req
3077  *             Pointer to CurrUlSlot
3078  * @return count
3079  * ********************************************************************/
3080 #ifdef FAPI
3081 uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot)
3082 {
3083         uint8_t pduCount = 0;
3084
3085         if(currUlSlot != NULLP)
3086    {
3087            if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH)
3088            {
3089               pduCount++;
3090          if(ulTtiReq)
3091                  ulTtiReq->rachPresent = PDU_PRESENT;
3092                 }
3093                 if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
3094                 {
3095                    pduCount++;
3096          if(ulTtiReq)
3097                            ulTtiReq->nUlsch = PDU_PRESENT;
3098                 }
3099                 if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI)
3100                 {
3101                    pduCount++;
3102          if(ulTtiReq)
3103                            ulTtiReq->nUlcch = PDU_PRESENT;
3104                 }
3105                 if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS)
3106                 {
3107                    pduCount++;
3108                 }
3109    }
3110         return pduCount;
3111 }
3112 #endif
3113
3114 /***********************************************************************
3115  *
3116  * @brief Set the value of zero correlation config in PRACH PDU
3117  *
3118  * @details
3119  *
3120  *    Function : setNumCs
3121  *
3122  *    Functionality:
3123  *         -Set the value of zero correlation config in PRACH PDU
3124  *
3125  * @params[in] Pointer to zero correlation config
3126  *             Pointer to MacCellCfg
3127  * ********************************************************************/
3128
3129 void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg)
3130 {
3131 #ifdef FAPI
3132    uint8_t idx;
3133         if(macCellCfg != NULLP)
3134         {
3135            idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg;
3136            *numCs = UnrestrictedSetNcsTable[idx];
3137         }
3138 #endif
3139 }
3140
3141 /***********************************************************************
3142  *
3143  * @brief Fills the PRACH PDU in UL TTI Request
3144  *
3145  * @details
3146  *
3147  *    Function : fillPrachPdu
3148  *
3149  *    Functionality:
3150  *         -Fills the PRACH PDU in UL TTI Request
3151  *
3152  * @params[in] Pointer to Prach Pdu
3153  *             Pointer to CurrUlSlot
3154  *             Pointer to macCellCfg
3155  *             Pointer to msgLen
3156  * ********************************************************************/
3157
3158 #ifdef FAPI
3159 void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
3160 {
3161    if(ulTtiReqPdu != NULLP)
3162    {
3163       ulTtiReqPdu->pduType = PRACH_PDU_TYPE;
3164       ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId;
3165       ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulCellInfo.prachSchInfo.numPrachOcas;
3166       ulTtiReqPdu->u.prach_pdu.prachFormat = \
3167                 currUlSlot->ulCellInfo.prachSchInfo.prachFormat;
3168       ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa;
3169       ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \
3170                 currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb;
3171       setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg);
3172       ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0;
3173       ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0;
3174       ulTtiReqPdu->u.prach_pdu.beamforming.digBfInterfaces = 0;
3175       ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0;
3176       ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0;
3177       ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t);
3178
3179       SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
3180          sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t)));
3181    }
3182 }
3183 #endif
3184
3185 /*******************************************************************
3186  *
3187  * @brief Sends UL TTI Request to PHY
3188  *
3189  * @details
3190  *
3191  *    Function : handleUlTtiReq
3192  *
3193  *    Functionality:
3194  *         -Sends FAPI Param req to PHY
3195  *
3196  * @params[in]  Pointer to CmLteTimingInfo
3197  * @return ROK     - success
3198  *         RFAILED - failure
3199  *
3200  ******************************************************************/
3201 uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo)
3202 {
3203 #ifdef FAPI
3204    uint8_t    pduIdx = -1;
3205    uint8_t    numPdu = 0;
3206    uint32_t   msgLen = 0;
3207    uint32_t   msgSize = 0;
3208
3209    fapi_ul_tti_req_t *ulTtiReq = NULLP;
3210    RgCellCb  *cellCbParams = NULLP;
3211    MacUlSlot *currUlSlot = NULLP;
3212    MacCellCfg macCellCfg;
3213    Inst inst = 0;
3214
3215    if(clGlobalCp.phyState == PHY_STATE_RUNNING)
3216    {
3217       cellCbParams = rgCb[inst].cell;
3218       macCellCfg = cellCbParams->macCellCfg;
3219
3220       if(currTimingInfo != NULLP)
3221       {
3222          currUlSlot = &macCb.macCell->ulSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED];
3223          numPdu = getnPdus(NULL, currUlSlot);
3224          msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu * \
3225             sizeof(fapi_ul_tti_req_pdu_t));
3226          LWR_MAC_ALLOC(ulTtiReq, msgSize);
3227
3228          if(ulTtiReq != NULLP)
3229          {
3230             ulTtiReq->sfn = currTimingInfo->sfn;
3231             ulTtiReq->slot = currTimingInfo->slot;
3232                  ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
3233             ulTtiReq->nGroup = 0;
3234             if(ulTtiReq->nPdus > 0)
3235             {
3236                ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
3237                   (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
3238                /* Fill Prach Pdu */
3239                if(ulTtiReq->rachPresent)
3240                {
3241                   pduIdx++;
3242                   fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
3243
3244                   msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
3245                   fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3246
3247                   DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3248                   LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3249                }
3250             }
3251             else
3252             {
3253                 msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
3254                 fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
3255
3256                 DU_LOG("\nLWR_MAC: Sending UL TTI Request");
3257                 LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
3258             }
3259                                 return ROK;
3260          }
3261               else
3262               {
3263                  DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
3264             return RFAILED;
3265          }
3266       }
3267       else
3268       {
3269          DU_LOG("\nLWR_MAC: Current TTI Info in UL is NULL");
3270          return RFAILED;
3271       }
3272    }
3273    else
3274    {
3275        lwr_mac_handleInvalidEvt(currTimingInfo);
3276    }
3277 #endif
3278    return ROK;
3279 }
3280
3281 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
3282 {
3283    {
3284       /* PHY_STATE_IDLE */
3285        lwr_mac_handleParamReqEvt,
3286        lwr_mac_handleParamRspEvt,
3287        lwr_mac_handleConfigReqEvt,
3288        lwr_mac_handleConfigRspEvt,
3289        lwr_mac_handleInvalidEvt,
3290    },
3291    {
3292        /* PHY_STATE_CONFIGURED */
3293        lwr_mac_handleParamReqEvt,
3294        lwr_mac_handleParamRspEvt,
3295        lwr_mac_handleConfigReqEvt,
3296        lwr_mac_handleConfigRspEvt,
3297        lwr_mac_handleStartReqEvt,
3298    },
3299    {
3300        /* PHY_STATE_RUNNING */
3301        lwr_mac_handleInvalidEvt,
3302        lwr_mac_handleInvalidEvt,
3303        lwr_mac_handleConfigReqEvt,
3304        lwr_mac_handleConfigRspEvt,
3305        lwr_mac_handleInvalidEvt,
3306    }
3307 };
3308
3309 /*******************************************************************
3310  *
3311  * @brief Sends message to LWR_MAC Fsm Event Handler
3312  *
3313  * @details
3314  *
3315  *    Function : sendToLowerMac
3316  *
3317  *    Functionality:
3318  *         -Sends message to LowerMac
3319  *
3320  * @params[in] Message Type
3321  *             Message Length
3322  *             Messaga Pointer
3323  *
3324  * @return void
3325  *
3326 ******************************************************************/
3327 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
3328 {
3329    clGlobalCp.event = msgType;
3330    fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
3331 }
3332 /**********************************************************************
3333          End of file
3334 **********************************************************************/