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 #include <stdlib.h>
  19 #include <stdint.h>
  20
  21 /* header include files -- defines (.h) */
  22 #include "envopt.h"        /* environment options */
  23 #include "envdep.h"        /* environment dependent */
  24 #include "envind.h"        /* environment independent */
  25 #include "gen.h"           /* general layer */
  26 #include "ssi.h"           /* system service interface */
  27 #include "cm_hash.h"       /* common hash list */
  28 #include "cm_mblk.h"       /* common memory link list library */
  29 #include "cm_llist.h"      /* common linked list library */
  30 #include "cm_err.h"        /* common error */
  31 #include "cm_lte.h"        /* common LTE */
  32 #include "lrg.h"           /* Layer manager interface includes*/
  33 #include "crg.h"           /* CRG interface includes*/
  34 #include "rgu.h"           /* RGU interface includes*/
  35 #include "tfu.h"           /* TFU interface includes */
  36 #include "rg_sch_inf.h"    /* SCH interface includes */
  37 #include "rg_prg.h"       /* PRG (MAC-MAC) interface includes*/
  38 #include "rg_env.h"       /* MAC environmental includes*/
  39 #include "rg.h"           /* MAC includes*/
  40 #include "rg_err.h"       /* MAC error includes*/
  41 #include "du_log.h"
  42 #include "lwr_mac_fsm.h"
  43
  44 /* header/extern include files (.x) */
  45 #include "gen.x"           /* general layer typedefs */
  46 #include "ssi.x"           /* system services typedefs */
  47 #include "cm5.x"           /* common timers */
  48 #include "cm_hash.x"       /* common hash list */
  49 #include "cm_lib.x"        /* common library */
  50 #include "cm_llist.x"      /* common linked list */
  51 #include "cm_mblk.x"       /* memory management */
  52 #include "cm_tkns.x"       /* common tokens */
  53 #include "cm_lte.x"       /* common tokens */
  54 #include "rgu.x"           /* RGU types */
  55 #include "tfu.x"           /* RGU types */
  56 #include "lrg.x"           /* layer management typedefs for MAC */
  57 #include "crg.x"           /* CRG interface includes */
  58 #include "rg_sch_inf.x"    /* SCH interface typedefs */
  59 #include "rg_prg.x"        /* PRG (MAC-MAC) Interface typedefs */
  60 #include "du_app_mac_inf.h"
  61 #include "mac.h"
  62 #include "rg.x"            /* typedefs for MAC */
  63
  64 #define MIB_SFN_BITMASK 0xFC
  65 #define SSB_PDU_TYPE 3
  66 #define SETLENGTH(x, size) x += size
  67
  68
  69 EXTERN void sendToPhy ARGS((uint8_t msgType, uint32_t msgLen, void *msg));
  70 SlotIndInfo slotIndInfo;   //global variable
  71
  72  /*******************************************************************
  73   *
  74   * @brief Handles Invalid Request Event
  75   *
  76   * @details
  77   *
  78   *    Function : lwr_mac_handleInvalidEvt
  79   *
  80   *    Functionality:
  81   *         - Displays the PHY state when the invalid event occurs
  82   *
  83   * @params[in]
  84   * @return ROK     - success
  85   *         RFAILED - failure
  86   *
  87   * ****************************************************************/
  88 S16 lwr_mac_handleInvalidEvt(void *msg)
  89 {
  90   printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
  91   RETVALUE(ROK);
  92 }
  93
  94 /*******************************************************************
  95   *
  96   * @brief Fills FAPI message header
  97   *
  98   * @details
  99   *
 100   *    Function : fillMsgHeader
 101   *
 102   *    Functionality:
 103   *         -Fills FAPI message header
 104   *
 105   * @params[in] Pointer to header
 106   *             Number of messages
 107   *             Messae Type
 108   *             Length of message
 109   * @return void
 110   *
 111   * ****************************************************************/
 112 PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
 113 {
 114    hdr->message_type_id = msgType;
 115    hdr->length = msgLen;
 116 }
 117
 118 /*******************************************************************
 119   *
 120   * @brief Fills FAPI Config Request message header
 121   *
 122   * @details
 123   *
 124   *    Function : fillTlvs
 125   *
 126   *    Functionality:
 127   *         -Fills FAPI Config Request message header
 128   *
 129   * @params[in] Pointer to TLV
 130   *             Tag
 131   *             Length
 132   *             Value
 133   *             MsgLen
 134   * @return void
 135   *
 136   * ****************************************************************/
 137 PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length,
 138 uint16_t value, uint32_t *msgLen)
 139 {
 140    tlv->tl.tag    = tag;
 141    tlv->tl.length = length;
 142    tlv->value     = value;
 143    *msgLen        = *msgLen + sizeof(tag) + sizeof(length) + length;
 144 }
 145  /*******************************************************************
 146   *
 147   * @brief fills the cyclic prefix by comparing the bitmask
 148   *
 149   * @details
 150   *
 151   *    Function : fillCyclicPrefix
 152   *
 153   *    Functionality:
 154   *         -checks the value with the bitmask and
 155   *          fills the cellPtr's cyclic prefix.
 156   *
 157   * @params[in] Pointer to ClCellParam
 158   *             Value to be compared
 159   * @return void
 160   *
 161   ********************************************************************/
 162 PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
 163 {
 164    if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
 165    {
 166       (*cellPtr)->cyclicPrefix   = NORMAL_CYCLIC_PREFIX_MASK;
 167    }
 168    else if((value & FAPI_EXTENDED_CYCLIC_PREFIX_MASK) == FAPI_EXTENDED_CYCLIC_PREFIX_MASK)
 169    {
 170       (*cellPtr)->cyclicPrefix   = EXTENDED_CYCLIC_PREFIX_MASK;
 171    }
 172    else
 173    {
 174       (*cellPtr)->cyclicPrefix = INVALID_VALUE;
 175    }
 176 }
 177
 178  /*******************************************************************
 179   *
 180   * @brief fills the subcarrier spacing of Downlink by comparing the bitmask
 181   *
 182   * @details
 183   *
 184   *    Function : fillSubcarrierSpaceDl
 185   *
 186   *    Functionality:
 187   *         -checks the value with the bitmask and
 188   *          fills the cellPtr's subcarrier spacing in DL
 189   *
 190   * @params[in] Pointer to ClCellParam
 191   *             Value to be compared
 192   * @return void
 193   *
 194   * ****************************************************************/
 195
 196 PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
 197 {
 198    if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
 199    {
 200       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_15_KHZ;
 201    }
 202    else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
 203    {
 204       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_30_KHZ;
 205    }
 206    else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
 207    {
 208       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_60_KHZ;
 209    }
 210    else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
 211    {
 212       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_120_KHZ;
 213    }
 214    else
 215    {
 216       (*cellPtr)->supportedSubcarrierSpacingDl = INVALID_VALUE;
 217    }
 218 }
 219
 220  /*******************************************************************
 221   *
 222   * @brief fills the downlink bandwidth by comparing the bitmask
 223   *
 224   * @details
 225   *
 226   *    Function : fillBandwidthDl
 227   *
 228   *    Functionality:
 229   *         -checks the value with the bitmask and
 230   *         -fills the cellPtr's DL Bandwidth
 231   *
 232   * @params[in] Pointer to ClCellParam
 233   *             Value to be compared
 234   * @return void
 235   *
 236   * ****************************************************************/
 237
 238 PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
 239 {
 240    if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
 241    {
 242       (*cellPtr)->supportedBandwidthDl = BW_5MHZ;
 243    }
 244    else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
 245    {
 246       (*cellPtr)->supportedBandwidthDl = BW_10MHZ;
 247    }
 248    else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
 249    {
 250       (*cellPtr)->supportedBandwidthDl = BW_15MHZ;
 251    }
 252    else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
 253    {
 254       (*cellPtr)->supportedBandwidthDl = BW_20MHZ;
 255    }
 256    else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
 257    {
 258       (*cellPtr)->supportedBandwidthDl = BW_40MHZ;
 259    }
 260    else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
 261    {
 262       (*cellPtr)->supportedBandwidthDl = BW_50MHZ;
 263    }
 264    else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
 265    {
 266       (*cellPtr)->supportedBandwidthDl = BW_60MHZ;
 267    }
 268    else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
 269    {
 270       (*cellPtr)->supportedBandwidthDl = BW_70MHZ;
 271    }
 272    else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
 273    {
 274       (*cellPtr)->supportedBandwidthDl = BW_80MHZ;
 275    }
 276    else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
 277    {
 278       (*cellPtr)->supportedBandwidthDl = BW_90MHZ;
 279    }
 280    else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
 281    {
 282       (*cellPtr)->supportedBandwidthDl = BW_100MHZ;
 283    }
 284    else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
 285    {
 286       (*cellPtr)->supportedBandwidthDl = BW_200MHZ;
 287    }
 288    else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
 289    {
 290       (*cellPtr)->supportedBandwidthDl = BW_400MHZ;
 291    }
 292    else
 293    {
 294       (*cellPtr)->supportedBandwidthDl = INVALID_VALUE;
 295    }
 296 }
 297
 298  /*******************************************************************
 299   *
 300   * @brief fills the subcarrier spacing of Uplink by comparing the bitmask
 301   *
 302   * @details
 303   *
 304   *    Function : fillSubcarrierSpaceUl
 305   *
 306   *    Functionality:
 307   *         -checks the value with the bitmask and
 308   *         -fills cellPtr's subcarrier spacing in UL
 309   *
 310   * @params[in] Pointer to ClCellParam
 311   *             Value to be compared
 312   * @return void
 313   *
 314   * ****************************************************************/
 315
 316 PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
 317 {
 318    if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
 319    {
 320       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_15_KHZ;
 321    }
 322    else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
 323    {
 324       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_30_KHZ;
 325    }
 326    else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
 327    {
 328       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_60_KHZ;
 329    }
 330    else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
 331    {
 332       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_120_KHZ;
 333    }
 334    else
 335    {
 336       (*cellPtr)->supportedSubcarrierSpacingsUl = INVALID_VALUE;
 337    }
 338 }
 339
 340  /*******************************************************************
 341   *
 342   * @brief fills the uplink bandwidth by comparing the bitmask
 343   *
 344   * @details
 345   *
 346   *    Function : fillBandwidthUl
 347   *
 348   *    Functionality:
 349   *         -checks the value with the bitmask and
 350   *          fills the cellPtr's UL Bandwidth
 351   *
 352   *
 353   *
 354   * @params[in] Pointer to ClCellParam
 355   *             Value to be compared
 356   * @return void
 357   *
 358   *
 359   * ****************************************************************/
 360
 361 PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
 362 {
 363    if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
 364    {
 365       (*cellPtr)->supportedBandwidthUl = BW_5MHZ;
 366    }
 367    else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
 368    {
 369       (*cellPtr)->supportedBandwidthUl = BW_10MHZ;
 370    }
 371    else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
 372    {
 373       (*cellPtr)->supportedBandwidthUl = BW_15MHZ;
 374    }
 375    else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
 376    {
 377       (*cellPtr)->supportedBandwidthUl = BW_20MHZ;
 378    }
 379    else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
 380    {
 381       (*cellPtr)->supportedBandwidthUl = BW_40MHZ;
 382    }
 383    else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
 384    {
 385       (*cellPtr)->supportedBandwidthUl = BW_50MHZ;
 386    }
 387    else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
 388    {
 389       (*cellPtr)->supportedBandwidthUl = BW_60MHZ;
 390    }
 391    else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
 392    {
 393       (*cellPtr)->supportedBandwidthUl = BW_70MHZ;
 394    }
 395    else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
 396    {
 397       (*cellPtr)->supportedBandwidthUl = BW_80MHZ;
 398    }
 399    else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
 400    {
 401       (*cellPtr)->supportedBandwidthUl = BW_90MHZ;
 402    }
 403    else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
 404    {
 405       (*cellPtr)->supportedBandwidthUl = BW_100MHZ;
 406    }
 407    else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
 408    {
 409       (*cellPtr)->supportedBandwidthUl = BW_200MHZ;
 410    }
 411    else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
 412    {
 413       (*cellPtr)->supportedBandwidthUl = BW_400MHZ;
 414    }
 415    else
 416    {
 417       (*cellPtr)->supportedBandwidthUl = INVALID_VALUE;
 418    }
 419 }
 420  /*******************************************************************
 421   *
 422   * @brief fills the CCE maping by comparing the bitmask
 423   *
 424   * @details
 425   *
 426   *    Function : fillCCEmaping
 427   *
 428   *    Functionality:
 429   *         -checks the value with the bitmask and
 430   *          fills the cellPtr's CCE Mapping Type
 431   *
 432   *
 433   * @params[in] Pointer to ClCellParam
 434   *             Value to be compared
 435   * @return void
 436   *
 437   * ****************************************************************/
 438
 439 PUBLIC void fillCCEmaping(uint8_t value,  ClCellParam **cellPtr)
 440 {
 441    if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
 442    {
 443       (*cellPtr)->cceMappingType = CCE_MAPPING_INTERLEAVED_MASK;
 444    }
 445    else if((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_NONINTERLVD_MASK)
 446    {
 447       (*cellPtr)->cceMappingType = CCE_MAPPING_NONINTERLVD_MASK;
 448    }
 449    else
 450    {
 451       (*cellPtr)->cceMappingType = INVALID_VALUE;
 452    }
 453 }
 454
 455  /*******************************************************************
 456   *
 457   * @brief fills the PUCCH format by comparing the bitmask
 458   *
 459   * @details
 460   *
 461   *    Function : fillPucchFormat
 462   *
 463   *    Functionality:
 464   *         -checks the value with the bitmask and
 465   *          fills the cellPtr's pucch format
 466   *
 467   *
 468   * @params[in] Pointer to ClCellParam
 469   *             Value to be compared
 470   * @return void
 471   *
 472   * ****************************************************************/
 473
 474 PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
 475 {
 476    if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
 477    {
 478       (*cellPtr)->pucchFormats    = FORMAT_0;
 479    }
 480    else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
 481    {
 482       (*cellPtr)->pucchFormats    = FORMAT_1;
 483    }
 484    else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
 485    {
 486       (*cellPtr)->pucchFormats    = FORMAT_2;
 487    }
 488    else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
 489    {
 490       (*cellPtr)->pucchFormats    = FORMAT_3;
 491    }
 492    else if((value & FAPI_FORMAT_4_MASK) == FAPI_FORMAT_4_MASK)
 493    {
 494       (*cellPtr)->pucchFormats    = FORMAT_4;
 495    }
 496    else
 497    {
 498       (*cellPtr)->pucchFormats    = INVALID_VALUE;
 499    }
 500 }
 501
 502  /*******************************************************************
 503   *
 504   * @brief fills the PDSCH Mapping Type by comparing the bitmask
 505   *
 506   * @details
 507   *
 508   *    Function : fillPdschMappingType
 509   *
 510   *    Functionality:
 511   *         -checks the value with the bitmask and
 512   *          fills the cellPtr's PDSCH MappingType
 513   *
 514   * @params[in] Pointer to ClCellParam
 515   *             Value to be compared
 516   * @return void
 517   *
 518   * ****************************************************************/
 519
 520 PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
 521 {
 522    if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
 523    {
 524       (*cellPtr)->pdschMappingType = MAPPING_TYPE_A;
 525    }
 526    else if((value & FAPI_PDSCH_MAPPING_TYPE_B_MASK) == FAPI_PDSCH_MAPPING_TYPE_B_MASK)
 527    {
 528       (*cellPtr)->pdschMappingType = MAPPING_TYPE_B;
 529    }
 530    else
 531    {
 532       (*cellPtr)->pdschMappingType = INVALID_VALUE;
 533    }
 534 }
 535
 536 /*******************************************************************
 537   *
 538   * @brief fills the PDSCH Allocation Type by comparing the bitmask
 539   *
 540   * @details
 541   *
 542   *    Function : fillPdschAllocationType
 543   *
 544   *    Functionality:
 545   *         -checks the value with the bitmask and
 546   *          fills the cellPtr's PDSCH AllocationType
 547   *
 548   * @params[in] Pointer to ClCellParam
 549   *             Value to be compared
 550   * @return void
 551   *
 552   * ****************************************************************/
 553
 554 PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
 555 {
 556    if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
 557    {
 558       (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_0;
 559    }
 560    else if((value & FAPI_PDSCH_ALLOC_TYPE_1_MASK) == FAPI_PDSCH_ALLOC_TYPE_1_MASK)
 561    {
 562       (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_1;
 563    }
 564    else
 565    {
 566       (*cellPtr)->pdschAllocationTypes = INVALID_VALUE;
 567    }
 568 }
 569
 570 /*******************************************************************
 571   *
 572   * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask
 573   *
 574   * @details
 575   *
 576   *    Function : fillPrbMappingType
 577   *
 578   *    Functionality:
 579   *         -checks the value with the bitmask and
 580   *          fills the cellPtr's PRB Mapping Type
 581   *
 582   * @params[in] Pointer to ClCellParam
 583   *             Value to be compared
 584   * @return void
 585   *
 586   ******************************************************************/
 587 PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
 588 {
 589    if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
 590    {
 591       (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
 592    }
 593    else if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
 594    {
 595       (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
 596    }
 597    else
 598    {
 599       (*cellPtr)->pdschVrbToPrbMapping = INVALID_VALUE;
 600    }
 601 }
 602
 603 /*******************************************************************
 604   *
 605   * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask
 606   *
 607   * @details
 608   *
 609   *    Function : fillPdschDmrsConfigType
 610   *
 611   *    Functionality:
 612   *         -checks the value with the bitmask and
 613   *          fills the cellPtr's DmrsConfig Type
 614   *
 615   * @params[in] Pointer to ClCellParam
 616   *             Value to be compared
 617   * @return void
 618   *
 619   ******************************************************************/
 620
 621 PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
 622 {
 623   if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
 624   {
 625      (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
 626   }
 627   else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK)
 628   {
 629      (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
 630   }
 631   else
 632   {
 633      (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE;
 634   }
 635 }
 636
 637 /*******************************************************************
 638   *
 639   * @brief fills the PDSCH DmrsLength by comparing the bitmask
 640   *
 641   * @details
 642   *
 643   *    Function : fillPdschDmrsLength
 644   *
 645   *    Functionality:
 646   *         -checks the value with the bitmask and
 647   *          fills the cellPtr's PdschDmrsLength
 648   *
 649   * @params[in] Pointer to ClCellParam
 650   *             Value to be compared
 651   * @return void
 652   *
 653   ******************************************************************/
 654 PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
 655 {
 656    if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
 657    {
 658       (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_1;
 659    }
 660    else if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_2)
 661    {
 662       (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_2;
 663    }
 664    else
 665    {
 666       (*cellPtr)->pdschDmrsMaxLength = INVALID_VALUE;
 667    }
 668 }
 669
 670 /*******************************************************************
 671   *
 672   * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask
 673   *
 674   * @details
 675   *
 676   *    Function : fillPdschDmrsAddPos
 677   *
 678   *    Functionality:
 679   *         -checks the value with the bitmask and
 680   *          fills the cellPtr's Pdsch DmrsAddPos
 681   *
 682   * @params[in] Pointer to ClCellParam
 683   *             Value to be compared
 684   * @return void
 685   *
 686   ******************************************************************/
 687
 688 PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
 689 {
 690    if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
 691    {
 692       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
 693    }
 694    else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
 695    {
 696       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
 697    }
 698    else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
 699    {
 700       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
 701    }
 702    else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
 703    {
 704       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
 705    }
 706    else
 707    {
 708       (*cellPtr)->pdschDmrsAdditionalPos = INVALID_VALUE;
 709    }
 710 }
 711
 712 /*******************************************************************
 713   *
 714   * @brief fills the Modulation Order in DL by comparing the bitmask
 715   *
 716   * @details
 717   *
 718   *    Function : fillModulationOrderDl
 719   *
 720   *    Functionality:
 721   *         -checks the value with the bitmask and
 722   *          fills the cellPtr's ModulationOrder in DL.
 723   *
 724   * @params[in] Pointer to ClCellParam
 725   *             Value to be compared
 726   * @return void
 727   *
 728   ******************************************************************/
 729 PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
 730 {
 731    if(value == 0 )
 732    {
 733       (*cellPtr)->supportedMaxModulationOrderDl = MOD_QPSK;
 734    }
 735    else if(value == 1)
 736    {
 737       (*cellPtr)->supportedMaxModulationOrderDl = MOD_16QAM;
 738    }
 739    else if(value == 2)
 740    {
 741       (*cellPtr)->supportedMaxModulationOrderDl = MOD_64QAM;
 742    }
 743    else if(value == 3)
 744    {
 745       (*cellPtr)->supportedMaxModulationOrderDl = MOD_256QAM;
 746    }
 747    else
 748    {
 749       (*cellPtr)->supportedMaxModulationOrderDl = INVALID_VALUE;
 750    }
 751 }
 752
 753 /*******************************************************************
 754   *
 755   * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask
 756   *
 757   * @details
 758   *
 759   *    Function : fillPuschDmrsConfigType
 760   *
 761   *    Functionality:
 762   *         -checks the value with the bitmask and
 763   *          fills the cellPtr's PUSCH DmrsConfigType
 764   *
 765   * @params[in] Pointer to ClCellParam
 766   *             Value to be compared
 767   * @return void
 768   *
 769   ******************************************************************/
 770
 771 PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
 772 {
 773    if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
 774    {
 775       (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
 776    }
 777    else if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK)
 778    {
 779       (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
 780    }
 781    else
 782    {
 783       (*cellPtr)->puschDmrsConfigTypes = INVALID_VALUE;
 784    }
 785 }
 786
 787 /*******************************************************************
 788   *
 789   * @brief fills the PUSCH DmrsLength by comparing the bitmask
 790   *
 791   * @details
 792   *
 793   *    Function : fillPuschDmrsLength
 794   *
 795   *    Functionality:
 796   *         -checks the value with the bitmask and
 797   *          fills the cellPtr's PUSCH DmrsLength
 798   *
 799   * @params[in] Pointer to ClCellParam
 800   *             Value to be compared
 801   * @return void
 802   *
 803   ******************************************************************/
 804
 805 PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
 806 {
 807    if(value  == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
 808    {
 809       (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_1;
 810    }
 811    else if(value  == FAPI_PUSCH_DMRS_MAX_LENGTH_2)
 812    {
 813       (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_2;
 814    }
 815    else
 816    {
 817       (*cellPtr)->puschDmrsMaxLength = INVALID_VALUE;
 818    }
 819 }
 820
 821 /*******************************************************************
 822   *
 823   * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask
 824   *
 825   * @details
 826   *
 827   *    Function : fillPuschDmrsAddPos
 828   *
 829   *    Functionality:
 830   *         -checks the value with the bitmask and
 831   *          fills the cellPtr's PUSCH DmrsAddPos
 832   *
 833   * @params[in] Pointer to ClCellParam
 834   *             Value to be compared
 835   * @return void
 836   *
 837   ******************************************************************/
 838
 839 PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
 840 {
 841    if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
 842    {
 843       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
 844    }
 845    else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
 846    {
 847       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
 848    }
 849    else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
 850    {
 851       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
 852    }
 853    else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
 854    {
 855       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
 856    }
 857    else
 858    {
 859       (*cellPtr)->puschDmrsAdditionalPos = INVALID_VALUE;
 860    }
 861 }
 862
 863 /*******************************************************************
 864   *
 865   * @brief fills the PUSCH Mapping Type by comparing the bitmask
 866   *
 867   * @details
 868   *
 869   *    Function : fillPuschMappingType
 870   *
 871   *    Functionality:
 872   *         -checks the value with the bitmask and
 873   *          fills the cellPtr's PUSCH MappingType
 874   *
 875   * @params[in] Pointer to ClCellParam
 876   *             Value to be compared
 877   * @return void
 878   *
 879   ******************************************************************/
 880
 881 PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
 882 {
 883    if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
 884    {
 885       (*cellPtr)->puschMappingType = MAPPING_TYPE_A;
 886    }
 887    else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK)
 888    {
 889       (*cellPtr)->puschMappingType = MAPPING_TYPE_B;
 890    }
 891    else
 892    {
 893       (*cellPtr)->puschMappingType = INVALID_VALUE;
 894    }
 895 }
 896
 897 /*******************************************************************
 898   *
 899   * @brief fills the PUSCH Allocation Type by comparing the bitmask
 900   *
 901   * @details
 902   *
 903   *    Function : fillPuschAllocationType
 904   *
 905   *    Functionality:
 906   *         -checks the value with the bitmask and
 907   *          fills the cellPtr's PUSCH AllocationType
 908   *
 909   * @params[in] Pointer to ClCellParam
 910   *             Value to be compared
 911   * @return void
 912   *
 913   ******************************************************************/
 914
 915 PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
 916 {
 917    if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
 918    {
 919       (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_0;
 920    }
 921    else if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
 922    {
 923       (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_1;
 924    }
 925    else
 926    {
 927       (*cellPtr)->puschAllocationTypes = INVALID_VALUE;
 928    }
 929 }
 930
 931 /*******************************************************************
 932   *
 933   * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask
 934   *
 935   * @details
 936   *
 937   *    Function : fillPuschPrbMappingType
 938   *
 939   *    Functionality:
 940   *         -checks the value with the bitmask and
 941   *          fills the cellPtr's PUSCH PRB MApping Type
 942   *
 943   * @params[in] Pointer to ClCellParam
 944   *             Value to be compared
 945   * @return void
 946   *
 947   ******************************************************************/
 948
 949 PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
 950 {
 951    if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
 952    {
 953       (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
 954    }
 955    else if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
 956    {
 957       (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
 958    }
 959    else
 960    {
 961       (*cellPtr)->puschVrbToPrbMapping = INVALID_VALUE;
 962    }
 963 }
 964
 965 /*******************************************************************
 966   *
 967   * @brief fills the Modulation Order in Ul by comparing the bitmask
 968   *
 969   * @details
 970   *
 971   *    Function : fillModulationOrderUl
 972   *
 973   *    Functionality:
 974   *         -checks the value with the bitmask and
 975   *          fills the cellPtr's Modualtsion Order in UL.
 976   *
 977   * @params[in] Pointer to ClCellParam
 978   *             Value to be compared
 979   * @return void
 980   *
 981   ******************************************************************/
 982
 983 PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
 984 {
 985    if(value == 0)
 986    {
 987       (*cellPtr)->supportedModulationOrderUl = MOD_QPSK;
 988    }
 989    else if(value == 1)
 990    {
 991       (*cellPtr)->supportedModulationOrderUl = MOD_16QAM;
 992    }
 993    else if(value == 2)
 994    {
 995       (*cellPtr)->supportedModulationOrderUl = MOD_64QAM;
 996    }
 997    else if(value == 3)
 998    {
 999       (*cellPtr)->supportedModulationOrderUl = MOD_256QAM;
1000    }
1001    else
1002    {
1003       (*cellPtr)->supportedModulationOrderUl = INVALID_VALUE;
1004    }
1005 }
1006
1007 /*******************************************************************
1008   *
1009   * @brief fills the PUSCH Aggregation Factor by comparing the bitmask
1010   *
1011   * @details
1012   *
1013   *    Function : fillPuschAggregationFactor
1014   *
1015   *    Functionality:
1016   *         -checks the value with the bitmask and
1017   *          fills the cellPtr's PUSCH Aggregation Factor
1018   *
1019   * @params[in] Pointer to ClCellParam
1020   *             Value to be compared
1021   * @return void
1022   *
1023   ******************************************************************/
1024
1025 PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
1026 {
1027    if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
1028    {
1029       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_1;
1030    }
1031    else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
1032    {
1033       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_2;
1034    }
1035    else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
1036    {
1037       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_4;
1038    }
1039    else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
1040    {
1041       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_8;
1042    }
1043    else
1044    {
1045       (*cellPtr)->puschAggregationFactor    = INVALID_VALUE;
1046    }
1047 }
1048
1049 /*******************************************************************
1050   *
1051   * @brief fills the PRACH Long Format by comparing the bitmask
1052   *
1053   * @details
1054   *
1055   *    Function : fillPrachLongFormat
1056   *
1057   *    Functionality:
1058   *         -checks the value with the bitmask and
1059   *          fills the cellPtr's PRACH Long Format
1060   *
1061   * @params[in] Pointer to ClCellParam
1062   *             Value to be compared
1063   * @return void
1064   *
1065   ******************************************************************/
1066
1067 PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
1068 {
1069    if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
1070    {
1071       (*cellPtr)->prachLongFormats    = FORMAT_0;
1072    }
1073    else if((value & FAPI_PRACH_LF_FORMAT_1_MASK) == FAPI_PRACH_LF_FORMAT_1_MASK)
1074    {
1075       (*cellPtr)->prachLongFormats    = FORMAT_1;
1076    }
1077    else if((value & FAPI_PRACH_LF_FORMAT_2_MASK) == FAPI_PRACH_LF_FORMAT_2_MASK)
1078    {
1079       (*cellPtr)->prachLongFormats    = FORMAT_2;
1080    }
1081    else if((value & FAPI_PRACH_LF_FORMAT_3_MASK) == FAPI_PRACH_LF_FORMAT_3_MASK)
1082    {
1083       (*cellPtr)->prachLongFormats    = FORMAT_3;
1084    }
1085    else
1086    {
1087       (*cellPtr)->prachLongFormats    = INVALID_VALUE;
1088    }
1089 }
1090
1091 /*******************************************************************
1092   *
1093   * @brief fills the PRACH Short Format by comparing the bitmask
1094   *
1095   * @details
1096   *
1097   *    Function : fillPrachShortFormat
1098   *
1099   *    Functionality:
1100   *         -checks the value with the bitmask and
1101   *          fills the cellPtr's PRACH ShortFormat
1102   *
1103   * @params[in] Pointer to ClCellParam
1104   *             Value to be compared
1105   * @return void
1106   *
1107   ******************************************************************/
1108
1109 PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
1110 {
1111    if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
1112    {
1113       (*cellPtr)->prachShortFormats    = SF_FORMAT_A1;
1114    }
1115    else if((value & FAPI_PRACH_SF_FORMAT_A2_MASK) == FAPI_PRACH_SF_FORMAT_A2_MASK)
1116    {
1117       (*cellPtr)->prachShortFormats    = SF_FORMAT_A2;
1118    }
1119    else if((value & FAPI_PRACH_SF_FORMAT_A3_MASK) == FAPI_PRACH_SF_FORMAT_A3_MASK)
1120    {
1121       (*cellPtr)->prachShortFormats    = SF_FORMAT_A3;
1122    }
1123    else if((value & FAPI_PRACH_SF_FORMAT_B1_MASK) == FAPI_PRACH_SF_FORMAT_B1_MASK)
1124    {
1125       (*cellPtr)->prachShortFormats    = SF_FORMAT_B1;
1126    }
1127    else if((value & FAPI_PRACH_SF_FORMAT_B2_MASK) == FAPI_PRACH_SF_FORMAT_B2_MASK)
1128    {
1129       (*cellPtr)->prachShortFormats    = SF_FORMAT_B2;
1130    }
1131    else if((value & FAPI_PRACH_SF_FORMAT_B3_MASK) == FAPI_PRACH_SF_FORMAT_B3_MASK)
1132    {
1133       (*cellPtr)->prachShortFormats    = SF_FORMAT_B3;
1134    }
1135    else if((value & FAPI_PRACH_SF_FORMAT_B4_MASK) == FAPI_PRACH_SF_FORMAT_B4_MASK)
1136    {
1137       (*cellPtr)->prachShortFormats    = SF_FORMAT_B4;
1138    }
1139    else if((value & FAPI_PRACH_SF_FORMAT_C0_MASK) == FAPI_PRACH_SF_FORMAT_C0_MASK)
1140    {
1141       (*cellPtr)->prachShortFormats    = SF_FORMAT_C0;
1142    }
1143    else if((value & FAPI_PRACH_SF_FORMAT_C2_MASK) == FAPI_PRACH_SF_FORMAT_C2_MASK)
1144    {
1145       (*cellPtr)->prachShortFormats    = SF_FORMAT_C2;
1146    }
1147    else
1148    {
1149       (*cellPtr)->prachShortFormats    = INVALID_VALUE;
1150    }
1151 }
1152
1153 /*******************************************************************
1154   *
1155   * @brief fills the Fd Occasions Type by comparing the bitmask
1156   *
1157   * @details
1158   *
1159   *    Function : fillFdOccasions
1160   *
1161   *    Functionality:
1162   *         -checks the value with the bitmask and
1163   *          fills the cellPtr's Fd Occasions
1164   *
1165   * @params[in] Pointer to ClCellParam
1166   *             Value to be compared
1167   * @return void
1168   *
1169   ******************************************************************/
1170
1171 PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
1172 {
1173    if(value == 0)
1174    {
1175       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_1;
1176    }
1177    else if(value == 1)
1178    {
1179       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_2;
1180    }
1181    else if(value == 3)
1182    {
1183       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_4;
1184    }
1185    else if(value == 4)
1186    {
1187       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_8;
1188    }
1189    else
1190    {
1191       (*cellPtr)->maxPrachFdOccasionsInASlot = INVALID_VALUE;
1192    }
1193 }
1194
1195 /*******************************************************************
1196   *
1197   * @brief fills the RSSI Measurement by comparing the bitmask
1198   *
1199   * @details
1200   *
1201   *    Function : fillRssiMeas
1202   *
1203   *    Functionality:
1204   *         -checks the value with the bitmask and
1205   *          fills the cellPtr's RSSI Measurement report
1206   *
1207   * @params[in] Pointer to ClCellParam
1208   *             Value to be compared
1209   * @return void
1210   *
1211   ******************************************************************/
1212
1213 PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
1214 {
1215    if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
1216    {
1217       (*cellPtr)->rssiMeasurementSupport    = RSSI_REPORT_DBM;
1218    }
1219    else if((value & FAPI_RSSI_REPORT_IN_DBFS_MASK) == FAPI_RSSI_REPORT_IN_DBFS_MASK)
1220    {
1221       (*cellPtr)->rssiMeasurementSupport    = RSSI_REPORT_DBFS;
1222    }
1223    else
1224    {
1225       (*cellPtr)->rssiMeasurementSupport    = INVALID_VALUE;
1226    }
1227 }
1228
1229  /*******************************************************************
1230   *
1231   * @brief Returns the TLVs value
1232   *
1233   * @details
1234   *
1235   *    Function : getParamValue
1236   *
1237   *    Functionality:
1238   *         -return TLVs value
1239   *
1240   * @params[in]
1241   * @return ROK     - temp
1242   *         RFAILED - failure
1243   *
1244   * ****************************************************************/
1245
1246 uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
1247 {
1248     uint16_t valueLen;
1249     void *posPtr;
1250     valueLen = tlv->tl.length;
1251     posPtr   = &tlv->tl.tag;
1252     posPtr   += sizeof(tlv->tl.tag);
1253     posPtr   += sizeof(tlv->tl.length);
1254     /*TO DO: malloc to SSI memory */
1255     if(type == FAPI_UINT_8)
1256     {
1257        //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
1258        //memcpy(temp, posPtr, valueLen);
1259        return(*(uint8_t *)posPtr);
1260     }
1261     else if(type == FAPI_UINT_16)
1262     {
1263        return(*(uint16_t *)posPtr);
1264     }
1265     else if(type == FAPI_UINT_32)
1266     {
1267        return(*(uint32_t *)posPtr);
1268     }
1269     else
1270     {
1271       DU_LOG("\nLOWER MAC: Value Extraction failed" );
1272       return RFAILED;
1273     }
1274 }
1275  /*******************************************************************
1276   *
1277   * @brief Sends FAPI Param req to PHY
1278   *
1279   * @details
1280   *
1281   *    Function : lwr_mac_handleParamReqEvt
1282   *
1283   *    Functionality:
1284   *         -Sends FAPI Param req to PHY
1285   *
1286   * @params[in]
1287   * @return ROK     - success
1288   *         RFAILED - failure
1289   *
1290   * ****************************************************************/
1291
1292 S16 lwr_mac_handleParamReqEvt(void *msg)
1293 {
1294    /* startGuardTimer(); */
1295    uint32_t msgLen;      //Length of message Body
1296    msgLen = 0;
1297    fapi_param_req_t *paramReq;
1298    MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
1299    if(paramReq != NULLP)
1300    {
1301       fillMsgHeader(&paramReq->header, FAPI_PARAM_REQUEST, msgLen);
1302       DU_LOG("\nLOWER MAC: sending param Req to Phy");
1303       sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
1304       MAC_FREE(paramReq, sizeof(fapi_param_req_t));
1305       return ROK;
1306    }
1307    else
1308    {
1309       DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request");
1310       return RFAILED;
1311    }
1312 }
1313
1314  /*******************************************************************
1315   *
1316   * @brief Sends FAPI Param Response to MAC via PHY
1317   *
1318   * @details
1319   *
1320   *    Function : lwr_mac_handleParamRspEvt
1321   *
1322   *    Functionality:
1323   *         -Sends FAPI Param rsp to MAC via PHY
1324   *
1325   * @params[in]
1326   * @return ROK     - success
1327   *         RFAILED - failure
1328   *
1329   * ****************************************************************/
1330
1331 S16 lwr_mac_handleParamRspEvt(void *msg)
1332 {
1333   /* stopGuardTimer(); */
1334    uint8_t index;
1335    uint32_t encodedVal;
1336         fapi_param_resp_t *paramRsp;
1337    ClCellParam *cellParam = NULLP;
1338
1339    paramRsp = (fapi_param_resp_t *)msg;
1340    DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1341
1342    if(paramRsp != NULLP)
1343    {
1344       MAC_ALLOC(cellParam, sizeof(ClCellParam));
1345       if(cellParam != NULLP)
1346       {
1347          DU_LOG("\n LOWER MAC: Filling TLVS into MAC API");
1348          if(paramRsp->error_code == MSG_OK)
1349          {
1350             for(index = 0; index < paramRsp->number_of_tlvs; index++)
1351             {
1352                switch(paramRsp->tlvs[index].tl.tag)
1353                {
1354                   case FAPI_RELEASE_CAPABILITY_TAG:
1355                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1356                      if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
1357                      {
1358                         cellParam->releaseCapability = RELEASE_15;
1359                      }
1360                      break;
1361
1362                   case FAPI_PHY_STATE_TAG:
1363                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1364                      if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
1365                      {
1366                         printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
1367                         RETVALUE(RFAILED);
1368                      }
1369                      break;
1370
1371                   case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
1372                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1373                      if(encodedVal != RFAILED && encodedVal != 0)
1374                      {
1375                        cellParam->skipBlankDlConfig = SUPPORTED;
1376                      }
1377                      else
1378                      {
1379                        cellParam->skipBlankDlConfig = NOT_SUPPORTED;
1380                      }
1381                      break;
1382
1383                   case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
1384                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1385                      if(encodedVal != RFAILED && encodedVal != 0)
1386                      {
1387                        cellParam->skipBlankUlConfig = SUPPORTED;
1388                      }
1389                      else
1390                      {
1391                        cellParam->skipBlankUlConfig = NOT_SUPPORTED;
1392                      }
1393                      break;
1394
1395                   case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
1396                      cellParam->numTlvsToReport = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1397                      break;
1398
1399                   case FAPI_CYCLIC_PREFIX_TAG:
1400                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1401                      if(encodedVal != RFAILED)
1402                      {
1403                         fillCyclicPrefix(encodedVal, &cellParam);
1404                      }
1405                      break;
1406
1407                   case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
1408                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1409                      if(encodedVal != RFAILED)
1410                      {
1411                         fillSubcarrierSpaceDl(encodedVal, &cellParam);
1412                      }
1413                      break;
1414
1415                   case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
1416                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1417                      if(encodedVal != RFAILED)
1418                      {
1419                         fillBandwidthDl(encodedVal, &cellParam);
1420                      }
1421                      break;
1422
1423                   case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
1424                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1425                      if(encodedVal != RFAILED)
1426                      {
1427                         fillSubcarrierSpaceUl(encodedVal, &cellParam);
1428                      }
1429                      break;
1430
1431                   case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
1432                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1433                      if(encodedVal != RFAILED)
1434                      {
1435                         fillBandwidthUl(encodedVal, &cellParam);
1436                      }
1437                      break;
1438
1439                   case FAPI_CCE_MAPPING_TYPE_TAG:
1440                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1441                      if(encodedVal != RFAILED)
1442                      {
1443                         fillCCEmaping(encodedVal, &cellParam);
1444                      }
1445                      break;
1446
1447                   case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
1448                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1449                      if(encodedVal != RFAILED && encodedVal != 0)
1450                      {
1451                         cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
1452                      }
1453                      else
1454                      {
1455                         cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
1456                      }
1457                      break;
1458
1459                   case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
1460                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1461                      if(encodedVal != RFAILED && encodedVal != 0)
1462                      {
1463                         cellParam->precoderGranularityCoreset = SUPPORTED;
1464                      }
1465                      else
1466                      {
1467                         cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
1468                      }
1469                      break;
1470
1471                   case FAPI_PDCCH_MU_MIMO_TAG:
1472                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1473                      if(encodedVal != RFAILED && encodedVal != 0)
1474                      {
1475                         cellParam->pdcchMuMimo = SUPPORTED;
1476                      }
1477                      else
1478                      {
1479                         cellParam->pdcchMuMimo = NOT_SUPPORTED;
1480                      }
1481                      break;
1482
1483                   case FAPI_PDCCH_PRECODER_CYCLING_TAG:
1484                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1485                      if(encodedVal != RFAILED && encodedVal != 0)
1486                      {
1487                         cellParam->pdcchPrecoderCycling = SUPPORTED;
1488                      }
1489                      else
1490                      {
1491                         cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
1492                      }
1493                      break;
1494
1495                   case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
1496                      cellParam->maxPdcchsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1497                      break;
1498
1499                   case FAPI_PUCCH_FORMATS_TAG:
1500                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1501                      if(encodedVal != RFAILED)
1502                      {
1503                         fillPucchFormat(encodedVal, &cellParam);
1504                      }
1505                      break;
1506
1507                   case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
1508                        cellParam->maxPucchsPerSlot   = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1509                      break;
1510
1511                   case FAPI_PDSCH_MAPPING_TYPE_TAG:
1512                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1513                      if(encodedVal != RFAILED)
1514                      {
1515                         fillPdschMappingType(encodedVal, &cellParam);
1516                      }
1517                      break;
1518
1519                   case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
1520                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1521                      if(encodedVal != RFAILED)
1522                      {
1523                         fillPdschAllocationType(encodedVal, &cellParam);
1524                      }
1525                      break;
1526
1527                   case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
1528                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1529                      if(encodedVal != RFAILED)
1530                      {
1531                         fillPrbMappingType(encodedVal, &cellParam);
1532                      }
1533                      break;
1534
1535                   case FAPI_PDSCH_CBG_TAG:
1536                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1537                      if(encodedVal != RFAILED && encodedVal != 0)
1538                      {
1539                         cellParam->pdschCbg = SUPPORTED;
1540                      }
1541                      else
1542                      {
1543                         cellParam->pdschCbg = NOT_SUPPORTED;
1544                      }
1545                      break;
1546
1547                   case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
1548                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1549                      if(encodedVal != RFAILED)
1550                      {
1551                         fillPdschDmrsConfigType(encodedVal, &cellParam);
1552                      }
1553                      break;
1554
1555                   case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
1556                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1557                      if(encodedVal != RFAILED)
1558                      {
1559                         fillPdschDmrsLength(encodedVal, &cellParam);
1560                      }
1561                      break;
1562
1563                   case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
1564                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1565                      if(encodedVal != RFAILED)
1566                      {
1567                         fillPdschDmrsAddPos(encodedVal, &cellParam);
1568                      }
1569                      break;
1570
1571                   case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
1572                      cellParam->maxPdschsTBsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1573                      break;
1574
1575                   case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
1576                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1577                      if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
1578                      {
1579                         cellParam->maxNumberMimoLayersPdsch   = encodedVal;
1580                      }
1581                      break;
1582
1583                   case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
1584                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1585                      if(encodedVal != RFAILED)
1586                      {
1587                         fillModulationOrderDl(encodedVal, &cellParam);
1588                      }
1589                      break;
1590
1591                   case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
1592                      cellParam->maxMuMimoUsersDl         = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1593                      break;
1594
1595                   case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
1596                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1597                      if(encodedVal != RFAILED && encodedVal != 0)
1598                      {
1599                         cellParam->pdschDataInDmrsSymbols = SUPPORTED;
1600                      }
1601                      else
1602                      {
1603                         cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
1604                      }
1605                      break;
1606
1607                   case FAPI_PREMPTIONSUPPORT_TAG:
1608                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1609                      if(encodedVal != RFAILED && encodedVal != 0)
1610                      {
1611                         cellParam->premptionSupport = SUPPORTED;
1612                      }
1613                      else
1614                      {
1615                         cellParam->premptionSupport = NOT_SUPPORTED;
1616                      }
1617                      break;
1618
1619                   case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
1620                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1621                      if(encodedVal != RFAILED && encodedVal != 0)
1622                      {
1623                         cellParam->pdschNonSlotSupport = SUPPORTED;
1624                      }
1625                      else
1626                      {
1627                         cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
1628                      }
1629                      break;
1630
1631                   case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
1632                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1633                      if(encodedVal != RFAILED && encodedVal != 0)
1634                      {
1635                         cellParam->uciMuxUlschInPusch = SUPPORTED;
1636                      }
1637                      else
1638                      {
1639                         cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
1640                      }
1641                      break;
1642
1643                   case FAPI_UCI_ONLY_PUSCH_TAG:
1644                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1645                      if(encodedVal != RFAILED && encodedVal != 0)
1646                      {
1647                         cellParam->uciOnlyPusch = SUPPORTED;
1648                      }
1649                      else
1650                      {
1651                         cellParam->uciOnlyPusch = NOT_SUPPORTED;
1652                      }
1653                      break;
1654
1655                   case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
1656                      encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1657                      if(encodedVal != RFAILED && encodedVal != 0)
1658                      {
1659                         cellParam->puschFrequencyHopping = SUPPORTED;
1660                      }
1661                      else
1662                      {
1663                         cellParam->puschFrequencyHopping = NOT_SUPPORTED;
1664                      }
1665                      break;
1666
1667                  case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
1668                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1669                     if(encodedVal != RFAILED)
1670                     {
1671                        fillPuschDmrsConfig(encodedVal, &cellParam);
1672                     }
1673                     break;
1674
1675                  case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
1676                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1677                     if(encodedVal != RFAILED)
1678                     {
1679                        fillPuschDmrsLength(encodedVal, &cellParam);
1680                     }
1681                     break;
1682
1683                  case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
1684                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1685                     if(encodedVal != RFAILED)
1686                     {
1687                        fillPuschDmrsAddPos(encodedVal, &cellParam);
1688                     }
1689                     break;
1690
1691                  case FAPI_PUSCH_CBG_TAG:
1692                     encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1693                     if(encodedVal != RFAILED && encodedVal != 0)
1694                     {
1695                        cellParam->puschCbg = SUPPORTED;
1696                     }
1697                     else
1698                     {
1699                        cellParam->puschCbg = NOT_SUPPORTED;
1700                     }
1701                     break;
1702
1703                 case FAPI_PUSCH_MAPPING_TYPE_TAG:
1704                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1705                    if(encodedVal != RFAILED)
1706                    {
1707                       fillPuschMappingType(encodedVal, &cellParam);
1708                    }
1709                    break;
1710
1711                 case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
1712                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1713                    if(encodedVal != RFAILED)
1714                    {
1715                       fillPuschAllocationType(encodedVal, &cellParam);
1716                    }
1717                    break;
1718
1719                 case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
1720                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1721                    if(encodedVal != RFAILED)
1722                    {
1723                       fillPuschPrbMappingType(encodedVal, &cellParam);
1724                    }
1725                    break;
1726
1727                 case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
1728                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1729                    if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
1730                    {
1731                 cellParam->puschMaxPtrsPorts = encodedVal;
1732                    }
1733                    break;
1734
1735                 case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
1736                    cellParam->maxPduschsTBsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1737                    break;
1738
1739                 case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
1740                    cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1741                    break;
1742
1743                 case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
1744                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1745                    if(encodedVal != RFAILED)
1746                    {
1747                       fillModulationOrderUl(encodedVal, &cellParam);
1748                    }
1749                    break;
1750
1751                 case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
1752                    cellParam->maxMuMimoUsersUl = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1753                    break;
1754
1755                 case FAPI_DFTS_OFDM_SUPPORT_TAG:
1756                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1757                    if(encodedVal != RFAILED && encodedVal != 0)
1758                    {
1759                       cellParam->dftsOfdmSupport = SUPPORTED;
1760                    }
1761                    else
1762                    {
1763                       cellParam->dftsOfdmSupport = NOT_SUPPORTED;
1764                    }
1765                    break;
1766
1767                 case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
1768                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1769                    if(encodedVal != RFAILED)
1770                    {
1771                       fillPuschAggregationFactor(encodedVal, &cellParam);
1772                    }
1773                    break;
1774
1775                 case FAPI_PRACH_LONG_FORMATS_TAG:
1776                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1777                    if(encodedVal != RFAILED)
1778                    {
1779                       fillPrachLongFormat(encodedVal, &cellParam);
1780                    }
1781                    break;
1782
1783                 case FAPI_PRACH_SHORT_FORMATS_TAG:
1784                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1785                    if(encodedVal != RFAILED)
1786                    {
1787                       fillPrachShortFormat(encodedVal, &cellParam);
1788                    }
1789                    break;
1790
1791                 case FAPI_PRACH_RESTRICTED_SETS_TAG:
1792                    encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1793                    if(encodedVal != RFAILED && encodedVal != 0)
1794                    {
1795                       cellParam->prachRestrictedSets = SUPPORTED;
1796                    }
1797                    else
1798                    {
1799                       cellParam->prachRestrictedSets = NOT_SUPPORTED;
1800                    }
1801                    break;
1802
1803                case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
1804                   encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1805                   if(encodedVal != RFAILED)
1806                   {
1807                      fillFdOccasions(encodedVal, &cellParam);
1808                   }
1809                   break;
1810
1811                case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
1812                   encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1813                   if(encodedVal != RFAILED)
1814                   {
1815                      fillRssiMeas(encodedVal, &cellParam);
1816                   }
1817                   break;
1818                default:
1819                //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
1820                                         break;
1821               }
1822            }
1823            MAC_FREE(cellParam, sizeof(ClCellParam));
1824            MAC_FREE(paramRsp, sizeof(fapi_param_resp_t));
1825            return ROK;
1826          }
1827          else
1828          {
1829             DU_LOG("\n LOWER MAC: Invalid error code %d", paramRsp->error_code);
1830             return RFAILED;
1831          }
1832      }
1833      else
1834      {
1835         DU_LOG("\nLOWER MAC: Failed to allocate memory for cell param");
1836         return RFAILED;
1837      }
1838    }
1839    else
1840    {
1841        DU_LOG("\nLOWER MAC:  Param Response received from PHY is NULL");
1842        return RFAILED;
1843    }
1844 }
1845
1846  /*******************************************************************
1847   *
1848   * @brief Sends FAPI Config req to PHY
1849   *
1850   * @details
1851   *
1852   *    Function : lwr_mac_handleConfigReqEvt
1853   *
1854   *    Functionality:
1855   *         -Sends FAPI Config Req to PHY
1856   *
1857   * @params[in]
1858   * @return ROK     - success
1859   *         RFAILED - failure
1860   *
1861   * ****************************************************************/
1862
1863 S16 lwr_mac_handleConfigReqEvt(void *msg)
1864 {
1865    uint8_t index = 0;
1866    uint32_t msgLen = 0;
1867    uint32_t configReqSize;
1868    RgCellCb  *cellParams;
1869    MacCellCfg macCfgParams;
1870    Inst inst = 0;
1871
1872    DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1873
1874    fapi_config_req_t *configReq;
1875    cellParams = rgCb[inst].cell;
1876    macCfgParams = cellParams->macCellCfg;
1877    configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t));
1878    MAC_ALLOC(configReq, configReqSize);
1879
1880    if(configReq != NULL)
1881    {
1882       configReq->number_of_tlvs = macCfgParams.numTlv;
1883
1884       if(macCfgParams.dlCarrCfg.pres)
1885       {
1886          fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG,            sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen);
1887          fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG,            sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
1888          fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG,                   sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
1889          fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG,             sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
1890          fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG,              sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
1891       }
1892       if(macCfgParams.ulCarrCfg.pres)
1893       {
1894          fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG,        sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen);
1895          fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG,        sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen);
1896          fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG,                   sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen);
1897          fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG,            sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen);
1898          fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG,              sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen);
1899       }
1900       fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG,    sizeof(uint8_t), macCfgParams.freqShft, &msgLen);
1901
1902       /* fill cell config */
1903       fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG,                sizeof(uint8_t), macCfgParams.phyCellId, &msgLen);
1904       fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG,          sizeof(uint8_t), macCfgParams.dupType, &msgLen);
1905
1906       /* fill SSB configuration */
1907       fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG,              sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
1908       fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG,                sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
1909       fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG,                 sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
1910
1911       /* fill PRACH configuration */
1912       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG,      sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
1913       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG,         sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
1914       fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG,      sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
1915       fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,     sizeof(uint8_t), macCfgParams.prachCfg.prachFdm, &msgLen);
1916       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG,  sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
1917       fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG,         sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
1918       fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG,                         sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
1919       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG ,      sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
1920       fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG,  sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
1921       fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,
1922                 sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
1923       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG,               sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
1924       fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG,  sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
1925
1926       /* fill SSB table */
1927       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG,         sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
1928       fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG,                   sizeof(uint8_t),  macCfgParams.ssbCfg.betaPss, &msgLen);
1929       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG,                 sizeof(uint8_t),  macCfgParams.ssbCfg.ssbPeriod, &msgLen);
1930       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG,      sizeof(uint8_t),  macCfgParams.ssbCfg.ssbScOffset, &msgLen);
1931       fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG ,                       sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen);
1932       fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG,                   sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
1933       fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG,                    sizeof(uint8_t),  macCfgParams.ssbCfg.beamId[0], &msgLen);
1934       fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
1935       fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
1936
1937       /* fill TDD table */
1938       fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG,                 sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen);
1939       fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG,                sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen);
1940
1941       /* fill measurement config */
1942       fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG,            sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
1943
1944       fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
1945       DU_LOG("\nLOWER_MAC: Sending Config Request to Phy");
1946       sendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq);
1947       MAC_FREE(configReq, configReqSize);
1948       return ROK;
1949    }
1950    else
1951    {
1952       DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request");
1953       return RFAILED;
1954    }
1955 }
1956
1957 S16 lwr_mac_handleConfigRspEvt(void *msg)
1958 {
1959    fapi_config_resp_t *configRsp;
1960         configRsp = (fapi_config_resp_t *)msg;
1961    DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1962
1963    if(configRsp != NULL)
1964    {
1965       if(configRsp->error_code == MSG_OK)
1966       {
1967          DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n");
1968          clGlobalCp.phyState = PHY_STATE_CONFIGURED;
1969          MAC_FREE(configRsp, sizeof(fapi_config_resp_t));
1970          return ROK;
1971       }
1972       else
1973       {
1974
1975          DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code);
1976          return RFAILED;
1977       }
1978    }
1979    else
1980    {
1981       DU_LOG("\nLOWER_MAC: Config Response received from PHY is NULL");
1982       return RFAILED;
1983    }
1984 }
1985
1986 S16 lwr_mac_handleStartReqEvt(void *msg)
1987 {
1988    uint32_t msgLen = 0;
1989    fapi_start_req_t *startReq;
1990    MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
1991
1992    if(startReq != NULL)
1993    {
1994       fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
1995       DU_LOG("\nLOWER MAC: Sending Start Request to PHY");
1996       sendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq);
1997       MAC_FREE(startReq, sizeof(fapi_start_req_t));
1998       return ROK;
1999    }
2000    else
2001    {
2002       DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request");
2003       return RFAILED;
2004    }
2005 }
2006
2007 S16 lwr_mac_handleStopReqEvt(void *msg)
2008 {
2009    /* stop TX and RX operation return PHy to configured State
2010       send stop.indication to l2/l3 */
2011    RETVALUE(ROK);
2012 }
2013
2014 /*******************************************************************
2015  *
2016  * @brief Modifes the received mibPdu to uint32 bit
2017  *        and stores it in MacCellCfg
2018  *
2019  * @details
2020  *
2021  *    Function : setMibPdu
2022  *
2023  *    Functionality:
2024  *         -Sets the MibPdu
2025  *
2026  * @params[in] Pointer to mibPdu
2027  *             pointer to modified value
2028  ******************************************************************/
2029
2030 PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val)
2031 {
2032    *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK);
2033    *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
2034     DU_LOG("\nLOWER MAC: value filled %x", *val);
2035 }
2036
2037 /*******************************************************************
2038  *
2039  * @brief fills SSB PDU required for DL TTI info in MAC
2040  *
2041  * @details
2042  *
2043  *    Function : fillSsbPdu
2044  *
2045  *    Functionality:
2046  *         -Fills the SSB PDU info
2047  *          stored in MAC
2048  *
2049  * @params[in] Pointer to FAPI DL TTI Req
2050  *             Pointer to RgCellCb
2051  *             Pointer to msgLen of DL TTI Info
2052  * @return ROK
2053  *
2054  ******************************************************************/
2055
2056 S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
2057 uint32_t *msgLen)
2058 {
2059    uint32_t mibPayload = 0;
2060    if(dlTtiReqPdu != NULL)
2061    {
2062       dlTtiReqPdu->pduType = SSB_PDU_TYPE;     /* SSB PDU */
2063       dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
2064       dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
2065       dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = macCb.macCell->dlSlot[0].cellBroadcastInfo.ssbIdxSupported;
2066       dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
2067       /* ssbOfPdufstA to be filled in ssbCfg */
2068       dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
2069       dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
2070       /* Bit manipulation for SFN */
2071       setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload);
2072       dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
2073       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
2074       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
2075       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
2076       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
2077       dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
2078          pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
2079       dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t);  /* Size of SSB PDU */
2080       SETLENGTH(*msgLen, sizeof(fapi_dl_ssb_pdu_t));
2081       return ROK;
2082     }
2083     else
2084     {
2085        return RFAILED;
2086     }
2087 }
2088
2089 /*******************************************************************
2090  *
2091  * @brief Sends DL TTI Request to PHY
2092  *
2093  * @details
2094  *
2095  *    Function : handleDlTtiReq
2096  *
2097  *    Functionality:
2098  *         -Sends FAPI Param req to PHY
2099  *
2100  * @params[in]    RgDlSf *dlTtiReqSlot
2101  * @return ROK     - success
2102  *         RFAILED - failure
2103  *
2104  * ****************************************************************/
2105 S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo)
2106 {
2107    uint32_t msgLen;
2108    fapi_dl_tti_req_t *dlTtiReq;
2109    fapi_dl_tti_req_pdu_t *dlTtiReqPdu;
2110    RgCellCb  *cellCbParams;
2111    MacCellCfg macCellCfg;
2112    Inst inst = 0;
2113
2114    cellCbParams = rgCb[inst].cell;
2115    if(dlTtiReqtimingInfo != NULLP)
2116    {
2117       MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2118       if(dlTtiReq != NULLP)
2119       {
2120          /* fill the SFN and slot value from crntTime */
2121          dlTtiReq->sfn = dlTtiReqtimingInfo->sfn;
2122          dlTtiReq->slot = dlTtiReqtimingInfo->slot;
2123          dlTtiReq->nPdus = 0;
2124          dlTtiReq->nGroup = 0;
2125          if(macCb.macCell->dlSlot[0].cellBroadcastInfo.ssbTrans)
2126          {
2127             macCellCfg = cellCbParams->macCellCfg;
2128
2129             MAC_ALLOC(dlTtiReqPdu, sizeof(fapi_dl_tti_req_pdu_t));
2130             if(dlTtiReqPdu != NULLP)
2131             {
2132                fillSsbPdu(dlTtiReqPdu, &macCellCfg, &msgLen);
2133                dlTtiReq->pdus = dlTtiReqPdu;
2134             }
2135             (dlTtiReq->nPdus)++;
2136             msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
2137             fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
2138             sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
2139             MAC_FREE(dlTtiReqPdu, sizeof(fapi_dl_tti_req_pdu_t));
2140          }
2141          MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
2142          return ROK;
2143       }
2144                 else
2145       {
2146          DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request");
2147          return RFAILED;
2148       }
2149    }
2150         else
2151         {
2152            DU_LOG("\nLOWER MAC: Current TTI Info is NULL");
2153       return RFAILED;
2154    }
2155 }
2156
2157 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
2158 {
2159    {
2160       /* PHY_STATE_IDLE */
2161        lwr_mac_handleParamReqEvt,
2162        lwr_mac_handleParamRspEvt,
2163        lwr_mac_handleConfigReqEvt,
2164        lwr_mac_handleConfigRspEvt,
2165        lwr_mac_handleInvalidEvt,
2166    },
2167    {
2168        /* PHY_STATE_CONFIGURED */
2169        lwr_mac_handleParamReqEvt,
2170        lwr_mac_handleParamRspEvt,
2171        lwr_mac_handleConfigReqEvt,
2172        lwr_mac_handleConfigRspEvt,
2173        lwr_mac_handleStartReqEvt,
2174    },
2175    {
2176        /* PHY_STATE_RUNNING */
2177        lwr_mac_handleInvalidEvt,
2178        lwr_mac_handleInvalidEvt,
2179        lwr_mac_handleConfigReqEvt,
2180        lwr_mac_handleConfigRspEvt,
2181        lwr_mac_handleInvalidEvt,
2182    }
2183 };
2184
2185 /*******************************************************************
2186  *
2187  * @brief Sends message to Lower Mac Fsm Event Handler
2188  *
2189  * @details
2190  *
2191  *    Function : sendToLowerMac
2192  *
2193  *    Functionality:
2194  *         -Sends message to LowerMac
2195  *
2196  * @params[in] Message Type
2197  *             Message Length
2198  *             Messaga Pointer
2199  *
2200  * @return void
2201  *
2202 ******************************************************************/
2203 void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
2204 {
2205    clGlobalCp.event = msgType;
2206    fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
2207 }
2208
2209 /**********************************************************************
2210          End of file
2211 **********************************************************************/