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