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