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