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 "fapi.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;
 109    SlotIndInfo *slotInd;
 110
 111    MAC_ALLOC_SHRABL_BUF(slotInd, sizeof(SlotIndInfo));
 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       ret = (*sendSlotIndOpts[pst.selector])(&pst, slotInd);
 120    }
 121    else
 122    {
 123       printf("\nLWR_MAC: Memory allocation failed in procSlotInd");
 124       ret = RFAILED;
 125    }
 126
 127 #ifdef INTEL_WLS_MEM
 128    slotIndIdx++;
 129    if(slotIndIdx > WLS_MEM_FREE_PRD)
 130    {
 131       slotIndIdx = 1;
 132    }
 133    freeWlsBlockList(slotIndIdx - 1);
 134 #endif
 135    return ret;
 136 }
 137
 138 /*******************************************************************
 139  *
 140  * @brief Handles stop indication recived from PHY
 141  *
 142  * @details
 143  *
 144  *    Function : procStopInd
 145  *
 146  *    Functionality:
 147  *         Handles Stop Indication received from PHY
 148  *
 149  * @return ROK     - success
 150  *         RFAILED - failure
 151  *
 152  * ****************************************************************/
 153 uint8_t procStopInd()
 154 {
 155    Pst pst;
 156    uint16_t *cellId = NULLP;
 157
 158    MAC_ALLOC_SHRABL_BUF(cellId, sizeof(uint16_t));
 159    if(!cellId)
 160    {
 161       printf("\nLWR_MAC: Memory Allocation failed in procStopInd");
 162       return RFAILED;
 163    }
 164
 165    *cellId = lwrMacCb.cellCb[0].cellId;
 166    lwrMacCb.phyState = PHY_STATE_CONFIGURED;
 167    lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
 168    DU_LOG("\nLWR_MAC: PHY has moved to configured state");
 169
 170    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_STOP_IND_TO_MAC);
 171    return (*sendStopIndOpts[pst.selector])(&pst, cellId);
 172 }
 173
 174 /*******************************************************************
 175  *
 176  * @brief Processes Rach Indication from PHY and sends to MAC
 177  *
 178  * @details
 179  *
 180  *    Function : procRachInd
 181  *
 182  *    Functionality:
 183  *         Processes Rach Indication from PHY and sends to MAC
 184  *
 185  * @params[in] fapi_rach_indication_t pointer
 186  * @return ROK     - success
 187  *         RFAILED - failure
 188  *
 189  * ****************************************************************/
 190 uint8_t procRachInd(fapi_rach_indication_t  *fapiRachInd)
 191 {
 192    Pst          pst;
 193    uint8_t      pduIdx;
 194    uint8_t      prmbleIdx;
 195    RachPduInfo  *rachPdu = NULLP;
 196    RachInd      *rachInd = NULLP;
 197
 198    MAC_ALLOC_SHRABL_BUF(rachInd, sizeof(RachInd));
 199    if(!rachInd)
 200    {
 201       printf("\nLWR_MAC: Memory Allocation failed in procRachInd");
 202       return RFAILED;
 203    }
 204
 205    rachInd->cellId = lwrMacCb.cellCb[0].cellId;
 206    rachInd->timingInfo.sfn = fapiRachInd->sfn;
 207    rachInd->timingInfo.slot = fapiRachInd->slot;
 208    rachInd->numPdu = fapiRachInd->numPdus;
 209    for(pduIdx=0; pduIdx < rachInd->numPdu; pduIdx++)
 210    {
 211       rachPdu = &rachInd->rachPdu[pduIdx];
 212       rachPdu->pci = fapiRachInd->rachPdu[pduIdx].phyCellId;
 213       rachPdu->symbolIdx = fapiRachInd->rachPdu[pduIdx].symbolIndex;
 214       rachPdu->slotIdx = fapiRachInd->rachPdu[pduIdx].slotIndex;
 215       rachPdu->freqIdx = fapiRachInd->rachPdu[pduIdx].freqIndex;
 216       rachPdu->numPream = fapiRachInd->rachPdu[pduIdx].numPreamble;
 217       for(prmbleIdx=0; prmbleIdx<rachPdu->numPream; prmbleIdx++)
 218       {
 219          rachPdu->preamInfo[prmbleIdx].preamIdx = \
 220             fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].preambleIndex;
 221          rachPdu->preamInfo[prmbleIdx].timingAdv = \
 222             fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].timingAdvance;
 223       }
 224    }
 225
 226    /* Fill post and sent to MAC */
 227    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RACH_IND_TO_MAC);
 228    return (*sendRachIndOpts[pst.selector])(&pst, rachInd);
 229
 230 }/* handleRachInd */
 231
 232 /*******************************************************************
 233  *
 234  * @brief Handles CRC indication from PHY and sends to MAC
 235  *
 236  * @details
 237  *
 238  *    Function : procCrcInd
 239  *
 240  *    Functionality:
 241  *      Handles CRC indication from PHY and sends to MAC
 242  *
 243  * @params[in] fapi_crc_ind_t message pointer
 244  * @return ROK     - success
 245  *         RFAILED - failure
 246  *
 247  * ****************************************************************/
 248
 249 uint8_t procCrcInd(fapi_crc_ind_t  *fapiCrcInd)
 250 {
 251    Pst          pst;
 252    uint8_t      crcInfoIdx;
 253    uint8_t      crcStatusIdx;
 254    CrcInfo      *crcIndInfo = NULLP;
 255    CrcInd       *crcInd = NULLP;
 256
 257    MAC_ALLOC_SHRABL_BUF(crcInd, sizeof(CrcInd));
 258    if(!crcInd)
 259    {
 260       printf("\nLWR_MAC: Memory Allocation failed in procCrcInd");
 261       return RFAILED;
 262    }
 263
 264    crcInd->cellId = lwrMacCb.cellCb[0].cellId;
 265    crcInd->timingInfo.sfn = fapiCrcInd->sfn;
 266    crcInd->timingInfo.slot = fapiCrcInd->slot;
 267    crcInd->numCrc = fapiCrcInd->numCrcs;
 268
 269    for(crcInfoIdx = 0; crcInfoIdx < crcInd->numCrc; crcInfoIdx++)
 270    {
 271       crcIndInfo = &crcInd->crcInfo[crcInfoIdx];
 272       crcIndInfo->handle      = fapiCrcInd->crc[crcInfoIdx].handle;
 273       crcIndInfo->rnti        = fapiCrcInd->crc[crcInfoIdx].rnti;
 274       crcIndInfo->harqId      = fapiCrcInd->crc[crcInfoIdx].harqId;
 275       crcIndInfo->tbCrcStatus = fapiCrcInd->crc[crcInfoIdx].tbCrcStatus;
 276       crcIndInfo->numCb       = fapiCrcInd->crc[crcInfoIdx].numCb;
 277       for(crcStatusIdx = 0; crcStatusIdx < crcIndInfo->numCb; crcStatusIdx++)
 278       {
 279          crcIndInfo->cbCrcStatus[crcStatusIdx] = \
 280             fapiCrcInd->crc[crcInfoIdx].cbCrcStatus[crcStatusIdx];
 281       }
 282       crcIndInfo->ul_cqi  = fapiCrcInd->crc[crcInfoIdx].ul_cqi;
 283       crcIndInfo->timingAdvance = fapiCrcInd->crc[crcInfoIdx].timingAdvance;
 284       crcIndInfo->rssi = fapiCrcInd->crc[crcInfoIdx].rssi;
 285    }
 286
 287    /* Fill post and sent to MAC */
 288    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_CRC_IND_TO_MAC);
 289    return (*sendCrcIndOpts[pst.selector])(&pst, crcInd);
 290 } /* handleCrcInd */
 291
 292 /*******************************************************************
 293  *
 294  * @brief Handles Rx Data indication from PHY and sends to MAC
 295  *
 296  * @details
 297  *
 298  *    Function : procRxDataInd
 299  *
 300  *    Functionality:
 301  *      Handles Rx Data indication from PHY and sends to MAC
 302  *
 303  * @params[in] fapi_rx_data_indication_t message pointer
 304  * @return ROK     - success
 305  *         RFAILED - failure
 306  *
 307  * ****************************************************************/
 308
 309 uint8_t procRxDataInd(fapi_rx_data_indication_t  *fapiRxDataInd)
 310 {
 311    Pst           pst;
 312    uint8_t       pduIdx;
 313    RxDataInd     *rxDataInd = NULLP;
 314    RxDataIndPdu  *pdu = NULLP;
 315
 316    MAC_ALLOC_SHRABL_BUF(rxDataInd, sizeof(RxDataInd));
 317    if(!rxDataInd)
 318    {
 319       printf("\nLWR_MAC: Memory Allocation failed in procRxDataInd");
 320       return RFAILED;
 321    }
 322
 323    rxDataInd->cellId = lwrMacCb.cellCb[0].cellId;
 324    rxDataInd->timingInfo.sfn = fapiRxDataInd->sfn;
 325    rxDataInd->timingInfo.slot = fapiRxDataInd->slot;
 326    rxDataInd->numPdus = fapiRxDataInd->numPdus;
 327
 328    for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++)
 329    {
 330       pdu = &rxDataInd->pdus[pduIdx];
 331       pdu->handle = fapiRxDataInd->pdus[pduIdx].handle;
 332       pdu->rnti = fapiRxDataInd->pdus[pduIdx].rnti;
 333       pdu->harqId = fapiRxDataInd->pdus[pduIdx].harqId;
 334       pdu->pduLength = fapiRxDataInd->pdus[pduIdx].pdu_length;
 335       pdu->ul_cqi = fapiRxDataInd->pdus[pduIdx].ul_cqi;
 336       pdu->timingAdvance = fapiRxDataInd->pdus[pduIdx].timingAdvance;
 337       pdu->rssi = fapiRxDataInd->pdus[pduIdx].rssi;
 338
 339       MAC_ALLOC_SHRABL_BUF(pdu->pduData, pdu->pduLength);
 340       memcpy(pdu->pduData, fapiRxDataInd->pdus[pduIdx].pduData, pdu->pduLength);
 341    }
 342
 343    /* Fill post and sent to MAC */
 344    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RX_DATA_IND_TO_MAC);
 345    return (*sendRxDataIndOpts[pst.selector])(&pst, rxDataInd);
 346 }
 347
 348 /*******************************************************************
 349  *
 350  * @brief Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
 351  *
 352  * @details
 353  *
 354  *    Function : fillUciIndPucchF0F1
 355  *
 356  *    Functionality:
 357  *       Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
 358  *
 359  *@params[in] UciPucchF0F1 *
 360  *            fapi_uci_o_pucch_f0f1_t *
 361  * @return ROK     - success
 362  *         RFAILED - failure
 363  *
 364  * ****************************************************************/
 365 uint8_t fillUciIndPucchF0F1(UciPucchF0F1 *pduInfo, fapi_uci_o_pucch_f0f1_t *fapiPduInfo)
 366 {
 367
 368    uint8_t harqIdx;
 369    uint8_t ret = ROK;
 370
 371    pduInfo->handle        = fapiPduInfo->handle;
 372    pduInfo->pduBitmap     = fapiPduInfo->pduBitmap;
 373    pduInfo->pucchFormat   = fapiPduInfo->pucchFormat;
 374    pduInfo->ul_cqi        = fapiPduInfo->ul_cqi;
 375    pduInfo->crnti         = fapiPduInfo->rnti;
 376    pduInfo->timingAdvance = fapiPduInfo->timingAdvance;
 377    pduInfo->rssi          = fapiPduInfo->rssi;
 378    if(fapiPduInfo->srInfo.srIndication)
 379    {
 380       pduInfo->srInfo.srIndPres = fapiPduInfo->srInfo.srIndication;
 381       pduInfo->srInfo.srConfdcLevel = fapiPduInfo->srInfo.srConfidenceLevel;
 382    }
 383    if(fapiPduInfo->harqInfo.numHarq)
 384    {
 385       pduInfo->harqInfo.numHarq = fapiPduInfo->harqInfo.numHarq;
 386       pduInfo->harqInfo.harqConfdcLevel = fapiPduInfo->harqInfo.harqConfidenceLevel;
 387       for(harqIdx = 0; harqIdx < pduInfo->harqInfo.numHarq; harqIdx++)
 388       {
 389          pduInfo->harqInfo.harqValue[harqIdx] = fapiPduInfo->harqInfo.harqValue[harqIdx];
 390       }
 391    }
 392    return ret;
 393 }
 394
 395 /*******************************************************************
 396  *
 397  * @brief Handles Uci indication from PHY and sends to MAC
 398  *
 399  * @details
 400  *
 401  *    Function : procUciInd
 402  *
 403  *    Functionality:
 404  *      Handles Uci indication from PHY and sends to MAC
 405  *
 406  * @params[in] fapi_uci_indication_t message pointer
 407  * @return ROK     - success
 408  *         RFAILED - failure
 409  *
 410  * ****************************************************************/
 411
 412 uint8_t procUciInd(fapi_uci_indication_t  *fapiUciInd)
 413 {
 414    uint8_t pduIdx;
 415    uint8_t ret = ROK;
 416    Pst     pst;
 417    UciInd  *macUciInd = NULLP;
 418
 419    MAC_ALLOC_SHRABL_BUF(macUciInd, sizeof(UciInd));
 420    if(!macUciInd)
 421    {
 422       printf("\nLWR_MAC: Memory Allocation failed in procUciInd");
 423       return RFAILED;
 424    }
 425
 426    memset(macUciInd, 0, sizeof(UciInd));
 427    macUciInd->cellId = lwrMacCb.cellCb[0].cellId;
 428    macUciInd->slotInd.sfn = fapiUciInd->sfn;
 429    macUciInd->slotInd.slot = fapiUciInd->slot;
 430    macUciInd->numUcis = fapiUciInd->numUcis;
 431
 432    for(pduIdx = 0; pduIdx < macUciInd->numUcis; pduIdx++)
 433    {
 434       macUciInd->pdus[pduIdx].pduType = fapiUciInd->uciPdu[pduIdx].pduType;
 435       switch(macUciInd->pdus[pduIdx].pduType)
 436       {
 437          case UCI_IND_PUSCH:
 438          break;
 439          case UCI_IND_PUCCH_F0F1:
 440          {
 441             UciPucchF0F1 *pduInfo = NULLP;
 442             macUciInd->pdus[pduIdx].pduSize = fapiUciInd->uciPdu[pduIdx].pduSize;
 443             pduInfo = &macUciInd->pdus[pduIdx].uci.uciPucchF0F1;
 444             ret = fillUciIndPucchF0F1(pduInfo, &fapiUciInd->uciPdu[pduIdx].uci.uciPucchF0F1);
 445          }
 446          break;
 447          case UCI_IND_PUCCH_F2F3F4:
 448             break;
 449          default:
 450             DU_LOG("\nLWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType);
 451             ret = RFAILED;
 452             break;
 453       }
 454    }
 455    if(!ret)
 456    {
 457       FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_UCI_IND_TO_MAC);
 458       ret = (*sendUciIndOpts[pst.selector])(&pst, macUciInd);
 459    }
 460    else
 461    {
 462       DU_LOG("\nLWR_MAC: Failed sending UCI Ind to MAC");
 463    }
 464    return ret;
 465 }
 466 #endif /* FAPI */
 467
 468 /*******************************************************************
 469  *
 470  * @brief Processes message from PHY
 471  *
 472  * @details
 473  *
 474  *    Function : procPhyMessages
 475  *
 476  *    Functionality: Processes message from PHY
 477  *
 478  * @params[in]
 479  * @return ROK     - success
 480  *         RFAILED - failure
 481  *
 482  * ****************************************************************/
 483 void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg)
 484 {
 485 #ifdef INTEL_FAPI
 486    /* extract the header */
 487    fapi_msg_t *header;
 488    header = (fapi_msg_t *)msg;
 489
 490    switch(header->msg_id)
 491    {
 492       case FAPI_PARAM_RESPONSE:
 493          {
 494             sendToLowerMac(PARAM_RESPONSE, msgSize, msg);
 495             break;
 496          }
 497       case FAPI_CONFIG_RESPONSE:
 498          {
 499             sendToLowerMac(CONFIG_RESPONSE, msgSize, msg);
 500             break;
 501          }
 502       case FAPI_SLOT_INDICATION:
 503          {
 504             if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
 505             {
 506                DU_LOG("\nLWR_MAC: PHY has moved to running state");
 507                lwrMacCb.phyState = PHY_STATE_RUNNING;
 508                lwrMacCb.cellCb[0].state = PHY_STATE_RUNNING;
 509             }
 510
 511             fapi_slot_ind_t *slotInd;
 512             slotInd  = (fapi_slot_ind_t *)msg;
 513             procSlotInd(slotInd);
 514             break;
 515          }
 516       case FAPI_ERROR_INDICATION:
 517          {
 518             break;
 519          }
 520       case FAPI_RX_DATA_INDICATION:
 521          {
 522             fapi_rx_data_indication_t *rxDataInd;
 523             rxDataInd = (fapi_rx_data_indication_t *)msg;
 524             procRxDataInd(rxDataInd);
 525             break;
 526          }
 527       case FAPI_CRC_INDICATION:
 528          {
 529             fapi_crc_ind_t  *crcInd;
 530             crcInd = (fapi_crc_ind_t *)msg;
 531             procCrcInd(crcInd);
 532             break;
 533          }
 534       case FAPI_UCI_INDICATION:
 535          {
 536             fapi_uci_indication_t *phyUciInd = NULLP;
 537             phyUciInd = (fapi_uci_indication_t*)msg;
 538             procUciInd(phyUciInd);
 539             break;
 540          }
 541       case FAPI_SRS_INDICATION:
 542          {
 543             break;
 544          }
 545       case FAPI_RACH_INDICATION:
 546          {
 547             fapi_rach_indication_t  *rachInd;
 548             rachInd = (fapi_rach_indication_t *)msg;
 549             procRachInd(rachInd);
 550             break;
 551          }
 552       case FAPI_STOP_INDICATION:
 553          {
 554             DU_LOG("\nLWR_MAC: Handling Stop Indication");
 555             procStopInd();
 556             break;
 557          }
 558    }
 559 #endif
 560 }
 561
 562 /**********************************************************************
 563   End of file
 564  **********************************************************************/