src/5gnrmac/lwr_mac_handle_phy.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 /* header include files (.h) */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #ifdef INTEL_FAPI
  23 #include "nr5g_fapi_internal.h"
  24 #include "fapi_vendor_extension.h"
  25 #endif
  26
  27 /* header/extern include files (.x) */
  28 #include "lrg.x"
  29 #include "du_app_mac_inf.h"
  30 #include "mac_sch_interface.h"
  31 #include "lwr_mac.h"
  32 #include "lwr_mac_fsm.h"
  33 #include "lwr_mac_phy.h"
  34 #include "lwr_mac_upr_inf.h"
  35 #include "mac.h"
  36 #include "mac_utils.h"
  37 #include "lwr_mac_utils.h"
  38
  39 #ifdef INTEL_FAPI
  40 /* Function pointer for slot indication from lower mac to mac */
  41 SlotIndFunc sendSlotIndOpts[] =
  42 {
  43    packSlotInd,  /* packing for loosely coupled */
  44    fapiMacSlotInd, /* packing for tightly coupled */
  45    packSlotInd /* packing for light weight loosly coupled */
  46 };
  47
  48 /* Function pointer for rach indication from lower mac to mac */
  49 RachIndFunc sendRachIndOpts[] =
  50 {
  51    packRachInd,
  52    fapiMacRachInd,
  53    packRachInd
  54 };
  55
  56 /* Function pointer for crc indication from lower mac to mac */
  57 CrcIndFunc sendCrcIndOpts[] =
  58 {
  59    packCrcInd,
  60    fapiMacCrcInd,
  61    packCrcInd
  62 };
  63
  64 /* Function pointer for Rx Data indication from lower mac to mac */
  65 RxDataIndFunc sendRxDataIndOpts[] =
  66 {
  67    packRxDataInd,
  68    fapiMacRxDataInd,
  69    packRxDataInd
  70 };
  71
  72 /* Function pointer for stop indication from lower mac to mac */
  73 StopIndFunc sendStopIndOpts[] =
  74 {
  75    packStopInd,
  76    fapiMacStopInd,
  77    packStopInd
  78 };
  79
  80 /* Function pointer for Uci indication from lower mac to mac */
  81 UciIndFunc sendUciIndOpts[] =
  82 {
  83    packUciInd,
  84    FapiMacUciInd,
  85    packUciInd
  86 };
  87
  88 /*******************************************************************
  89  *
  90  * @brief Processes Slot Indication from PHY and sends to MAC
  91  *
  92  * @details
  93  *
  94  *    Function : procSlotInd
  95  *
  96  *    Functionality:
  97  *     Processes Slot Indication from PHY and sends to MAC
  98  *
  99  * @params[in] fapi_slot_ind_t pointer
 100  * @return ROK     - success
 101  *         RFAILED - failure
 102  *
 103  * ****************************************************************/
 104 uint8_t procSlotInd(fapi_slot_ind_t *fapiSlotInd)
 105 {
 106    /* fill Pst structure to send to lwr_mac to MAC */
 107    Pst pst;
 108    uint16_t ret = 0;
 109    SlotTimingInfo *slotInd = {0};
 110
 111    MAC_ALLOC_SHRABL_BUF(slotInd, sizeof(SlotTimingInfo));
 112    if(slotInd)
 113    {
 114       slotInd->cellId = lwrMacCb.cellCb[0].cellId;
 115       slotInd->sfn = fapiSlotInd->sfn;
 116       slotInd->slot = fapiSlotInd->slot;
 117
 118       FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_SLOT_IND_TO_MAC);
 119       pst.selector = ODU_SELECTOR_LWLC;
 120       ret = (*sendSlotIndOpts[pst.selector])(&pst, slotInd);
 121    }
 122    else
 123    {
 124       DU_LOG("\nERROR  -->  LWR_MAC: Memory allocation failed in procSlotInd");
 125       ret = RFAILED;
 126    }
 127    return ret;
 128 }
 129
 130 /*******************************************************************
 131  *
 132  * @brief Handles stop indication recived from PHY
 133  *
 134  * @details
 135  *
 136  *    Function : procStopInd
 137  *
 138  *    Functionality:
 139  *         Handles Stop Indication received from PHY
 140  *
 141  * @return ROK     - success
 142  *         RFAILED - failure
 143  *
 144  * ****************************************************************/
 145 uint8_t procStopInd()
 146 {
 147    Pst pst;
 148    uint16_t *cellId = NULLP;
 149
 150    MAC_ALLOC_SHRABL_BUF(cellId, sizeof(uint16_t));
 151    if(!cellId)
 152    {
 153       DU_LOG("\nERROR  -->  LWR_MAC: Memory Allocation failed in procStopInd");
 154       return RFAILED;
 155    }
 156
 157    *cellId = lwrMacCb.cellCb[0].cellId;
 158    lwrMacCb.phyState = PHY_STATE_CONFIGURED;
 159    lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
 160    DU_LOG("\nINFO  -->  LWR_MAC: PHY has moved to configured state");
 161
 162    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_STOP_IND_TO_MAC);
 163    pst.selector = ODU_SELECTOR_LWLC;
 164    return (*sendStopIndOpts[pst.selector])(&pst, cellId);
 165 }
 166
 167 /*******************************************************************
 168  *
 169  * @brief Processes Rach Indication from PHY and sends to MAC
 170  *
 171  * @details
 172  *
 173  *    Function : procRachInd
 174  *
 175  *    Functionality:
 176  *         Processes Rach Indication from PHY and sends to MAC
 177  *
 178  * @params[in] fapi_rach_indication_t pointer
 179  * @return ROK     - success
 180  *         RFAILED - failure
 181  *
 182  * ****************************************************************/
 183 uint8_t procRachInd(fapi_rach_indication_t  *fapiRachInd)
 184 {
 185    Pst          pst;
 186    uint8_t      pduIdx;
 187    uint8_t      prmbleIdx;
 188    RachPduInfo  *rachPdu = NULLP;
 189    RachInd      *rachInd = NULLP;
 190
 191    MAC_ALLOC_SHRABL_BUF(rachInd, sizeof(RachInd));
 192    if(!rachInd)
 193    {
 194       DU_LOG("\nERROR  -->  LWR_MAC : Memory Allocation failed in procRachInd");
 195       return RFAILED;
 196    }
 197    if(!fapiRachInd->numPdus)
 198    {
 199       DU_LOG("\nDEBUG  -->  LWR_MAC : No PDU in RACH.indication at [%d, %d]", fapiRachInd->sfn, fapiRachInd->slot);
 200       return ROK;
 201    }
 202
 203    rachInd->cellId = lwrMacCb.cellCb[0].cellId;
 204    rachInd->timingInfo.sfn = fapiRachInd->sfn;
 205    rachInd->timingInfo.slot = fapiRachInd->slot;
 206    rachInd->numPdu = fapiRachInd->numPdus;
 207    for(pduIdx=0; pduIdx < rachInd->numPdu; pduIdx++)
 208    {
 209       rachPdu = &rachInd->rachPdu[pduIdx];
 210       rachPdu->pci = fapiRachInd->rachPdu[pduIdx].phyCellId;
 211       rachPdu->symbolIdx = fapiRachInd->rachPdu[pduIdx].symbolIndex;
 212       rachPdu->slotIdx = fapiRachInd->rachPdu[pduIdx].slotIndex;
 213       rachPdu->freqIdx = fapiRachInd->rachPdu[pduIdx].freqIndex;
 214       rachPdu->numPream = fapiRachInd->rachPdu[pduIdx].numPreamble;
 215       for(prmbleIdx=0; prmbleIdx<rachPdu->numPream; prmbleIdx++)
 216       {
 217          rachPdu->preamInfo[prmbleIdx].preamIdx = \
 218             fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].preambleIndex;
 219          rachPdu->preamInfo[prmbleIdx].timingAdv = \
 220             fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].timingAdvance;
 221       }
 222    }
 223
 224    /* Fill post and sent to MAC */
 225    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RACH_IND_TO_MAC);
 226    return (*sendRachIndOpts[pst.selector])(&pst, rachInd);
 227 }/* handleRachInd */
 228
 229 /*******************************************************************
 230  *
 231  * @brief Handles CRC indication from PHY and sends to MAC
 232  *
 233  * @details
 234  *
 235  *    Function : procCrcInd
 236  *
 237  *    Functionality:
 238  *      Handles CRC indication from PHY and sends to MAC
 239  *
 240  * @params[in] fapi_crc_ind_t message pointer
 241  * @return ROK     - success
 242  *         RFAILED - failure
 243  *
 244  * ****************************************************************/
 245
 246 uint8_t procCrcInd(fapi_crc_ind_t  *fapiCrcInd)
 247 {
 248    Pst          pst;
 249    uint8_t      crcInfoIdx;
 250    uint8_t      crcStatusIdx;
 251    CrcInfo      *crcIndInfo = NULLP;
 252    CrcInd       *crcInd = NULLP;
 253
 254    MAC_ALLOC_SHRABL_BUF(crcInd, sizeof(CrcInd));
 255    if(!crcInd)
 256    {
 257       DU_LOG("\nERROR  -->  LWR_MAC : Memory Allocation failed in procCrcInd");
 258       return RFAILED;
 259    }
 260    if(!fapiCrcInd->numCrcs)
 261    {
 262       DU_LOG("\nDEBUG  --> LWR_MAC : No CRC PDUs in CRC.indication at [%d, %d]", fapiCrcInd->sfn, fapiCrcInd->slot);
 263       return ROK;
 264    }
 265
 266    crcInd->cellId = lwrMacCb.cellCb[0].cellId;
 267    crcInd->timingInfo.sfn = fapiCrcInd->sfn;
 268    crcInd->timingInfo.slot = fapiCrcInd->slot;
 269    crcInd->numCrc = fapiCrcInd->numCrcs;
 270
 271    for(crcInfoIdx = 0; crcInfoIdx < crcInd->numCrc; crcInfoIdx++)
 272    {
 273       crcIndInfo = &crcInd->crcInfo[crcInfoIdx];
 274       crcIndInfo->handle      = fapiCrcInd->crc[crcInfoIdx].handle;
 275       crcIndInfo->rnti        = fapiCrcInd->crc[crcInfoIdx].rnti;
 276       crcIndInfo->harqId      = fapiCrcInd->crc[crcInfoIdx].harqId;
 277       crcIndInfo->tbCrcStatus = fapiCrcInd->crc[crcInfoIdx].tbCrcStatus;
 278       crcIndInfo->numCb       = fapiCrcInd->crc[crcInfoIdx].numCb;
 279       for(crcStatusIdx = 0; crcStatusIdx < crcIndInfo->numCb; crcStatusIdx++)
 280       {
 281          crcIndInfo->cbCrcStatus[crcStatusIdx] = \
 282             fapiCrcInd->crc[crcInfoIdx].cbCrcStatus[crcStatusIdx];
 283       }
 284       crcIndInfo->ul_cqi  = fapiCrcInd->crc[crcInfoIdx].ul_cqi;
 285       crcIndInfo->timingAdvance = fapiCrcInd->crc[crcInfoIdx].timingAdvance;
 286       crcIndInfo->rssi = fapiCrcInd->crc[crcInfoIdx].rssi;
 287    }
 288
 289    /* Fill post and sent to MAC */
 290    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_CRC_IND_TO_MAC);
 291    return (*sendCrcIndOpts[pst.selector])(&pst, crcInd);
 292 } /* handleCrcInd */
 293
 294 /*******************************************************************
 295  *
 296  * @brief Handles Rx Data indication from PHY and sends to MAC
 297  *
 298  * @details
 299  *
 300  *    Function : procRxDataInd
 301  *
 302  *    Functionality:
 303  *      Handles Rx Data indication from PHY and sends to MAC
 304  *
 305  * @params[in] fapi_rx_data_indication_t message pointer
 306  * @return ROK     - success
 307  *         RFAILED - failure
 308  *
 309  * ****************************************************************/
 310
 311 uint8_t procRxDataInd(fapi_rx_data_indication_t  *fapiRxDataInd)
 312 {
 313    Pst           pst;
 314    uint8_t       pduIdx =0;
 315    RxDataInd     *rxDataInd = NULLP;
 316    RxDataIndPdu  *pdu = NULLP;
 317
 318    MAC_ALLOC_SHRABL_BUF(rxDataInd, sizeof(RxDataInd));
 319    if(!rxDataInd)
 320    {
 321       DU_LOG("\nERROR  -->  LWR_MAC : Memory Allocation failed in procRxDataInd");
 322       return RFAILED;
 323    }
 324    if(!fapiRxDataInd->numPdus)
 325    {
 326       DU_LOG("\nDEBUG  -->  LWR_MAC : No PDU in RX_Data.indication at [%d, %d]", fapiRxDataInd->sfn, fapiRxDataInd->slot);
 327       return ROK;
 328    }
 329
 330    rxDataInd->cellId = lwrMacCb.cellCb[0].cellId;
 331    rxDataInd->timingInfo.sfn = fapiRxDataInd->sfn;
 332    rxDataInd->timingInfo.slot = fapiRxDataInd->slot;
 333    rxDataInd->numPdus = fapiRxDataInd->numPdus;
 334
 335    for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++)
 336    {
 337       pdu = &rxDataInd->pdus[pduIdx];
 338       pdu->handle = fapiRxDataInd->pdus[pduIdx].handle;
 339       pdu->rnti = fapiRxDataInd->pdus[pduIdx].rnti;
 340       pdu->harqId = fapiRxDataInd->pdus[pduIdx].harqId;
 341       pdu->pduLength = fapiRxDataInd->pdus[pduIdx].pdu_length;
 342       pdu->ul_cqi = fapiRxDataInd->pdus[pduIdx].ul_cqi;
 343       pdu->timingAdvance = fapiRxDataInd->pdus[pduIdx].timingAdvance;
 344       pdu->rssi = fapiRxDataInd->pdus[pduIdx].rssi;
 345
 346       MAC_ALLOC_SHRABL_BUF(pdu->pduData, pdu->pduLength);
 347       memcpy(pdu->pduData, fapiRxDataInd->pdus[pduIdx].pduData, pdu->pduLength);
 348 #ifdef INTEL_WLS_MEM
 349       /* Free WLS memory allocated for Rx PDU */
 350       WLS_MEM_FREE(fapiRxDataInd->pdus[pduIdx].pduData, LWR_MAC_WLS_BUF_SIZE);
 351 #endif
 352    }
 353
 354    /* Fill post and sent to MAC */
 355    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RX_DATA_IND_TO_MAC);
 356    return (*sendRxDataIndOpts[pst.selector])(&pst, rxDataInd);
 357 }
 358
 359 /*******************************************************************
 360  *
 361  * @brief Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
 362  *
 363  * @details
 364  *
 365  *    Function : fillUciIndPucchF0F1
 366  *
 367  *    Functionality:
 368  *       Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
 369  *
 370  *@params[in] UciPucchF0F1 *
 371  *            fapi_uci_o_pucch_f0f1_t *
 372  * @return ROK     - success
 373  *         RFAILED - failure
 374  *
 375  * ****************************************************************/
 376 uint8_t fillUciIndPucchF0F1(UciPucchF0F1 *pduInfo, fapi_uci_o_pucch_f0f1_t *fapiPduInfo)
 377 {
 378
 379    uint8_t harqIdx;
 380    uint8_t ret = ROK;
 381
 382    pduInfo->handle        = fapiPduInfo->handle;
 383    pduInfo->pduBitmap     = fapiPduInfo->pduBitmap;
 384    pduInfo->pucchFormat   = fapiPduInfo->pucchFormat;
 385    pduInfo->ul_cqi        = fapiPduInfo->ul_cqi;
 386    pduInfo->crnti         = fapiPduInfo->rnti;
 387    pduInfo->timingAdvance = fapiPduInfo->timingAdvance;
 388    pduInfo->rssi          = fapiPduInfo->rssi;
 389    if(fapiPduInfo->srInfo.srIndication)
 390    {
 391       pduInfo->srInfo.srIndPres = fapiPduInfo->srInfo.srIndication;
 392       pduInfo->srInfo.srConfdcLevel = fapiPduInfo->srInfo.srConfidenceLevel;
 393    }
 394    if(fapiPduInfo->harqInfo.numHarq)
 395    {
 396       pduInfo->harqInfo.numHarq = fapiPduInfo->harqInfo.numHarq;
 397       pduInfo->harqInfo.harqConfdcLevel = fapiPduInfo->harqInfo.harqConfidenceLevel;
 398       for(harqIdx = 0; harqIdx < pduInfo->harqInfo.numHarq; harqIdx++)
 399       {
 400          pduInfo->harqInfo.harqValue[harqIdx] = fapiPduInfo->harqInfo.harqValue[harqIdx];
 401       }
 402    }
 403    return ret;
 404 }
 405
 406 /*******************************************************************
 407  *
 408  * @brief Handles Uci indication from PHY and sends to MAC
 409  *
 410  * @details
 411  *
 412  *    Function : procUciInd
 413  *
 414  *    Functionality:
 415  *      Handles Uci indication from PHY and sends to MAC
 416  *
 417  * @params[in] fapi_uci_indication_t message pointer
 418  * @return ROK     - success
 419  *         RFAILED - failure
 420  *
 421  * ****************************************************************/
 422
 423 uint8_t procUciInd(fapi_uci_indication_t  *fapiUciInd)
 424 {
 425    uint8_t pduIdx;
 426    uint8_t ret = ROK;
 427    Pst     pst;
 428    UciInd  *macUciInd = NULLP;
 429
 430    MAC_ALLOC_SHRABL_BUF(macUciInd, sizeof(UciInd));
 431    if(!macUciInd)
 432    {
 433       DU_LOG("\nERROR  -->  LWR_MAC: Memory Allocation failed in procUciInd");
 434       return RFAILED;
 435    }
 436
 437    DU_LOG("\nDEBUG  -->  LWR_MAC: Processing UCI Indication");
 438    memset(macUciInd, 0, sizeof(UciInd));
 439    macUciInd->cellId = lwrMacCb.cellCb[0].cellId;
 440    macUciInd->slotInd.sfn = fapiUciInd->sfn;
 441    macUciInd->slotInd.slot = fapiUciInd->slot;
 442    macUciInd->numUcis = fapiUciInd->numUcis;
 443
 444    for(pduIdx = 0; pduIdx < macUciInd->numUcis; pduIdx++)
 445    {
 446       macUciInd->pdus[pduIdx].pduType = fapiUciInd->uciPdu[pduIdx].pduType;
 447       switch(macUciInd->pdus[pduIdx].pduType)
 448       {
 449          case UCI_IND_PUSCH:
 450          break;
 451          case UCI_IND_PUCCH_F0F1:
 452          {
 453             UciPucchF0F1 *pduInfo = NULLP;
 454             macUciInd->pdus[pduIdx].pduSize = fapiUciInd->uciPdu[pduIdx].pduSize;
 455             pduInfo = &macUciInd->pdus[pduIdx].uci.uciPucchF0F1;
 456             ret = fillUciIndPucchF0F1(pduInfo, &fapiUciInd->uciPdu[pduIdx].uci.uciPucchF0F1);
 457          }
 458          break;
 459          case UCI_IND_PUCCH_F2F3F4:
 460             break;
 461          default:
 462             DU_LOG("\nERROR  -->  LWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType);
 463             ret = RFAILED;
 464             break;
 465       }
 466    }
 467    if(!ret)
 468    {
 469       FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_UCI_IND_TO_MAC);
 470       ret = (*sendUciIndOpts[pst.selector])(&pst, macUciInd);
 471    }
 472    else
 473    {
 474       DU_LOG("\nERROR  -->  LWR_MAC: Failed sending UCI Ind to MAC");
 475    }
 476    return ret;
 477 }
 478 #endif /* FAPI */
 479
 480 /*******************************************************************
 481  * @brief Function prints src, dest, msg infor about all the msgs that
 482  received.
 483  *
 484  * @details
 485  *
 486  *     Function :callFlowFromPhyToLwrMac
 487  *
 488  *     Function call Flow From Phy To LwrMac
 489  *
 490  *  @param[in]  Pst     *pst, Post structure of the primitive.
 491  *
 492  *  @return  void
 493  * ****************************************************************/
 494 void callFlowFromPhyToLwrMac(uint16_t msgId)
 495 {
 496    char message[100];
 497    switch(msgId)
 498    {
 499 #ifdef INTEL_TIMER_MODE
 500       case FAPI_VENDOR_EXT_UL_IQ_SAMPLES:
 501          strcpy(message,"FAPI_VENDOR_EXT_UL_IQ_SAMPLES");
 502          break;
 503 #endif
 504       case FAPI_PARAM_RESPONSE:
 505          strcpy(message,"FAPI_PARAM_RESPONSE");
 506          break;
 507       case FAPI_CONFIG_RESPONSE:
 508          strcpy(message,"FAPI_CONFIG_RESPONSE");
 509          break;
 510       case FAPI_SLOT_INDICATION:
 511          strcpy(message,"FAPI_SLOT_INDICATION");
 512          break;
 513       case FAPI_ERROR_INDICATION:
 514          strcpy(message,"FAPI_ERROR_INDICATION");
 515          break;
 516       case FAPI_RX_DATA_INDICATION:
 517          strcpy(message,"FAPI_RX_DATA_INDICATION");
 518          break;
 519       case FAPI_CRC_INDICATION:
 520          strcpy(message,"FAPI_CRC_INDICATION");
 521          break;
 522       case FAPI_UCI_INDICATION:
 523          strcpy(message,"FAPI_UCI_INDICATION");
 524          break;
 525       case FAPI_SRS_INDICATION:
 526          strcpy(message,"FAPI_SRS_INDICATION");
 527          break;
 528       case FAPI_RACH_INDICATION:
 529          strcpy(message,"FAPI_RACH_INDICATION");
 530          break;
 531       case FAPI_STOP_INDICATION:
 532          strcpy(message,"FAPI_STOP_INDICATION");
 533          break;
 534    }
 535    DU_LOG("\nCall Flow: PHY -> ENTLWRMAC : %s\n",message);
 536 }
 537 /*******************************************************************
 538  *
 539  * @brief Processes message from PHY
 540  *
 541  * @details
 542  *
 543  *    Function : procPhyMessages
 544  *
 545  *    Functionality: Processes message from PHY
 546  *
 547  * @params[in]
 548  * @return ROK     - success
 549  *         RFAILED - failure
 550  *
 551  * ****************************************************************/
 552 void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg)
 553 {
 554 #ifdef INTEL_FAPI
 555    /* extract the header */
 556    fapi_msg_t *header = NULLP;
 557    header = (fapi_msg_t *)msg;
 558
 559 #ifdef CALL_FLOW_DEBUG_LOG
 560    callFlowFromPhyToLwrMac(header->msg_id);
 561 #endif
 562    switch(header->msg_id)
 563    {
 564 #ifdef INTEL_TIMER_MODE
 565       case FAPI_VENDOR_EXT_UL_IQ_SAMPLES:
 566          {
 567             DU_LOG("\nDEBUG  -->  LWR_MAC: Received FAPI_VENDOR_EXT_UL_IQ_SAMPLES");
 568             //send config req
 569             uint16_t cellId = 1;
 570             sendToLowerMac(CONFIG_REQUEST, 0, (void *)&cellId);
 571             break;
 572          }
 573 #endif
 574       case FAPI_PARAM_RESPONSE:
 575          {
 576             sendToLowerMac(PARAM_RESPONSE, msgSize, msg);
 577             break;
 578          }
 579       case FAPI_CONFIG_RESPONSE:
 580          {
 581             sendToLowerMac(CONFIG_RESPONSE, msgSize, msg);
 582             break;
 583          }
 584       case FAPI_SLOT_INDICATION:
 585          {
 586             if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
 587             {
 588                DU_LOG("\nINFO  -->  LWR_MAC: PHY has moved to running state");
 589                lwrMacCb.phyState = PHY_STATE_RUNNING;
 590                lwrMacCb.cellCb[0].state = PHY_STATE_RUNNING;
 591             }
 592
 593             fapi_slot_ind_t *slotInd = NULLP;
 594             slotInd  = (fapi_slot_ind_t *)msg;
 595             procSlotInd(slotInd);
 596             break;
 597          }
 598       case FAPI_ERROR_INDICATION:
 599          {
 600             break;
 601          }
 602       case FAPI_RX_DATA_INDICATION:
 603          {
 604             fapi_rx_data_indication_t *rxDataInd;
 605             rxDataInd = (fapi_rx_data_indication_t *)msg;
 606             procRxDataInd(rxDataInd);
 607             break;
 608          }
 609       case FAPI_CRC_INDICATION:
 610          {
 611             fapi_crc_ind_t  *crcInd;
 612             crcInd = (fapi_crc_ind_t *)msg;
 613             procCrcInd(crcInd);
 614             break;
 615          }
 616       case FAPI_UCI_INDICATION:
 617          {
 618             fapi_uci_indication_t *phyUciInd = NULLP;
 619             phyUciInd = (fapi_uci_indication_t*)msg;
 620             procUciInd(phyUciInd);
 621             break;
 622          }
 623       case FAPI_SRS_INDICATION:
 624          {
 625             break;
 626          }
 627       case FAPI_RACH_INDICATION:
 628          {
 629             fapi_rach_indication_t  *rachInd;
 630             rachInd = (fapi_rach_indication_t *)msg;
 631             procRachInd(rachInd);
 632             break;
 633          }
 634       case FAPI_STOP_INDICATION:
 635          {
 636             DU_LOG("\nINFO  -->  LWR_MAC: Handling Stop Indication");
 637             procStopInd();
 638             break;
 639          }
 640    }
 641 #endif
 642 }
 643
 644 /**********************************************************************
 645   End of file
 646  **********************************************************************/