src/5gnrmac/lwr_mac_fsm.c

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