src/phy_stub/l1_bdy1.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 /*This file contains stub for PHY to handle messages to/from MAC CL */
  20
  21 #include <stdint.h>
  22
  23 #include "envdep.h"
  24 #include "gen.h"
  25 #include "ssi.h"
  26
  27 #include "gen.x"
  28 #include "ssi.x"
  29
  30 #include "lwr_mac.h"
  31 #include "lwr_mac_phy.h"
  32 #ifdef FAPI
  33 #include "fapi.h"
  34 #endif
  35 #include "lphy_stub.h"
  36 #include "du_log.h"
  37 #include "rg.h"
  38
  39 #define MAX_SLOT_VALUE   9
  40 #define MAX_SFN_VALUE    1023
  41
  42 uint16_t sfnValue = 0;
  43 uint16_t slotValue = 0;
  44 EXTERN void phyToMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg));
  45 #ifdef FAPI
  46 EXTERN void fillTlvs ARGS((fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t
  47 length, uint16_t value, uint32_t *msgLen));
  48 EXTERN void fillMsgHeader ARGS((fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen));
  49 #endif
  50 EXTERN void handlePhyMessages(uint16_t msgType, uint32_t msgSize, void *msg);
  51
  52 /*******************************************************************
  53  *
  54  * @brief Builds and sends param response to MAC CL
  55  *
  56  * @details
  57  *
  58  *    Function : l1BldAndSndParamRsp
  59  *
  60  *    Functionality:
  61  *          - Builds and sends param response to MAC
  62  *
  63  * @params[in] Config request message pointer
  64  * @return ROK     - success
  65  *         RFAILED - failure
  66  *
  67  * ****************************************************************/
  68 S16 l1BldAndSndParamRsp(void *msg)
  69 {
  70 #ifdef FAPI
  71    uint8_t index = 0;
  72    uint32_t msgLen = 0;
  73         fapi_param_resp_t *fapiParamRsp = (fapi_param_resp_t *)msg;
  74
  75   /* Cell Params */
  76   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_RELEASE_CAPABILITY_TAG,                          sizeof(uint16_t), 1, &msgLen);
  77   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PHY_STATE_TAG,                                   sizeof(uint16_t), 0, &msgLen);
  78   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SKIP_BLANK_DL_CONFIG_TAG,                        sizeof(uint8_t),  0, &msgLen);
  79   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SKIP_BLANK_UL_CONFIG_TAG,                        sizeof(uint8_t),  0, &msgLen);
  80   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG,              sizeof(uint8_t),  0, &msgLen);
  81
  82   /* Carrier Params */
  83   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_CYCLIC_PREFIX_TAG,                               sizeof(uint8_t),  1, &msgLen);
  84   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG,             sizeof(uint8_t),  1, &msgLen);
  85   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_BANDWIDTH_DL_TAG,                      sizeof(uint16_t), 1, &msgLen);
  86   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG,             sizeof(uint8_t),  0, &msgLen);
  87   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_BANDWIDTH_UL_TAG,                      sizeof(uint16_t), 0, &msgLen);
  88
  89   /* PDCCH Param*/
  90   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_CCE_MAPPING_TYPE_TAG,                            sizeof(uint8_t), 0, &msgLen);
  91   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG,   sizeof(uint8_t), 0, &msgLen);
  92   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRECODER_GRANULARITY_CORESET_TAG,                sizeof(uint8_t), 0, &msgLen);
  93   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDCCH_MU_MIMO_TAG,                               sizeof(uint8_t), 0, &msgLen);
  94   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDCCH_PRECODER_CYCLING_TAG,                      sizeof(uint8_t), 0, &msgLen);
  95   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PDCCHS_PER_SLOT_TAG,                         sizeof(uint8_t), 0, &msgLen);
  96
  97   /* PUCCH Param */
  98   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUCCH_FORMATS_TAG,                               sizeof(uint8_t), 0, &msgLen);
  99   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PUCCHS_PER_SLOT_TAG,                         sizeof(uint8_t), 0, &msgLen);
 100
 101   /* PDSCH Param */
 102   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_MAPPING_TYPE_TAG,                          sizeof(uint8_t), 0, &msgLen);
 103   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_ALLOCATION_TYPES_TAG,                      sizeof(uint8_t), 0, &msgLen);
 104   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG,                    sizeof(uint8_t), 0, &msgLen);
 105   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_CBG_TAG,                                   sizeof(uint8_t), 0, &msgLen);
 106   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG,                     sizeof(uint8_t), 0, &msgLen);
 107   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DMRS_MAX_LENGTH_TAG,                       sizeof(uint8_t), 0, &msgLen);
 108   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG,                   sizeof(uint8_t), 0, &msgLen);
 109   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG,                     sizeof(uint8_t), 0, &msgLen);
 110   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG,                sizeof(uint8_t), 0, &msgLen);
 111   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG,           sizeof(uint8_t), 0, &msgLen);
 112   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_MU_MIMO_USERS_DL_TAG,                        sizeof(uint8_t), 0, &msgLen);
 113   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG,                  sizeof(uint8_t), 0, &msgLen);
 114   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PREMPTIONSUPPORT_TAG,                            sizeof(uint8_t), 0, &msgLen);
 115   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PDSCH_NON_SLOT_SUPPORT_TAG,                      sizeof(uint8_t), 0, &msgLen);
 116
 117   /* PUSCH Param */
 118   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG,                      sizeof(uint8_t), 0, &msgLen);
 119   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_UCI_ONLY_PUSCH_TAG,                              sizeof(uint8_t), 0, &msgLen);
 120   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_FREQUENCY_HOPPING_TAG,                     sizeof(uint8_t), 0, &msgLen);
 121   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG,                     sizeof(uint8_t), 0, &msgLen);
 122   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_DMRS_MAX_LEN_TAG,                          sizeof(uint8_t), 0, &msgLen);
 123   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG,                   sizeof(uint8_t), 0, &msgLen);
 124   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_CBG_TAG,                                   sizeof(uint8_t), 0, &msgLen);
 125   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_MAPPING_TYPE_TAG,                          sizeof(uint8_t), 0, &msgLen);
 126   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_ALLOCATION_TYPES_TAG,                      sizeof(uint8_t), 0, &msgLen);
 127   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG,                    sizeof(uint8_t), 0, &msgLen);
 128   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_MAX_PTRS_PORTS_TAG,                        sizeof(uint8_t), 0, &msgLen);
 129   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG,                    sizeof(uint8_t), 0, &msgLen);
 130   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG,         sizeof(uint8_t), 0, &msgLen);
 131   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG,               sizeof(uint8_t), 0, &msgLen);
 132   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_MU_MIMO_USERS_UL_TAG,                        sizeof(uint8_t), 0, &msgLen);
 133   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_DFTS_OFDM_SUPPORT_TAG,                           sizeof(uint8_t), 0, &msgLen);
 134   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PUSCH_AGGREGATION_FACTOR_TAG,                    sizeof(uint8_t), 0, &msgLen);
 135
 136   /* PRACH Params */
 137   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRACH_LONG_FORMATS_TAG,                          sizeof(uint8_t), 0, &msgLen);
 138   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRACH_SHORT_FORMATS_TAG,                         sizeof(uint8_t), 0, &msgLen);
 139   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_PRACH_RESTRICTED_SETS_TAG,                       sizeof(uint8_t), 0, &msgLen);
 140   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG,            sizeof(uint8_t), 0, &msgLen);
 141
 142   /* MEASUREMENT TAG */
 143   fillTlvs(&fapiParamRsp->tlvs[index++],  FAPI_RSSI_MEASUREMENT_SUPPORT_TAG,                    sizeof(uint8_t), 0, &msgLen);
 144
 145   fapiParamRsp->number_of_tlvs = index;
 146   msgLen = msgLen + sizeof(fapi_param_resp_t);
 147
 148   fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen);
 149   fapiParamRsp->error_code = MSG_OK;
 150   DU_LOG("\nPHY_STUB: Sending Param Request to Lower Mac");
 151   handlePhyMessages(fapiParamRsp->header.message_type_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp);
 152 #endif
 153   return ROK;
 154 }
 155
 156 /*******************************************************************
 157  *
 158  * @brief Builds and sends config response to lower mac
 159  *
 160  * @details
 161  *
 162  *    Function : l1BldAndSndConfigRsp
 163  *
 164  *    Functionality:
 165  *          - Builds and sends config response to MAC
 166  *
 167  * @params[in] Config request message pointer
 168  * @return ROK     - success
 169  *         RFAILED - failure
 170  *
 171  * ****************************************************************/
 172
 173 S16 l1BldAndSndConfigRsp(void *msg)
 174 {
 175 #ifdef FAPI
 176    uint32_t msgLen = 0;
 177    fapi_config_resp_t *fapiConfigRsp = (fapi_config_resp_t *)msg;
 178
 179    if(fapiConfigRsp != NULL)
 180    {
 181       fapiConfigRsp->number_of_invalid_tlvs = NULLP;
 182       fapiConfigRsp->number_of_inv_tlvs_idle_only = NULLP;
 183       fapiConfigRsp->number_of_missing_tlvs = NULLP;
 184       fapiConfigRsp->error_code = MSG_OK;
 185       msgLen += sizeof(fapi_config_resp_t);
 186       fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen);
 187       DU_LOG("\nPHY_STUB: Sending Config Response to Lower Mac");
 188       handlePhyMessages(fapiConfigRsp->header.message_type_id, sizeof(fapi_config_resp_t), (void *)fapiConfigRsp);
 189       return ROK;
 190    }
 191 #else
 192    return ROK;
 193 #endif
 194 }
 195 /*******************************************************************
 196  *
 197  * @brief Handles param request received from MAC
 198  *
 199  * @details
 200  *
 201  *    Function : l1HdlParamReq
 202  *
 203  *    Functionality:
 204  *          -Handles param request received from MAC
 205  *
 206  * @params[in]   Message length
 207  *               Param request message pointer
 208  *
 209  * @return void
 210  *
 211  * ****************************************************************/
 212
 213 PUBLIC void l1HdlParamReq(uint32_t msgLen, void *msg)
 214 {
 215    DU_LOG("\nPHY_STUB: Received Param Request in PHY");
 216    /* Handling PARAM RESPONSE */
 217    if(l1BldAndSndParamRsp(msg)!= ROK)
 218    {
 219       DU_LOG("\nPHY_STUB: Failed Sending Param Response");
 220    }
 221 }
 222
 223 /*******************************************************************
 224  *
 225  * @brief Handles config request received from MAC
 226  *
 227  * @details
 228  *
 229  *    Function : l1HdlConfigReq
 230  *
 231  *    Functionality:
 232  *          -Handles config request received from MAC
 233  *
 234  * @params[in]   Message length
 235  *               config request message pointer
 236  *
 237  * @return void
 238  *
 239  * ****************************************************************/
 240
 241 PUBLIC void l1HdlConfigReq(uint32_t msgLen, void *msg)
 242 {
 243    DU_LOG("\nPHY_STUB: Received Config Request in PHY");
 244
 245    /* Handling CONFIG RESPONSE */
 246    if(l1BldAndSndConfigRsp(msg)!= ROK)
 247    {
 248       printf("\nPHY_STUB: Failed Sending config Response");
 249    }
 250 }
 251
 252 /*******************************************************************
 253  *
 254  * @brief Builds and Send the Slot Indication message to MAC
 255  *
 256  * @details
 257  *
 258  *    Function : buildAndSendSlotIndication
 259  *
 260  *    Functionality:
 261  *          -Send the Slot indication Message to MAC
 262  *
 263  * @params[in]   Message length
 264  *               config request message pointer
 265  *
 266  * @return void
 267  *
 268  * ****************************************************************/
 269 PUBLIC S16 buildAndSendSlotIndication()
 270 {
 271 #ifdef FAPI
 272    fapi_slot_ind_t *slotIndMsg;
 273    if(SGetSBuf(0, 0, (Data **)&slotIndMsg, sizeof(slotIndMsg)) != ROK)
 274    {
 275        DU_LOG("\nPHY_STUB: Memory allocation failed for slot Indication Message");
 276        return RFAILED;
 277    }
 278    else
 279    {
 280       slotValue++;
 281       if(sfnValue > MAX_SFN_VALUE && slotValue > MAX_SLOT_VALUE)
 282       {
 283          sfnValue = 0;
 284          slotValue = 0;
 285       }
 286       else if(slotValue > MAX_SLOT_VALUE)
 287       {
 288          sfnValue++;
 289          slotValue = 0;
 290       }
 291       slotIndMsg->sfn = sfnValue;
 292       slotIndMsg->slot = slotValue;
 293       fillMsgHeader(&slotIndMsg->header, FAPI_SLOT_INDICATION, sizeof(fapi_slot_ind_t));
 294       DU_LOG("\nPHY_STUB [%d:%d] ",sfnValue,slotValue);
 295       handlePhyMessages(slotIndMsg->header.message_type_id, sizeof(fapi_slot_ind_t), (void*)slotIndMsg);
 296       SPutSBuf(0, 0, (Data *)slotIndMsg, sizeof(slotIndMsg));
 297    }
 298 #endif
 299    return ROK;
 300 }
 301
 302 /*******************************************************************
 303  *
 304  * @brief Handles start request received from MAC
 305  *
 306  * @details
 307  *
 308  *    Function : l1HdlStartReq
 309  *
 310  *    Functionality:
 311  *          -Handles start request received from MAC
 312  *
 313  * @params[in]   Message length
 314  *               config request message pointer
 315  *
 316  * @return void
 317  *
 318  * ****************************************************************/
 319
 320 PUBLIC S16 l1HdlStartReq(uint32_t msgLen, void *msg)
 321 {
 322    if(clGlobalCp.phyState == PHY_STATE_CONFIGURED)
 323    {
 324       duStartSlotIndicaion();
 325 #ifdef FAPI
 326       SPutSBuf(0, 0, (Data *)msg, sizeof(fapi_start_req_t));
 327 #endif
 328       return ROK;
 329    }
 330    else
 331    {
 332       DU_LOG("\n PHY_STUB: Received Start Req in PHY State %d", clGlobalCp.phyState);
 333       return RFAILED;
 334    }
 335 }
 336
 337 /*******************************************************************
 338 *
 339 * @brief Handles Dl Tti request received from MAC
 340 *
 341 * @details
 342 *
 343 *    Function : l1HdlDlTtiReq
 344 *
 345 *    Functionality:
 346 *          -Handles Dl Tti request received from MAC
 347 *
 348 * @params[in]   Message length
 349 *               Dl Tti request message pointer
 350 *
 351 * @return void
 352 *
 353 * ****************************************************************/
 354
 355 PUBLIC S16 l1HdlDlTtiReq(uint16_t msgLen, void *msg)
 356 {
 357 #ifdef FAPI
 358    fapi_dl_tti_req_t *dlTtiReq;
 359    dlTtiReq = (fapi_dl_tti_req_t *)msg;
 360 #if 0
 361    printf("\nPHY_STUB:  Received DL TTI Request in PHY");
 362    printf("\nPHY_STUB:  SFN     %d", dlTtiReq->sfn);
 363    printf("\nPHY_STUB:  SLOT    %d", dlTtiReq->slot);
 364    printf("\nPHY_STUB:  nPdus   %d", dlTtiReq->nPdus);
 365    printf("\nPHY_STUB:  nGroup  %d", dlTtiReq->nGroup);
 366    /* Printing SSB CONFIGURED VALUES */
 367    printf("\nPHY_STUB: physCellId   %d", dlTtiReq->pdus->u.ssb_pdu.physCellId);
 368    printf("\nPHY_STUB: betaPss      %d", dlTtiReq->pdus->u.ssb_pdu.betaPss);
 369    printf("\nPHY_STUB: ssbBlockIndex %d",       dlTtiReq->pdus->u.ssb_pdu.ssbBlockIndex);
 370    printf("\nPHY_STUB: ssbSubCarrierOffset %d", dlTtiReq->pdus->u.ssb_pdu.ssbSubCarrierOffset);
 371    printf("\nPHY_STUB: ssbOffsetPointA     %d", dlTtiReq->pdus->u.ssb_pdu.ssbOffsetPointA);
 372    printf("\nPHY_STUB: bchPayloadFlag      %d", dlTtiReq->pdus->u.ssb_pdu.bchPayloadFlag);
 373    printf("\nPHY_STUB: bchPayload          %x", dlTtiReq->pdus->u.ssb_pdu.bchPayload);
 374 #endif
 375    uint8_t numPdus = dlTtiReq->nPdus;
 376         if(numPdus == 0)
 377         {
 378                 DU_LOG("\nNo PDU \n");
 379    }
 380         while(numPdus)
 381         {
 382                 if(dlTtiReq->pdus->pduType == 3) //SSB_PDU_TYPE
 383                         DU_LOG("\nSSB PDU\n");
 384                 else if(dlTtiReq->pdus->pduType == 0)
 385                         DU_LOG("\nSIB1 PDCCH PDU\n");
 386                 else if(dlTtiReq->pdus->pduType == 1)
 387                    DU_LOG("\nSIB1 PDSCH PDU\n");
 388
 389                 numPdus--;
 390         }
 391    MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
 392 #endif
 393    return ROK;
 394 }
 395
 396 /*******************************************************************
 397 *
 398 * @brief Handles Ul Tti request received from MAC
 399 *
 400 * @details
 401 *
 402 *    Function : l1HdlUlTtiReq
 403 *
 404 *    Functionality:
 405 *          -Handles Ul Tti request received from MAC
 406 *
 407 * @params[in]   Message length
 408 *               Ul Tti request message pointer
 409 *
 410 * @return void
 411 *
 412 * ****************************************************************/
 413
 414 PUBLIC S16 l1HdlUlTtiReq(uint16_t msgLen, void *msg)
 415 {
 416 #ifdef FAPI
 417    fapi_ul_tti_req_t *ulTtiReq;
 418    ulTtiReq = (fapi_ul_tti_req_t *)msg;
 419    uint8_t numPdus = ulTtiReq->nPdus;
 420         if(numPdus == 0)
 421         {
 422                 DU_LOG("\nPHY STUB: No PDU in UL TTI \n");
 423    }
 424         while(numPdus)
 425         {
 426                 if(ulTtiReq->pdus->pduType == 0)
 427                         DU_LOG("\n PHY STUB: PRACH PDU\n");
 428                 numPdus--;
 429         }
 430         MAC_FREE(ulTtiReq, sizeof(fapi_ul_tti_req_t));
 431 #endif
 432    return ROK;
 433 }
 434
 435 /*******************************************************************
 436  *
 437  * @brief Receives message from MAC
 438  *
 439  * @details
 440  *
 441  *    Function : processFapiRequest
 442  *
 443  *    Functionality:
 444  *       - Receives message from MAC and calls handler
 445  *
 446  * @params[in] Message type
 447  *             Message length
 448  *             Message pointer
 449  *
 450  * @return void
 451  *
 452  * ****************************************************************/
 453
 454 void processFapiRequest(uint8_t msgType, uint32_t msgLen, void *msg)
 455 {
 456    switch(msgType)
 457    {
 458 #ifdef FAPI
 459       case FAPI_PARAM_REQUEST:
 460          l1HdlParamReq(msgLen, msg);
 461          break;
 462       case FAPI_CONFIG_REQUEST:
 463          l1HdlConfigReq(msgLen, msg);
 464          break;
 465       case FAPI_START_REQUEST:
 466          l1HdlStartReq(msgLen, msg);
 467          break;
 468       case FAPI_DL_TTI_REQUEST:
 469          l1HdlDlTtiReq(msgLen, msg);
 470          break;
 471       case FAPI_UL_TTI_REQUEST:
 472          l1HdlUlTtiReq(msgLen, msg);
 473          break;
 474       default:
 475          DU_LOG("\nPHY_STUB: Invalid message type[%x] received at PHY", msgType);
 476          break;
 477 #endif
 478    }
 479 }
 480 /**********************************************************************
 481          End of file
 482 **********************************************************************/