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