src/5gnrmac/lwr_mac_fsm.c

   1  /*******************************************************************************
   2  ################################################################################
   3  #   Copyright (c) [2017-2019] [Radisys]                                        #
   4  #                                                                              #
   5  #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6  #   you may not use this file except in compliance with the License.           #
   7  #   You may obtain a copy of the License at                                    #
   8  #                                                                              #
   9  #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10  #                                                                              #
  11  #   Unless required by applicable law or agreed to in writing, software        #
  12  #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13  #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14  #   See the License for the specific language governing permissions and        #
  15  #   limitations under the License.                                             #
  16  ################################################################################
  17  *******************************************************************************/
  18 #include <stdlib.h>
  19 #include "lwr_mac_fsm.h"
  20
  21 EXTERN void sendToPhy ARGS((U16 msgType, U32 msgLen, void *msg));
  22
  23  /*******************************************************************
  24   *
  25   * @brief Handles Invalid Request Event
  26   *
  27   * @details
  28   *
  29   *    Function : lwr_mac_handleInvalidEvt
  30   *
  31   *    Functionality:
  32   *         - Displays the PHY state when the invalid event occurs
  33   *
  34   * @params[in]
  35   * @return ROK     - success
  36   *         RFAILED - failure
  37   *
  38   * ****************************************************************/
  39 S16 lwr_mac_handleInvalidEvt(void *msg)
  40 {
  41   printf("\n Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
  42   RETVALUE(ROK);
  43 }
  44
  45 /*******************************************************************
  46   *
  47   * @brief Fills FAPI message header
  48   *
  49   * @details
  50   *
  51   *    Function : fillMsgHeader
  52   *
  53   *    Functionality:
  54   *         -Fills FAPI message header
  55   *
  56   * @params[in] Pointer to header
  57   *             Number of messages
  58   *             Messae Type
  59   *             Length of message
  60   * @return void
  61   *
  62   * ****************************************************************/
  63 PUBLIC void fillMsgHeader(fapi_msg_t *hdr, U16 msgType, U16 msgLen)
  64 {
  65    hdr->message_type_id = msgType;
  66    hdr->length = msgLen;
  67 }
  68
  69 /*******************************************************************
  70   *
  71   * @brief Fills FAPI Config Request message header
  72   *
  73   * @details
  74   *
  75   *    Function : fillTlvs
  76   *
  77   *    Functionality:
  78   *         -Fills FAPI Config Request message header
  79   *
  80   * @params[in] Pointer to TLV
  81   *             Tag
  82   *             Length
  83   *             Value
  84   *             MsgLen
  85   * @return void
  86   *
  87   * ****************************************************************/
  88 PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, U16 tag, U16 length, U16 value, U16 *msgLen)
  89 {
  90    tlv->tl.tag    = tag;
  91    tlv->tl.length = length;
  92    tlv->value     = value;
  93    *msgLen        = *msgLen + sizeof(tag) + sizeof(length) + length;
  94 }
  95  /*******************************************************************
  96   *
  97   * @brief fills the cyclic prefix by comparing the bitmask
  98   *
  99   * @details
 100   *
 101   *    Function : fillCyclicPrefix
 102   *
 103   *    Functionality:
 104   *         -checks the value with the bitmask and
 105   *          fills the cellPtr's cyclic prefix.
 106   *
 107   * @params[in] Pointer to ClCellParam
 108   *             Value to be compared
 109   * @return void
 110   *
 111   ********************************************************************/
 112 PUBLIC void fillCyclicPrefix(U8 value, ClCellParam **cellPtr)
 113 {
 114    if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
 115    {
 116       (*cellPtr)->cyclicPrefix   = NORMAL_CYCLIC_PREFIX_MASK;
 117    }
 118    else if((value & FAPI_EXTENDED_CYCLIC_PREFIX_MASK) == FAPI_EXTENDED_CYCLIC_PREFIX_MASK)
 119    {
 120       (*cellPtr)->cyclicPrefix   = EXTENDED_CYCLIC_PREFIX_MASK;
 121    }
 122    else
 123    {
 124       (*cellPtr)->cyclicPrefix = INVALID_VALUE;
 125    }
 126 }
 127
 128  /*******************************************************************
 129   *
 130   * @brief fills the subcarrier spacing of Downlink by comparing the bitmask
 131   *
 132   * @details
 133   *
 134   *    Function : fillSubcarrierSpaceDl
 135   *
 136   *    Functionality:
 137   *         -checks the value with the bitmask and
 138   *          fills the cellPtr's subcarrier spacing in DL
 139   *
 140   * @params[in] Pointer to ClCellParam
 141   *             Value to be compared
 142   * @return void
 143   *
 144   * ****************************************************************/
 145
 146 PUBLIC void fillSubcarrierSpaceDl(U8 value, ClCellParam **cellPtr)
 147 {
 148    if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
 149    {
 150       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_15_KHZ;
 151    }
 152    else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
 153    {
 154       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_30_KHZ;
 155    }
 156    else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
 157    {
 158       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_60_KHZ;
 159    }
 160    else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
 161    {
 162       (*cellPtr)->supportedSubcarrierSpacingDl = SPACING_120_KHZ;
 163    }
 164    else
 165    {
 166       (*cellPtr)->supportedSubcarrierSpacingDl = INVALID_VALUE;
 167    }
 168 }
 169
 170  /*******************************************************************
 171   *
 172   * @brief fills the downlink bandwidth by comparing the bitmask
 173   *
 174   * @details
 175   *
 176   *    Function : fillBandwidthDl
 177   *
 178   *    Functionality:
 179   *         -checks the value with the bitmask and
 180   *         -fills the cellPtr's DL Bandwidth
 181   *
 182   * @params[in] Pointer to ClCellParam
 183   *             Value to be compared
 184   * @return void
 185   *
 186   * ****************************************************************/
 187
 188 PUBLIC void fillBandwidthDl(U16 value, ClCellParam **cellPtr)
 189 {
 190    if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
 191    {
 192       (*cellPtr)->supportedBandwidthDl = BW_5MHZ;
 193    }
 194    else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
 195    {
 196       (*cellPtr)->supportedBandwidthDl = BW_10MHZ;
 197    }
 198    else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
 199    {
 200       (*cellPtr)->supportedBandwidthDl = BW_15MHZ;
 201    }
 202    else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
 203    {
 204       (*cellPtr)->supportedBandwidthDl = BW_20MHZ;
 205    }
 206    else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
 207    {
 208       (*cellPtr)->supportedBandwidthDl = BW_40MHZ;
 209    }
 210    else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
 211    {
 212       (*cellPtr)->supportedBandwidthDl = BW_50MHZ;
 213    }
 214    else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
 215    {
 216       (*cellPtr)->supportedBandwidthDl = BW_60MHZ;
 217    }
 218    else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
 219    {
 220       (*cellPtr)->supportedBandwidthDl = BW_70MHZ;
 221    }
 222    else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
 223    {
 224       (*cellPtr)->supportedBandwidthDl = BW_80MHZ;
 225    }
 226    else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
 227    {
 228       (*cellPtr)->supportedBandwidthDl = BW_90MHZ;
 229    }
 230    else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
 231    {
 232       (*cellPtr)->supportedBandwidthDl = BW_100MHZ;
 233    }
 234    else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
 235    {
 236       (*cellPtr)->supportedBandwidthDl = BW_200MHZ;
 237    }
 238    else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
 239    {
 240       (*cellPtr)->supportedBandwidthDl = BW_400MHZ;
 241    }
 242    else
 243    {
 244       (*cellPtr)->supportedBandwidthDl = INVALID_VALUE;
 245    }
 246 }
 247
 248  /*******************************************************************
 249   *
 250   * @brief fills the subcarrier spacing of Uplink by comparing the bitmask
 251   *
 252   * @details
 253   *
 254   *    Function : fillSubcarrierSpaceUl
 255   *
 256   *    Functionality:
 257   *         -checks the value with the bitmask and
 258   *         -fills cellPtr's subcarrier spacing in UL
 259   *
 260   * @params[in] Pointer to ClCellParam
 261   *             Value to be compared
 262   * @return void
 263   *
 264   * ****************************************************************/
 265
 266 PUBLIC void fillSubcarrierSpaceUl(U8 value, ClCellParam **cellPtr)
 267 {
 268    if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
 269    {
 270       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_15_KHZ;
 271    }
 272    else if((value & FAPI_30KHZ_MASK) == FAPI_30KHZ_MASK)
 273    {
 274       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_30_KHZ;
 275    }
 276    else if((value & FAPI_60KHZ_MASK) == FAPI_60KHZ_MASK)
 277    {
 278       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_60_KHZ;
 279    }
 280    else if((value & FAPI_120KHZ_MASK) == FAPI_120KHZ_MASK)
 281    {
 282       (*cellPtr)->supportedSubcarrierSpacingsUl = SPACING_120_KHZ;
 283    }
 284    else
 285    {
 286       (*cellPtr)->supportedSubcarrierSpacingsUl = INVALID_VALUE;
 287    }
 288 }
 289
 290  /*******************************************************************
 291   *
 292   * @brief fills the uplink bandwidth by comparing the bitmask
 293   *
 294   * @details
 295   *
 296   *    Function : fillBandwidthUl
 297   *
 298   *    Functionality:
 299   *         -checks the value with the bitmask and
 300   *          fills the cellPtr's UL Bandwidth
 301   *
 302   *
 303   *
 304   * @params[in] Pointer to ClCellParam
 305   *             Value to be compared
 306   * @return void
 307   *
 308   *
 309   * ****************************************************************/
 310
 311 PUBLIC void fillBandwidthUl(U16 value, ClCellParam **cellPtr)
 312 {
 313    if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
 314    {
 315       (*cellPtr)->supportedBandwidthUl = BW_5MHZ;
 316    }
 317    else if((value & FAPI_10MHZ_BW_MASK) == FAPI_10MHZ_BW_MASK)
 318    {
 319       (*cellPtr)->supportedBandwidthUl = BW_10MHZ;
 320    }
 321    else if((value & FAPI_15MHZ_BW_MASK) == FAPI_15MHZ_BW_MASK)
 322    {
 323       (*cellPtr)->supportedBandwidthUl = BW_15MHZ;
 324    }
 325    else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
 326    {
 327       (*cellPtr)->supportedBandwidthUl = BW_20MHZ;
 328    }
 329    else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
 330    {
 331       (*cellPtr)->supportedBandwidthUl = BW_40MHZ;
 332    }
 333    else if((value & FAPI_50MHZ_BW_MASK) == FAPI_50MHZ_BW_MASK)
 334    {
 335       (*cellPtr)->supportedBandwidthUl = BW_50MHZ;
 336    }
 337    else if((value & FAPI_60MHZ_BW_MASK) == FAPI_60MHZ_BW_MASK)
 338    {
 339       (*cellPtr)->supportedBandwidthUl = BW_60MHZ;
 340    }
 341    else if((value & FAPI_70MHZ_BW_MASK) == FAPI_70MHZ_BW_MASK)
 342    {
 343       (*cellPtr)->supportedBandwidthUl = BW_70MHZ;
 344    }
 345    else if((value & FAPI_80MHZ_BW_MASK) == FAPI_80MHZ_BW_MASK)
 346    {
 347       (*cellPtr)->supportedBandwidthUl = BW_80MHZ;
 348    }
 349    else if((value & FAPI_90MHZ_BW_MASK) == FAPI_90MHZ_BW_MASK)
 350    {
 351       (*cellPtr)->supportedBandwidthUl = BW_90MHZ;
 352    }
 353    else if((value & FAPI_100MHZ_BW_MASK) == FAPI_100MHZ_BW_MASK)
 354    {
 355       (*cellPtr)->supportedBandwidthUl = BW_100MHZ;
 356    }
 357    else if((value & FAPI_200MHZ_BW_MASK) == FAPI_200MHZ_BW_MASK)
 358    {
 359       (*cellPtr)->supportedBandwidthUl = BW_200MHZ;
 360    }
 361    else if((value & FAPI_400MHZ_BW_MASK) == FAPI_400MHZ_BW_MASK)
 362    {
 363       (*cellPtr)->supportedBandwidthUl = BW_400MHZ;
 364    }
 365    else
 366    {
 367       (*cellPtr)->supportedBandwidthUl = INVALID_VALUE;
 368    }
 369 }
 370  /*******************************************************************
 371   *
 372   * @brief fills the CCE maping by comparing the bitmask
 373   *
 374   * @details
 375   *
 376   *    Function : fillCCEmaping
 377   *
 378   *    Functionality:
 379   *         -checks the value with the bitmask and
 380   *          fills the cellPtr's CCE Mapping Type
 381   *
 382   *
 383   * @params[in] Pointer to ClCellParam
 384   *             Value to be compared
 385   * @return void
 386   *
 387   * ****************************************************************/
 388
 389 PUBLIC void fillCCEmaping(U8 value,  ClCellParam **cellPtr)
 390 {
 391    if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
 392    {
 393       (*cellPtr)->cceMappingType = CCE_MAPPING_INTERLEAVED_MASK;
 394    }
 395    else if((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_NONINTERLVD_MASK)
 396    {
 397       (*cellPtr)->cceMappingType = CCE_MAPPING_NONINTERLVD_MASK;
 398    }
 399    else
 400    {
 401       (*cellPtr)->cceMappingType = INVALID_VALUE;
 402    }
 403 }
 404
 405  /*******************************************************************
 406   *
 407   * @brief fills the PUCCH format by comparing the bitmask
 408   *
 409   * @details
 410   *
 411   *    Function : fillPucchFormat
 412   *
 413   *    Functionality:
 414   *         -checks the value with the bitmask and
 415   *          fills the cellPtr's pucch format
 416   *
 417   *
 418   * @params[in] Pointer to ClCellParam
 419   *             Value to be compared
 420   * @return void
 421   *
 422   * ****************************************************************/
 423
 424 PUBLIC void fillPucchFormat(U8 value, ClCellParam **cellPtr)
 425 {
 426    if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
 427    {
 428       (*cellPtr)->pucchFormats    = FORMAT_0;
 429    }
 430    else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
 431    {
 432       (*cellPtr)->pucchFormats    = FORMAT_1;
 433    }
 434    else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
 435    {
 436       (*cellPtr)->pucchFormats    = FORMAT_2;
 437    }
 438    else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
 439    {
 440       (*cellPtr)->pucchFormats    = FORMAT_3;
 441    }
 442    else if((value & FAPI_FORMAT_4_MASK) == FAPI_FORMAT_4_MASK)
 443    {
 444       (*cellPtr)->pucchFormats    = FORMAT_4;
 445    }
 446    else
 447    {
 448       (*cellPtr)->pucchFormats    = INVALID_VALUE;
 449    }
 450 }
 451
 452  /*******************************************************************
 453   *
 454   * @brief fills the PDSCH Mapping Type by comparing the bitmask
 455   *
 456   * @details
 457   *
 458   *    Function : fillPdschMappingType
 459   *
 460   *    Functionality:
 461   *         -checks the value with the bitmask and
 462   *          fills the cellPtr's PDSCH MappingType
 463   *
 464   * @params[in] Pointer to ClCellParam
 465   *             Value to be compared
 466   * @return void
 467   *
 468   * ****************************************************************/
 469
 470 PUBLIC void fillPdschMappingType(U8 value, ClCellParam **cellPtr)
 471 {
 472    if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
 473    {
 474       (*cellPtr)->pdschMappingType = MAPPING_TYPE_A;
 475    }
 476    else if((value & FAPI_PDSCH_MAPPING_TYPE_B_MASK) == FAPI_PDSCH_MAPPING_TYPE_B_MASK)
 477    {
 478       (*cellPtr)->pdschMappingType = MAPPING_TYPE_B;
 479    }
 480    else
 481    {
 482       (*cellPtr)->pdschMappingType = INVALID_VALUE;
 483    }
 484 }
 485
 486 /*******************************************************************
 487   *
 488   * @brief fills the PDSCH Allocation Type by comparing the bitmask
 489   *
 490   * @details
 491   *
 492   *    Function : fillPdschAllocationType
 493   *
 494   *    Functionality:
 495   *         -checks the value with the bitmask and
 496   *          fills the cellPtr's PDSCH AllocationType
 497   *
 498   * @params[in] Pointer to ClCellParam
 499   *             Value to be compared
 500   * @return void
 501   *
 502   * ****************************************************************/
 503
 504 PUBLIC void fillPdschAllocationType(U8 value, ClCellParam **cellPtr)
 505 {
 506    if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
 507    {
 508       (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_0;
 509    }
 510    else if((value & FAPI_PDSCH_ALLOC_TYPE_1_MASK) == FAPI_PDSCH_ALLOC_TYPE_1_MASK)
 511    {
 512       (*cellPtr)->pdschAllocationTypes = ALLOCATION_TYPE_1;
 513    }
 514    else
 515    {
 516       (*cellPtr)->pdschAllocationTypes = INVALID_VALUE;
 517    }
 518 }
 519
 520 /*******************************************************************
 521   *
 522   * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask
 523   *
 524   * @details
 525   *
 526   *    Function : fillPrbMappingType
 527   *
 528   *    Functionality:
 529   *         -checks the value with the bitmask and
 530   *          fills the cellPtr's PRB Mapping Type
 531   *
 532   * @params[in] Pointer to ClCellParam
 533   *             Value to be compared
 534   * @return void
 535   *
 536   ******************************************************************/
 537 PUBLIC void fillPrbMappingType(U8 value, ClCellParam **cellPtr)
 538 {
 539    if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
 540    {
 541       (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
 542    }
 543    else if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
 544    {
 545       (*cellPtr)->pdschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
 546    }
 547    else
 548    {
 549       (*cellPtr)->pdschVrbToPrbMapping = INVALID_VALUE;
 550    }
 551 }
 552
 553 /*******************************************************************
 554   *
 555   * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask
 556   *
 557   * @details
 558   *
 559   *    Function : fillPdschDmrsConfigType
 560   *
 561   *    Functionality:
 562   *         -checks the value with the bitmask and
 563   *          fills the cellPtr's DmrsConfig Type
 564   *
 565   * @params[in] Pointer to ClCellParam
 566   *             Value to be compared
 567   * @return void
 568   *
 569   ******************************************************************/
 570
 571 PUBLIC void fillPdschDmrsConfigType(U8 value, ClCellParam **cellPtr)
 572 {
 573   if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
 574   {
 575      (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
 576   }
 577   else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK)
 578   {
 579      (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
 580   }
 581   else
 582   {
 583      (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE;
 584   }
 585 }
 586
 587 /*******************************************************************
 588   *
 589   * @brief fills the PDSCH DmrsLength by comparing the bitmask
 590   *
 591   * @details
 592   *
 593   *    Function : fillPdschDmrsLength
 594   *
 595   *    Functionality:
 596   *         -checks the value with the bitmask and
 597   *          fills the cellPtr's PdschDmrsLength
 598   *
 599   * @params[in] Pointer to ClCellParam
 600   *             Value to be compared
 601   * @return void
 602   *
 603   ******************************************************************/
 604 PUBLIC void fillPdschDmrsLength(U8 value, ClCellParam **cellPtr)
 605 {
 606    if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
 607    {
 608       (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_1;
 609    }
 610    else if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_2)
 611    {
 612       (*cellPtr)->pdschDmrsMaxLength = DMRS_MAX_LENGTH_2;
 613    }
 614    else
 615    {
 616       (*cellPtr)->pdschDmrsMaxLength = INVALID_VALUE;
 617    }
 618 }
 619
 620 /*******************************************************************
 621   *
 622   * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask
 623   *
 624   * @details
 625   *
 626   *    Function : fillPdschDmrsAddPos
 627   *
 628   *    Functionality:
 629   *         -checks the value with the bitmask and
 630   *          fills the cellPtr's Pdsch DmrsAddPos
 631   *
 632   * @params[in] Pointer to ClCellParam
 633   *             Value to be compared
 634   * @return void
 635   *
 636   ******************************************************************/
 637
 638 PUBLIC void fillPdschDmrsAddPos(U8 value, ClCellParam **cellPtr)
 639 {
 640    if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
 641    {
 642       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
 643    }
 644    else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
 645    {
 646       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
 647    }
 648    else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
 649    {
 650       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
 651    }
 652    else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
 653    {
 654       (*cellPtr)->pdschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
 655    }
 656    else
 657    {
 658       (*cellPtr)->pdschDmrsAdditionalPos = INVALID_VALUE;
 659    }
 660 }
 661
 662 /*******************************************************************
 663   *
 664   * @brief fills the Modulation Order in DL by comparing the bitmask
 665   *
 666   * @details
 667   *
 668   *    Function : fillModulationOrderDl
 669   *
 670   *    Functionality:
 671   *         -checks the value with the bitmask and
 672   *          fills the cellPtr's ModulationOrder in DL.
 673   *
 674   * @params[in] Pointer to ClCellParam
 675   *             Value to be compared
 676   * @return void
 677   *
 678   ******************************************************************/
 679 PUBLIC void fillModulationOrderDl(U8 value, ClCellParam **cellPtr)
 680 {
 681    if(value == 0 )
 682    {
 683       (*cellPtr)->supportedMaxModulationOrderDl = MOD_QPSK;
 684    }
 685    else if(value == 1)
 686    {
 687       (*cellPtr)->supportedMaxModulationOrderDl = MOD_16QAM;
 688    }
 689    else if(value == 2)
 690    {
 691       (*cellPtr)->supportedMaxModulationOrderDl = MOD_64QAM;
 692    }
 693    else if(value == 3)
 694    {
 695       (*cellPtr)->supportedMaxModulationOrderDl = MOD_256QAM;
 696    }
 697    else
 698    {
 699       (*cellPtr)->supportedMaxModulationOrderDl = INVALID_VALUE;
 700    }
 701 }
 702
 703 /*******************************************************************
 704   *
 705   * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask
 706   *
 707   * @details
 708   *
 709   *    Function : fillPuschDmrsConfigType
 710   *
 711   *    Functionality:
 712   *         -checks the value with the bitmask and
 713   *          fills the cellPtr's PUSCH DmrsConfigType
 714   *
 715   * @params[in] Pointer to ClCellParam
 716   *             Value to be compared
 717   * @return void
 718   *
 719   ******************************************************************/
 720
 721 PUBLIC void fillPuschDmrsConfig(U8 value, ClCellParam **cellPtr)
 722 {
 723    if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
 724    {
 725       (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_1;
 726    }
 727    else if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_2_MASK)
 728    {
 729       (*cellPtr)->puschDmrsConfigTypes = DMRS_CONFIG_TYPE_2;
 730    }
 731    else
 732    {
 733       (*cellPtr)->puschDmrsConfigTypes = INVALID_VALUE;
 734    }
 735 }
 736
 737 /*******************************************************************
 738   *
 739   * @brief fills the PUSCH DmrsLength by comparing the bitmask
 740   *
 741   * @details
 742   *
 743   *    Function : fillPuschDmrsLength
 744   *
 745   *    Functionality:
 746   *         -checks the value with the bitmask and
 747   *          fills the cellPtr's PUSCH DmrsLength
 748   *
 749   * @params[in] Pointer to ClCellParam
 750   *             Value to be compared
 751   * @return void
 752   *
 753   ******************************************************************/
 754
 755 PUBLIC void fillPuschDmrsLength(U8 value, ClCellParam **cellPtr)
 756 {
 757    if(value  == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
 758    {
 759       (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_1;
 760    }
 761    else if(value  == FAPI_PUSCH_DMRS_MAX_LENGTH_2)
 762    {
 763       (*cellPtr)->puschDmrsMaxLength = DMRS_MAX_LENGTH_2;
 764    }
 765    else
 766    {
 767       (*cellPtr)->puschDmrsMaxLength = INVALID_VALUE;
 768    }
 769 }
 770
 771 /*******************************************************************
 772   *
 773   * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask
 774   *
 775   * @details
 776   *
 777   *    Function : fillPuschDmrsAddPos
 778   *
 779   *    Functionality:
 780   *         -checks the value with the bitmask and
 781   *          fills the cellPtr's PUSCH DmrsAddPos
 782   *
 783   * @params[in] Pointer to ClCellParam
 784   *             Value to be compared
 785   * @return void
 786   *
 787   ******************************************************************/
 788
 789 PUBLIC void fillPuschDmrsAddPos(U8 value, ClCellParam **cellPtr)
 790 {
 791    if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
 792    {
 793       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_0;
 794    }
 795    else if((value & FAPI_DMRS_ADDITIONAL_POS_1_MASK) == FAPI_DMRS_ADDITIONAL_POS_1_MASK)
 796    {
 797       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_1;
 798    }
 799    else if((value & FAPI_DMRS_ADDITIONAL_POS_2_MASK) == FAPI_DMRS_ADDITIONAL_POS_2_MASK)
 800    {
 801       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_2;
 802    }
 803    else if((value & FAPI_DMRS_ADDITIONAL_POS_3_MASK) == FAPI_DMRS_ADDITIONAL_POS_3_MASK)
 804    {
 805       (*cellPtr)->puschDmrsAdditionalPos = DMRS_ADDITIONAL_POS_3;
 806    }
 807    else
 808    {
 809       (*cellPtr)->puschDmrsAdditionalPos = INVALID_VALUE;
 810    }
 811 }
 812
 813 /*******************************************************************
 814   *
 815   * @brief fills the PUSCH Mapping Type by comparing the bitmask
 816   *
 817   * @details
 818   *
 819   *    Function : fillPuschMappingType
 820   *
 821   *    Functionality:
 822   *         -checks the value with the bitmask and
 823   *          fills the cellPtr's PUSCH MappingType
 824   *
 825   * @params[in] Pointer to ClCellParam
 826   *             Value to be compared
 827   * @return void
 828   *
 829   ******************************************************************/
 830
 831 PUBLIC void fillPuschMappingType(U8 value, ClCellParam **cellPtr)
 832 {
 833    if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
 834    {
 835       (*cellPtr)->puschMappingType = MAPPING_TYPE_A;
 836    }
 837    else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK)
 838    {
 839       (*cellPtr)->puschMappingType = MAPPING_TYPE_B;
 840    }
 841    else
 842    {
 843       (*cellPtr)->puschMappingType = INVALID_VALUE;
 844    }
 845 }
 846
 847 /*******************************************************************
 848   *
 849   * @brief fills the PUSCH Allocation Type by comparing the bitmask
 850   *
 851   * @details
 852   *
 853   *    Function : fillPuschAllocationType
 854   *
 855   *    Functionality:
 856   *         -checks the value with the bitmask and
 857   *          fills the cellPtr's PUSCH AllocationType
 858   *
 859   * @params[in] Pointer to ClCellParam
 860   *             Value to be compared
 861   * @return void
 862   *
 863   ******************************************************************/
 864
 865 PUBLIC void fillPuschAllocationType(U8 value, ClCellParam **cellPtr)
 866 {
 867    if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
 868    {
 869       (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_0;
 870    }
 871    else if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
 872    {
 873       (*cellPtr)->puschAllocationTypes = ALLOCATION_TYPE_1;
 874    }
 875    else
 876    {
 877       (*cellPtr)->puschAllocationTypes = INVALID_VALUE;
 878    }
 879 }
 880
 881 /*******************************************************************
 882   *
 883   * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask
 884   *
 885   * @details
 886   *
 887   *    Function : fillPuschPrbMappingType
 888   *
 889   *    Functionality:
 890   *         -checks the value with the bitmask and
 891   *          fills the cellPtr's PUSCH PRB MApping Type
 892   *
 893   * @params[in] Pointer to ClCellParam
 894   *             Value to be compared
 895   * @return void
 896   *
 897   ******************************************************************/
 898
 899 PUBLIC void fillPuschPrbMappingType(U8 value, ClCellParam **cellPtr)
 900 {
 901    if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
 902    {
 903       (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_NON_INTLV;
 904    }
 905    else if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_INTLVD_MASK)
 906    {
 907       (*cellPtr)->puschVrbToPrbMapping = VRB_TO_PRB_MAP_INTLVD;
 908    }
 909    else
 910    {
 911       (*cellPtr)->puschVrbToPrbMapping = INVALID_VALUE;
 912    }
 913 }
 914
 915 /*******************************************************************
 916   *
 917   * @brief fills the Modulation Order in Ul by comparing the bitmask
 918   *
 919   * @details
 920   *
 921   *    Function : fillModulationOrderUl
 922   *
 923   *    Functionality:
 924   *         -checks the value with the bitmask and
 925   *          fills the cellPtr's Modualtsion Order in UL.
 926   *
 927   * @params[in] Pointer to ClCellParam
 928   *             Value to be compared
 929   * @return void
 930   *
 931   ******************************************************************/
 932
 933 PUBLIC void fillModulationOrderUl(U8 value, ClCellParam **cellPtr)
 934 {
 935    if(value == 0)
 936    {
 937       (*cellPtr)->supportedModulationOrderUl = MOD_QPSK;
 938    }
 939    else if(value == 1)
 940    {
 941       (*cellPtr)->supportedModulationOrderUl = MOD_16QAM;
 942    }
 943    else if(value == 2)
 944    {
 945       (*cellPtr)->supportedModulationOrderUl = MOD_64QAM;
 946    }
 947    else if(value == 3)
 948    {
 949       (*cellPtr)->supportedModulationOrderUl = MOD_256QAM;
 950    }
 951    else
 952    {
 953       (*cellPtr)->supportedModulationOrderUl = INVALID_VALUE;
 954    }
 955 }
 956
 957 /*******************************************************************
 958   *
 959   * @brief fills the PUSCH Aggregation Factor by comparing the bitmask
 960   *
 961   * @details
 962   *
 963   *    Function : fillPuschAggregationFactor
 964   *
 965   *    Functionality:
 966   *         -checks the value with the bitmask and
 967   *          fills the cellPtr's PUSCH Aggregation Factor
 968   *
 969   * @params[in] Pointer to ClCellParam
 970   *             Value to be compared
 971   * @return void
 972   *
 973   ******************************************************************/
 974
 975 PUBLIC void fillPuschAggregationFactor(U8 value, ClCellParam **cellPtr)
 976 {
 977    if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
 978    {
 979       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_1;
 980    }
 981    else if((value & FAPI_FORMAT_1_MASK) == FAPI_FORMAT_1_MASK)
 982    {
 983       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_2;
 984    }
 985    else if((value & FAPI_FORMAT_2_MASK) == FAPI_FORMAT_2_MASK)
 986    {
 987       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_4;
 988    }
 989    else if((value & FAPI_FORMAT_3_MASK) == FAPI_FORMAT_3_MASK)
 990    {
 991       (*cellPtr)->puschAggregationFactor    = AGG_FACTOR_8;
 992    }
 993    else
 994    {
 995       (*cellPtr)->puschAggregationFactor    = INVALID_VALUE;
 996    }
 997 }
 998
 999 /*******************************************************************
1000   *
1001   * @brief fills the PRACH Long Format by comparing the bitmask
1002   *
1003   * @details
1004   *
1005   *    Function : fillPrachLongFormat
1006   *
1007   *    Functionality:
1008   *         -checks the value with the bitmask and
1009   *          fills the cellPtr's PRACH Long Format
1010   *
1011   * @params[in] Pointer to ClCellParam
1012   *             Value to be compared
1013   * @return void
1014   *
1015   ******************************************************************/
1016
1017 PUBLIC void fillPrachLongFormat(U8 value, ClCellParam **cellPtr)
1018 {
1019    if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
1020    {
1021       (*cellPtr)->prachLongFormats    = FORMAT_0;
1022    }
1023    else if((value & FAPI_PRACH_LF_FORMAT_1_MASK) == FAPI_PRACH_LF_FORMAT_1_MASK)
1024    {
1025       (*cellPtr)->prachLongFormats    = FORMAT_1;
1026    }
1027    else if((value & FAPI_PRACH_LF_FORMAT_2_MASK) == FAPI_PRACH_LF_FORMAT_2_MASK)
1028    {
1029       (*cellPtr)->prachLongFormats    = FORMAT_2;
1030    }
1031    else if((value & FAPI_PRACH_LF_FORMAT_3_MASK) == FAPI_PRACH_LF_FORMAT_3_MASK)
1032    {
1033       (*cellPtr)->prachLongFormats    = FORMAT_3;
1034    }
1035    else
1036    {
1037       (*cellPtr)->prachLongFormats    = INVALID_VALUE;
1038    }
1039 }
1040
1041 /*******************************************************************
1042   *
1043   * @brief fills the PRACH Short Format by comparing the bitmask
1044   *
1045   * @details
1046   *
1047   *    Function : fillPrachShortFormat
1048   *
1049   *    Functionality:
1050   *         -checks the value with the bitmask and
1051   *          fills the cellPtr's PRACH ShortFormat
1052   *
1053   * @params[in] Pointer to ClCellParam
1054   *             Value to be compared
1055   * @return void
1056   *
1057   ******************************************************************/
1058
1059 PUBLIC void fillPrachShortFormat(U8 value, ClCellParam **cellPtr)
1060 {
1061    if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
1062    {
1063       (*cellPtr)->prachShortFormats    = SF_FORMAT_A1;
1064    }
1065    else if((value & FAPI_PRACH_SF_FORMAT_A2_MASK) == FAPI_PRACH_SF_FORMAT_A2_MASK)
1066    {
1067       (*cellPtr)->prachShortFormats    = SF_FORMAT_A2;
1068    }
1069    else if((value & FAPI_PRACH_SF_FORMAT_A3_MASK) == FAPI_PRACH_SF_FORMAT_A3_MASK)
1070    {
1071       (*cellPtr)->prachShortFormats    = SF_FORMAT_A3;
1072    }
1073    else if((value & FAPI_PRACH_SF_FORMAT_B1_MASK) == FAPI_PRACH_SF_FORMAT_B1_MASK)
1074    {
1075       (*cellPtr)->prachShortFormats    = SF_FORMAT_B1;
1076    }
1077    else if((value & FAPI_PRACH_SF_FORMAT_B2_MASK) == FAPI_PRACH_SF_FORMAT_B2_MASK)
1078    {
1079       (*cellPtr)->prachShortFormats    = SF_FORMAT_B2;
1080    }
1081    else if((value & FAPI_PRACH_SF_FORMAT_B3_MASK) == FAPI_PRACH_SF_FORMAT_B3_MASK)
1082    {
1083       (*cellPtr)->prachShortFormats    = SF_FORMAT_B3;
1084    }
1085    else if((value & FAPI_PRACH_SF_FORMAT_B4_MASK) == FAPI_PRACH_SF_FORMAT_B4_MASK)
1086    {
1087       (*cellPtr)->prachShortFormats    = SF_FORMAT_B4;
1088    }
1089    else if((value & FAPI_PRACH_SF_FORMAT_C0_MASK) == FAPI_PRACH_SF_FORMAT_C0_MASK)
1090    {
1091       (*cellPtr)->prachShortFormats    = SF_FORMAT_C0;
1092    }
1093    else if((value & FAPI_PRACH_SF_FORMAT_C2_MASK) == FAPI_PRACH_SF_FORMAT_C2_MASK)
1094    {
1095       (*cellPtr)->prachShortFormats    = SF_FORMAT_C2;
1096    }
1097    else
1098    {
1099       (*cellPtr)->prachShortFormats    = INVALID_VALUE;
1100    }
1101 }
1102
1103 /*******************************************************************
1104   *
1105   * @brief fills the Fd Occasions Type by comparing the bitmask
1106   *
1107   * @details
1108   *
1109   *    Function : fillFdOccasions
1110   *
1111   *    Functionality:
1112   *         -checks the value with the bitmask and
1113   *          fills the cellPtr's Fd Occasions
1114   *
1115   * @params[in] Pointer to ClCellParam
1116   *             Value to be compared
1117   * @return void
1118   *
1119   ******************************************************************/
1120
1121 PUBLIC void fillFdOccasions(U8 value, ClCellParam **cellPtr)
1122 {
1123    if(value == 0)
1124    {
1125       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_1;
1126    }
1127    else if(value == 1)
1128    {
1129       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_2;
1130    }
1131    else if(value == 3)
1132    {
1133       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_4;
1134    }
1135    else if(value == 4)
1136    {
1137       (*cellPtr)->maxPrachFdOccasionsInASlot = PRACH_FD_OCC_IN_A_SLOT_8;
1138    }
1139    else
1140    {
1141       (*cellPtr)->maxPrachFdOccasionsInASlot = INVALID_VALUE;
1142    }
1143 }
1144
1145 /*******************************************************************
1146   *
1147   * @brief fills the RSSI Measurement by comparing the bitmask
1148   *
1149   * @details
1150   *
1151   *    Function : fillRssiMeas
1152   *
1153   *    Functionality:
1154   *         -checks the value with the bitmask and
1155   *          fills the cellPtr's RSSI Measurement report
1156   *
1157   * @params[in] Pointer to ClCellParam
1158   *             Value to be compared
1159   * @return void
1160   *
1161   ******************************************************************/
1162
1163 PUBLIC void fillRssiMeas(U8 value, ClCellParam **cellPtr)
1164 {
1165    if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
1166    {
1167       (*cellPtr)->rssiMeasurementSupport    = RSSI_REPORT_DBM;
1168    }
1169    else if((value & FAPI_RSSI_REPORT_IN_DBFS_MASK) == FAPI_RSSI_REPORT_IN_DBFS_MASK)
1170    {
1171       (*cellPtr)->rssiMeasurementSupport    = RSSI_REPORT_DBFS;
1172    }
1173    else
1174    {
1175       (*cellPtr)->rssiMeasurementSupport    = INVALID_VALUE;
1176    }
1177 }
1178
1179  /*******************************************************************
1180   *
1181   * @brief Returns the TLVs value
1182   *
1183   * @details
1184   *
1185   *    Function : getParamValue
1186   *
1187   *    Functionality:
1188   *         -return TLVs value
1189   *
1190   * @params[in]
1191   * @return ROK     - temp
1192   *         RFAILED - failure
1193   *
1194   * ****************************************************************/
1195
1196 S16 getParamValue(fapi_uint16_tlv_t *tlv, U16 type)
1197 {
1198     U16 valueLen;
1199     void *temp, *posPtr;
1200     valueLen = tlv->tl.length;
1201     posPtr   = &tlv->tl.tag;
1202     posPtr   += sizeof(tlv->tl.tag);
1203     posPtr   += sizeof(tlv->tl.length);
1204     /*TO DO: malloc to SSI memory */
1205     if(type == FAPI_UINT_8)
1206     {
1207        temp = (U8 *)malloc(valueLen * sizeof(U8));
1208        memcpy(temp, posPtr, valueLen);
1209        return(*(U8 *)temp);
1210     }
1211     else if(type == FAPI_UINT_16)
1212     {
1213        temp = (U16 *)malloc(valueLen * sizeof(U16));
1214        memcpy(temp, posPtr, valueLen);
1215        return(*(U16 *)temp);
1216     }
1217     else if(type == FAPI_UINT_32)
1218     {
1219        temp = (U32 *)malloc(valueLen * sizeof(U32));
1220        memcpy(temp, posPtr, valueLen);
1221        return(*(U32 *)temp);
1222     }
1223     else
1224     {
1225       printf("\n Value Extraction failed" );
1226       RETVALUE(RFAILED);
1227     }
1228 }
1229  /*******************************************************************
1230   *
1231   * @brief Sends FAPI Param req to PHY
1232   *
1233   * @details
1234   *
1235   *    Function : lwr_mac_handleParamReqEvt
1236   *
1237   *    Functionality:
1238   *         -Sends FAPI Param req to PHY
1239   *
1240   * @params[in]
1241   * @return ROK     - success
1242   *         RFAILED - failure
1243   *
1244   * ****************************************************************/
1245
1246 S16 lwr_mac_handleParamReqEvt(void *msg)
1247 {
1248    /* startGuardTimer(); */
1249    fapi_param_req_t *paramReq = (fapi_param_req_t *)msg;
1250    if(SGetSBuf(0, 0, (Data **)&paramReq, sizeof(fapi_param_req_t)) != ROK)
1251    {
1252       printf("\nFailed to allocate memory for Param Request");
1253       RETVALUE(LCM_REASON_MEM_NOAVAIL);
1254    }
1255    else
1256    {
1257       fillMsgHeader(&paramReq->header, FAPI_PARAM_REQUEST, 0);
1258       sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
1259       RETVALUE(ROK);
1260    }
1261 }
1262
1263  /*******************************************************************
1264   *
1265   * @brief Sends FAPI Param rsp to MAC via PHY
1266   *
1267   * @details
1268   *
1269   *    Function : lwr_mac_handleParamRspEvt
1270   *
1271   *    Functionality:
1272   *         -Sends FAPI Param rsp to MAC via PHY
1273   *
1274   * @params[in]
1275   * @return ROK     - success
1276   *         RFAILED - failure
1277   *
1278   * ****************************************************************/
1279
1280 S16 lwr_mac_handleParamRspEvt(fapi_param_resp_t *paramRsp)
1281 {
1282   /* stopGuardTimer(); */
1283    U16 index;
1284    U32 encodedVal;
1285    ClCellParam *cellParam = NULLP;
1286    if(paramRsp == NULLP)
1287    {
1288       printf("\n Param Request for State [%d] is unsuccessfull", clGlobalCp.phyState);
1289       RETVALUE(RFAILED);
1290    }
1291    printf("\n Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
1292    SPutSBuf(0, 0, (Data *)paramRsp, paramRsp->header.length);
1293    if(SGetSBuf(0, 0, (Data **)&cellParam, sizeof(ClCellParam)) != ROK)
1294    {
1295       printf("\nFailed to allocate memory for new cell");
1296       RETVALUE(LCM_REASON_MEM_NOAVAIL);
1297    }
1298
1299    printf("\n Filling TLVS into MAC API");
1300    if(paramRsp->error_code == MSG_OK)
1301    {
1302       for(index = 0; index < paramRsp->number_of_tlvs; index++)
1303       {
1304          switch(paramRsp->tlvs[index].tl.tag)
1305          {
1306             case FAPI_RELEASE_CAPABILITY_TAG:
1307                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1308                if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
1309                {
1310                   cellParam->releaseCapability = RELEASE_15;
1311                }
1312                break;
1313
1314             case FAPI_PHY_STATE_TAG:
1315                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1316                if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
1317                {
1318                   printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
1319                   RETVALUE(RFAILED);
1320                }
1321                break;
1322
1323             case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
1324                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1325                if(encodedVal != RFAILED && encodedVal != 0)
1326                {
1327                  cellParam->skipBlankDlConfig = SUPPORTED;
1328                }
1329                else
1330                {
1331                  cellParam->skipBlankDlConfig = NOT_SUPPORTED;
1332                }
1333                break;
1334
1335             case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
1336                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1337                if(encodedVal != RFAILED && encodedVal != 0)
1338                {
1339                  cellParam->skipBlankUlConfig = SUPPORTED;
1340                }
1341                else
1342                {
1343                  cellParam->skipBlankUlConfig = NOT_SUPPORTED;
1344                }
1345                break;
1346
1347             case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
1348                cellParam->numTlvsToReport = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1349                break;
1350
1351             case FAPI_CYCLIC_PREFIX_TAG:
1352                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1353                if(encodedVal != RFAILED)
1354                {
1355                   fillCyclicPrefix(encodedVal, &cellParam);
1356                }
1357                break;
1358
1359             case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
1360                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1361                if(encodedVal != RFAILED)
1362                {
1363                   fillSubcarrierSpaceDl(encodedVal, &cellParam);
1364                }
1365                break;
1366
1367             case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
1368                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1369                if(encodedVal != RFAILED)
1370                {
1371                   fillBandwidthDl(encodedVal, &cellParam);
1372                }
1373                break;
1374
1375             case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
1376                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1377                if(encodedVal != RFAILED)
1378                {
1379                   fillSubcarrierSpaceUl(encodedVal, &cellParam);
1380                }
1381                break;
1382
1383             case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
1384                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_16);
1385                if(encodedVal != RFAILED)
1386                {
1387                   fillBandwidthUl(encodedVal, &cellParam);
1388                }
1389                break;
1390
1391             case FAPI_CCE_MAPPING_TYPE_TAG:
1392                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1393                if(encodedVal != RFAILED)
1394                {
1395                   fillCCEmaping(encodedVal, &cellParam);
1396                }
1397                break;
1398
1399             case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
1400                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1401                if(encodedVal != RFAILED && encodedVal != 0)
1402                {
1403                   cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
1404                }
1405                else
1406                {
1407                   cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
1408                }
1409                break;
1410
1411             case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
1412                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1413                if(encodedVal != RFAILED && encodedVal != 0)
1414                {
1415                   cellParam->precoderGranularityCoreset = SUPPORTED;
1416                }
1417                else
1418                {
1419                   cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
1420                }
1421                break;
1422
1423             case FAPI_PDCCH_MU_MIMO_TAG:
1424                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1425                if(encodedVal != RFAILED && encodedVal != 0)
1426                {
1427                   cellParam->pdcchMuMimo = SUPPORTED;
1428                }
1429                else
1430                {
1431                   cellParam->pdcchMuMimo = NOT_SUPPORTED;
1432                }
1433                break;
1434
1435             case FAPI_PDCCH_PRECODER_CYCLING_TAG:
1436                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1437                if(encodedVal != RFAILED && encodedVal != 0)
1438                {
1439                   cellParam->pdcchPrecoderCycling = SUPPORTED;
1440                }
1441                else
1442                {
1443                   cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
1444                }
1445                break;
1446
1447             case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
1448                cellParam->maxPdcchsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1449                break;
1450
1451             case FAPI_PUCCH_FORMATS_TAG:
1452                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1453                if(encodedVal != RFAILED)
1454                {
1455                   fillPucchFormat(encodedVal, &cellParam);
1456                }
1457                break;
1458
1459             case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
1460                cellParam->maxPucchsPerSlot   = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1461                break;
1462
1463             case FAPI_PDSCH_MAPPING_TYPE_TAG:
1464                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1465                if(encodedVal != RFAILED)
1466                {
1467                   fillPdschMappingType(encodedVal, &cellParam);
1468                }
1469                break;
1470
1471             case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
1472                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1473                if(encodedVal != RFAILED)
1474                {
1475                   fillPdschAllocationType(encodedVal, &cellParam);
1476                }
1477                break;
1478
1479             case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
1480                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1481                if(encodedVal != RFAILED)
1482                {
1483                   fillPrbMappingType(encodedVal, &cellParam);
1484                }
1485                break;
1486
1487             case FAPI_PDSCH_CBG_TAG:
1488                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1489                if(encodedVal != RFAILED && encodedVal != 0)
1490                {
1491                   cellParam->pdschCbg = SUPPORTED;
1492                }
1493                else
1494                {
1495                   cellParam->pdschCbg = NOT_SUPPORTED;
1496                }
1497                break;
1498
1499             case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
1500                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1501                if(encodedVal != RFAILED)
1502                {
1503                   fillPdschDmrsConfigType(encodedVal, &cellParam);
1504                }
1505                break;
1506
1507             case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
1508                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1509                if(encodedVal != RFAILED)
1510                {
1511                   fillPdschDmrsLength(encodedVal, &cellParam);
1512                }
1513                break;
1514
1515             case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
1516                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1517                if(encodedVal != RFAILED)
1518                {
1519                   fillPdschDmrsAddPos(encodedVal, &cellParam);
1520                }
1521                break;
1522
1523             case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
1524                cellParam->maxPdschsTBsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1525                break;
1526
1527             case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
1528                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1529                if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
1530                {
1531                   cellParam->maxNumberMimoLayersPdsch   = encodedVal;
1532                }
1533                break;
1534
1535             case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
1536                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1537                if(encodedVal != RFAILED)
1538                {
1539                   fillModulationOrderDl(encodedVal, &cellParam);
1540                }
1541                break;
1542
1543             case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
1544                cellParam->maxMuMimoUsersDl         = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1545                break;
1546
1547             case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
1548                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1549                if(encodedVal != RFAILED && encodedVal != 0)
1550                {
1551                   cellParam->pdschDataInDmrsSymbols = SUPPORTED;
1552                }
1553                else
1554                {
1555                   cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
1556                }
1557                break;
1558
1559             case FAPI_PREMPTIONSUPPORT_TAG:
1560                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1561                if(encodedVal != RFAILED && encodedVal != 0)
1562                {
1563                   cellParam->premptionSupport = SUPPORTED;
1564                }
1565                else
1566                {
1567                   cellParam->premptionSupport = NOT_SUPPORTED;
1568                }
1569                break;
1570
1571             case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
1572                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1573                if(encodedVal != RFAILED && encodedVal != 0)
1574                {
1575                   cellParam->pdschNonSlotSupport = SUPPORTED;
1576                }
1577                else
1578                {
1579                   cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
1580                }
1581                break;
1582
1583             case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
1584                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1585                if(encodedVal != RFAILED && encodedVal != 0)
1586                {
1587                   cellParam->uciMuxUlschInPusch = SUPPORTED;
1588                }
1589                else
1590                {
1591                   cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
1592                }
1593                break;
1594
1595             case FAPI_UCI_ONLY_PUSCH_TAG:
1596                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1597                if(encodedVal != RFAILED && encodedVal != 0)
1598                {
1599                   cellParam->uciOnlyPusch = SUPPORTED;
1600                }
1601                else
1602                {
1603                   cellParam->uciOnlyPusch = NOT_SUPPORTED;
1604                }
1605                break;
1606
1607             case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
1608                encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1609                if(encodedVal != RFAILED && encodedVal != 0)
1610                {
1611                   cellParam->puschFrequencyHopping = SUPPORTED;
1612                }
1613                else
1614                {
1615                   cellParam->puschFrequencyHopping = NOT_SUPPORTED;
1616                }
1617                break;
1618
1619            case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
1620               encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1621               if(encodedVal != RFAILED)
1622               {
1623                  fillPuschDmrsConfig(encodedVal, &cellParam);
1624               }
1625               break;
1626
1627            case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
1628               encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1629               if(encodedVal != RFAILED)
1630               {
1631                  fillPuschDmrsLength(encodedVal, &cellParam);
1632               }
1633               break;
1634
1635            case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
1636               encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1637               if(encodedVal != RFAILED)
1638               {
1639                  fillPuschDmrsAddPos(encodedVal, &cellParam);
1640               }
1641               break;
1642
1643            case FAPI_PUSCH_CBG_TAG:
1644               encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1645               if(encodedVal != RFAILED && encodedVal != 0)
1646               {
1647                  cellParam->puschCbg = SUPPORTED;
1648               }
1649               else
1650               {
1651                  cellParam->puschCbg = NOT_SUPPORTED;
1652               }
1653               break;
1654
1655           case FAPI_PUSCH_MAPPING_TYPE_TAG:
1656              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1657              if(encodedVal != RFAILED)
1658              {
1659                 fillPuschMappingType(encodedVal, &cellParam);
1660              }
1661              break;
1662
1663           case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
1664              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1665              if(encodedVal != RFAILED)
1666              {
1667                 fillPuschAllocationType(encodedVal, &cellParam);
1668              }
1669              break;
1670
1671           case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
1672              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1673              if(encodedVal != RFAILED)
1674              {
1675                 fillPuschPrbMappingType(encodedVal, &cellParam);
1676              }
1677              break;
1678
1679           case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
1680              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1681              if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
1682              {
1683                 cellParam->puschMaxPtrsPorts = encodedVal;
1684              }
1685              break;
1686
1687           case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
1688              cellParam->maxPduschsTBsPerSlot = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1689              break;
1690
1691           case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
1692              cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1693              break;
1694
1695           case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
1696              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1697              if(encodedVal != RFAILED)
1698              {
1699                 fillModulationOrderUl(encodedVal, &cellParam);
1700              }
1701              break;
1702
1703           case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
1704              cellParam->maxMuMimoUsersUl = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1705              break;
1706
1707           case FAPI_DFTS_OFDM_SUPPORT_TAG:
1708              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1709              if(encodedVal != RFAILED && encodedVal != 0)
1710              {
1711                 cellParam->dftsOfdmSupport = SUPPORTED;
1712              }
1713              else
1714              {
1715                 cellParam->dftsOfdmSupport = NOT_SUPPORTED;
1716              }
1717              break;
1718
1719           case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
1720              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1721              if(encodedVal != RFAILED)
1722              {
1723                 fillPuschAggregationFactor(encodedVal, &cellParam);
1724              }
1725              break;
1726
1727           case FAPI_PRACH_LONG_FORMATS_TAG:
1728              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1729              if(encodedVal != RFAILED)
1730              {
1731                 fillPrachLongFormat(encodedVal, &cellParam);
1732              }
1733              break;
1734
1735           case FAPI_PRACH_SHORT_FORMATS_TAG:
1736              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1737              if(encodedVal != RFAILED)
1738              {
1739                 fillPrachShortFormat(encodedVal, &cellParam);
1740              }
1741              break;
1742
1743           case FAPI_PRACH_RESTRICTED_SETS_TAG:
1744              encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1745              if(encodedVal != RFAILED && encodedVal != 0)
1746              {
1747                 cellParam->prachRestrictedSets = SUPPORTED;
1748              }
1749              else
1750              {
1751                 cellParam->prachRestrictedSets = NOT_SUPPORTED;
1752              }
1753              break;
1754
1755          case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
1756             encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1757             if(encodedVal != RFAILED)
1758             {
1759                fillFdOccasions(encodedVal, &cellParam);
1760             }
1761             break;
1762
1763          case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
1764             encodedVal = getParamValue(&paramRsp->tlvs[index], FAPI_UINT_8);
1765             if(encodedVal != RFAILED)
1766             {
1767                fillRssiMeas(encodedVal, &cellParam);
1768             }
1769             break;
1770
1771          default:
1772             printf("\n Invalid value for TLV[%d]", paramRsp->tlvs[index].tl.tag);
1773             break;
1774       }
1775     }
1776   }
1777   else
1778   {
1779     printf("\n Error Indication Evnt received in state[%d] event[%d]", clGlobalCp.phyState, clGlobalCp.event);
1780     RETVALUE(RFAILED);
1781   }
1782   RETVALUE(ROK);
1783 }
1784
1785  /*******************************************************************
1786   *
1787   * @brief Sends FAPI Config req to PHY
1788   *
1789   * @details
1790   *
1791   *    Function : lwr_mac_handleConfigReqEvt
1792   *
1793   *    Functionality:
1794   *         -Sends FAPI Config Req to PHY
1795   *
1796   * @params[in]
1797   * @return ROK     - success
1798   *         RFAILED - failure
1799   *
1800   * ****************************************************************/
1801
1802 S16 lwr_mac_handleConfigReqEvt(void *msg)
1803 {
1804    RETVALUE(ROK);
1805 }
1806
1807 S16 lwr_mac_handleConfigRspEvt(fapi_config_resp_t *configRsp)
1808 {
1809    RETVALUE(ROK);
1810 }
1811
1812 S16 lwr_mac_handleStartReqEvt(void *msg)
1813 {
1814   /*fapi_slot_ind_t *slotInd;
1815   slotInd->header.message_type_id = FAPI_SLOT_INDICATION;
1816   slotInd->sfn = 0;
1817   slotInd->slot = 1;
1818   phyToMac(slotInd->header.message_type_id, sizeof(fapi_slot_ind_t), (void *)slotInd);
1819   */
1820   RETVALUE(ROK);
1821 }
1822
1823 S16 lwr_mac_handleStopReqEvt(void *msg)
1824 {
1825    /* stop TX and RX operation return PHy to configured State
1826       send stop.indication to l2/l3 */
1827    RETVALUE(ROK);
1828 }
1829
1830 lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
1831 {
1832    {
1833       /* PHY_STATE_IDLE */
1834        lwr_mac_handleParamReqEvt,
1835        lwr_mac_handleParamRspEvt,
1836        lwr_mac_handleConfigReqEvt,
1837        lwr_mac_handleConfigRspEvt,
1838        lwr_mac_handleInvalidEvt,
1839        lwr_mac_handleInvalidEvt
1840    },
1841    {
1842        /* PHY_STATE_CONFIGURED */
1843        lwr_mac_handleParamReqEvt,
1844        lwr_mac_handleParamRspEvt,
1845        lwr_mac_handleConfigReqEvt,
1846        lwr_mac_handleConfigRspEvt,
1847        lwr_mac_handleStartReqEvt,
1848        lwr_mac_handleInvalidEvt
1849    },
1850    {
1851        /* PHY_STATE_RUNNING */
1852        lwr_mac_handleInvalidEvt,
1853        lwr_mac_handleInvalidEvt,
1854        lwr_mac_handleConfigReqEvt,
1855        lwr_mac_handleConfigRspEvt,
1856        lwr_mac_handleInvalidEvt,
1857        lwr_mac_handleStopReqEvt
1858    }
1859 };
1860
1861 /*******************************************************************
1862  *
1863  * @brief Sends message to Lower Mac Fsm Event Handler
1864  *
1865  * @details
1866  *
1867  *    Function : sendToLowerMac
1868  *
1869  *    Functionality:
1870  *         -Sends message to LowerMac
1871  *
1872  * @params[in] Message Type
1873  *             Message Length
1874  *             Messaga Pointer
1875  *
1876  * @return void
1877  *
1878 ******************************************************************/
1879 S16 sendToLowerMac(U16 msgType, U32 msgLen, void *msg)
1880 {
1881    clGlobalCp.event = msgType;
1882    fapiEvtHdlr[clGlobalCp.phyState][msgType](msg);
1883 }
1884
1885 /**********************************************************************
1886          End of file
1887 **********************************************************************/