X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Flwr_mac_handle_phy.c;h=a8f251ca235247e6c83aecdb726c8e2ef08aa334;hb=de6a435729e3cad9d4a66329080b8206a64f452c;hp=736aca2edc32accc3030dac92bcbc0e0282d6d3a;hpb=db0a2ee4edd328449d01ab184d253327fca950d6;p=o-du%2Fl2.git diff --git a/src/5gnrmac/lwr_mac_handle_phy.c b/src/5gnrmac/lwr_mac_handle_phy.c index 736aca2ed..a8f251ca2 100644 --- a/src/5gnrmac/lwr_mac_handle_phy.c +++ b/src/5gnrmac/lwr_mac_handle_phy.c @@ -17,47 +17,36 @@ *******************************************************************************/ /* header include files (.h) */ -#include "envopt.h" /* environment options */ -#include "envdep.h" /* environment dependent */ -#include "envind.h" /* environment independent */ -#include "gen.h" /* general */ -#include "ssi.h" /* system services */ -#include "cm_tkns.h" /* Common Token Defines */ -#include "cm_llist.h" /* Common Link List Defines */ -#include "cm_hash.h" /* Common Hash List Defines */ -#include "cm_lte.h" /* Common LTE Defines */ -#include "cm_mblk.h" /* Common LTE Defines */ -#include "tfu.h" /* RGU Interface defines */ -#ifdef FAPI -#include "fapi.h" +#include "common_def.h" +#include "lrg.h" +#ifdef INTEL_FAPI +#include "nr5g_fapi_internal.h" +#include "fapi_vendor_extension.h" #endif /* header/extern include files (.x) */ -#include "gen.x" /* general */ -#include "ssi.x" /* system services */ -#include "cm_tkns.x" /* Common Token Definitions */ -#include "cm_llist.x" /* Common Link List Definitions */ -#include "cm_lib.x" /* Common Library Definitions */ -#include "cm_hash.x" /* Common Hash List Definitions */ -#include "cm_lte.x" /* Common LTE Defines */ -#include "cm_mblk.x" /* Common LTE Defines */ -#include "tfu.x" /* RGU Interface includes */ -#include "du_log.h" +#include "lrg.x" +#include "du_app_mac_inf.h" +#include "mac_sch_interface.h" +#include "lwr_mac.h" #include "lwr_mac_fsm.h" #include "lwr_mac_phy.h" #include "lwr_mac_upr_inf.h" +#include "mac.h" +#include "mac_utils.h" +#include "lwr_mac_utils.h" -#ifdef FAPI +#ifdef INTEL_FAPI /* Function pointer for slot indication from lower mac to mac */ -packSlotIndMsg packSlotIndOpts[] = +SlotIndFunc sendSlotIndOpts[] = { - packLcSlotInd, /* packing for loosely coupled */ + packSlotInd, /* packing for loosely coupled */ fapiMacSlotInd, /* packing for tightly coupled */ - packLwlcSlotInd /* packing for light weight loosly coupled */ + packSlotInd /* packing for light weight loosly coupled */ }; /* Function pointer for rach indication from lower mac to mac */ -packRachIndMsg sendRachIndOpts[] = +RachIndFunc sendRachIndOpts[] = { packRachInd, fapiMacRachInd, @@ -65,7 +54,7 @@ packRachIndMsg sendRachIndOpts[] = }; /* Function pointer for crc indication from lower mac to mac */ -packCrcIndMsg sendCrcIndOpts[] = +CrcIndFunc sendCrcIndOpts[] = { packCrcInd, fapiMacCrcInd, @@ -73,87 +62,106 @@ packCrcIndMsg sendCrcIndOpts[] = }; /* Function pointer for Rx Data indication from lower mac to mac */ -packRxDataIndMsg sendRxDataIndOpts[] = +RxDataIndFunc sendRxDataIndOpts[] = { packRxDataInd, fapiMacRxDataInd, packRxDataInd }; - + +/* Function pointer for stop indication from lower mac to mac */ +StopIndFunc sendStopIndOpts[] = +{ + packStopInd, + fapiMacStopInd, + packStopInd +}; + +/* Function pointer for Uci indication from lower mac to mac */ +UciIndFunc sendUciIndOpts[] = +{ + packUciInd, + FapiMacUciInd, + packUciInd +}; /******************************************************************* * - * @brief Fills post structure + * @brief Processes Slot Indication from PHY and sends to MAC * * @details * - * Function : fillLwrMacToMacPst + * Function : procSlotInd * * Functionality: - * Fills post structure used to send message from lower MAC - * to MAC + * Processes Slot Indication from PHY and sends to MAC * - * @params[in] Pst pointer + * @params[in] fapi_slot_ind_t pointer * @return ROK - success * RFAILED - failure * * ****************************************************************/ -void fillLwrMacToMacPst(Pst *pst) +uint8_t procSlotInd(fapi_slot_ind_t *fapiSlotInd) { - pst->srcProcId = 0; - pst->dstProcId = 0; - pst->srcEnt = ENTTF; - pst->dstEnt = ENTRG; - pst->srcInst = 0; - pst->dstInst = 0; - pst->region = 0; - pst->pool = 0; - pst->selector = MAC_SELECTOR_TC; + /* fill Pst structure to send to lwr_mac to MAC */ + Pst pst; + uint16_t ret = 0; + SlotTimingInfo *slotInd = {0}; + + MAC_ALLOC_SHRABL_BUF(slotInd, sizeof(SlotTimingInfo)); + if(slotInd) + { + slotInd->cellId = lwrMacCb.cellCb[0].cellId; + slotInd->sfn = fapiSlotInd->sfn; + slotInd->slot = fapiSlotInd->slot; + FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_SLOT_IND_TO_MAC); + pst.selector = ODU_SELECTOR_LWLC; + ret = (*sendSlotIndOpts[pst.selector])(&pst, slotInd); + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed in procSlotInd"); + ret = RFAILED; + } + return ret; } /******************************************************************* * - * @brief Processes Slot Indication from PHY and sends to MAC + * @brief Handles stop indication recived from PHY * * @details * - * Function : handleSlotInd + * Function : procStopInd * * Functionality: - * Processes Slot Indication from PHY and sends to MAC + * Handles Stop Indication received from PHY * - * @params[in] fapi_slot_ind_t pointer * @return ROK - success * RFAILED - failure * * ****************************************************************/ -U16 handleSlotInd(fapi_slot_ind_t *fapiSlotInd) +uint8_t procStopInd() { - /* fill Pst structure to send to lwr_mac to MAC */ Pst pst; - uint16_t ret; - SlotIndInfo slotInd; + uint16_t *cellId = NULLP; - fillLwrMacToMacPst(&pst); - pst.event = EVENT_SLOT_IND_TO_MAC; - - slotInd.sfn = fapiSlotInd->sfn; - slotInd.slot = fapiSlotInd->slot; - - ret = (*packSlotIndOpts[pst.selector])(&pst, &slotInd); - -#ifdef INTEL_WLS - slotIndIdx++; - if(slotIndIdx > WLS_MEM_FREE_PRD) + MAC_ALLOC_SHRABL_BUF(cellId, sizeof(uint16_t)); + if(!cellId) { - slotIndIdx = 1; + DU_LOG("\nERROR --> LWR_MAC: Memory Allocation failed in procStopInd"); + return RFAILED; } - freeWlsBlockList(slotIndIdx - 1); -#endif - return ret; -} + *cellId = lwrMacCb.cellCb[0].cellId; + lwrMacCb.phyState = PHY_STATE_CONFIGURED; + lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED; + DU_LOG("\nINFO --> LWR_MAC: PHY has moved to configured state"); + FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_STOP_IND_TO_MAC); + pst.selector = ODU_SELECTOR_LWLC; + return (*sendStopIndOpts[pst.selector])(&pst, cellId); +} /******************************************************************* * @@ -161,7 +169,7 @@ U16 handleSlotInd(fapi_slot_ind_t *fapiSlotInd) * * @details * - * Function : handleRachInd + * Function : procRachInd * * Functionality: * Processes Rach Indication from PHY and sends to MAC @@ -171,39 +179,50 @@ U16 handleSlotInd(fapi_slot_ind_t *fapiSlotInd) * RFAILED - failure * * ****************************************************************/ -uint8_t handleRachInd(fapi_rach_indication_t *fapiRachInd) +uint8_t procRachInd(fapi_rach_indication_t *fapiRachInd) { Pst pst; uint8_t pduIdx; uint8_t prmbleIdx; - RachPduInfo *rachPdu; - RachInd rachInd; + RachPduInfo *rachPdu = NULLP; + RachInd *rachInd = NULLP; - rachInd.timingInfo.sfn = fapiRachInd->sfn; - rachInd.timingInfo.slot = fapiRachInd->slot; - rachInd.numPdu = fapiRachInd->numPdus; - for(pduIdx=0; pduIdx < rachInd.numPdu; pduIdx++) + if(!fapiRachInd->numPdus) { - rachPdu = &rachInd.rachPdu[pduIdx]; - rachPdu->pci = fapiRachInd->rachPdu[pduIdx].physCellId; + DU_LOG("\nDEBUG --> LWR_MAC : No PDU in RACH.indication at [%d, %d]", fapiRachInd->sfn, fapiRachInd->slot); + return ROK; + } + + MAC_ALLOC_SHRABL_BUF(rachInd, sizeof(RachInd)); + if(!rachInd) + { + DU_LOG("\nERROR --> LWR_MAC : Memory Allocation failed in procRachInd"); + return RFAILED; + } + rachInd->cellId = lwrMacCb.cellCb[0].cellId; + rachInd->timingInfo.sfn = fapiRachInd->sfn; + rachInd->timingInfo.slot = fapiRachInd->slot; + rachInd->numPdu = fapiRachInd->numPdus; + for(pduIdx=0; pduIdx < rachInd->numPdu; pduIdx++) + { + rachPdu = &rachInd->rachPdu[pduIdx]; + rachPdu->pci = fapiRachInd->rachPdu[pduIdx].phyCellId; rachPdu->symbolIdx = fapiRachInd->rachPdu[pduIdx].symbolIndex; rachPdu->slotIdx = fapiRachInd->rachPdu[pduIdx].slotIndex; rachPdu->freqIdx = fapiRachInd->rachPdu[pduIdx].freqIndex; rachPdu->numPream = fapiRachInd->rachPdu[pduIdx].numPreamble; for(prmbleIdx=0; prmbleIdxnumPream; prmbleIdx++) { - rachPdu->preamInfo[prmbleIdx].preamIdx = \ - fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].preambleIndex; - rachPdu->preamInfo[prmbleIdx].timingAdv = \ - fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].timingAdvance; + rachPdu->preamInfo[prmbleIdx].preamIdx = \ + fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].preambleIndex; + rachPdu->preamInfo[prmbleIdx].timingAdv = \ + fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].timingAdvance; } } - fillLwrMacToMacPst(&pst); - pst.event = EVENT_RACH_IND_TO_MAC; - - (*sendRachIndOpts[pst.selector])(&pst, &rachInd); - return ROK; + /* Fill post and sent to MAC */ + FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RACH_IND_TO_MAC); + return (*sendRachIndOpts[pst.selector])(&pst, rachInd); }/* handleRachInd */ /******************************************************************* @@ -212,7 +231,7 @@ uint8_t handleRachInd(fapi_rach_indication_t *fapiRachInd) * * @details * - * Function : handleCrcInd + * Function : procCrcInd * * Functionality: * Handles CRC indication from PHY and sends to MAC @@ -223,21 +242,34 @@ uint8_t handleRachInd(fapi_rach_indication_t *fapiRachInd) * * ****************************************************************/ -uint8_t handleCrcInd(fapi_crc_ind_t *fapiCrcInd) +uint8_t procCrcInd(fapi_crc_ind_t *fapiCrcInd) { Pst pst; uint8_t crcInfoIdx; uint8_t crcStatusIdx; - CrcInfo *crcIndInfo; - CrcInd crcInd; + CrcInfo *crcIndInfo = NULLP; + CrcInd *crcInd = NULLP; + + MAC_ALLOC_SHRABL_BUF(crcInd, sizeof(CrcInd)); + if(!crcInd) + { + DU_LOG("\nERROR --> LWR_MAC : Memory Allocation failed in procCrcInd"); + return RFAILED; + } + if(!fapiCrcInd->numCrcs) + { + DU_LOG("\nDEBUG --> LWR_MAC : No CRC PDUs in CRC.indication at [%d, %d]", fapiCrcInd->sfn, fapiCrcInd->slot); + return ROK; + } - crcInd.timingInfo.sfn = fapiCrcInd->sfn; - crcInd.timingInfo.slot = fapiCrcInd->slot; - crcInd.numCrc = fapiCrcInd->numCrcs; + crcInd->cellId = lwrMacCb.cellCb[0].cellId; + crcInd->timingInfo.sfn = fapiCrcInd->sfn; + crcInd->timingInfo.slot = fapiCrcInd->slot; + crcInd->numCrc = fapiCrcInd->numCrcs; - for(crcInfoIdx = 0; crcInfoIdx < crcInd.numCrc; crcInfoIdx++) + for(crcInfoIdx = 0; crcInfoIdx < crcInd->numCrc; crcInfoIdx++) { - crcIndInfo = &crcInd.crcInfo[crcInfoIdx]; + crcIndInfo = &crcInd->crcInfo[crcInfoIdx]; crcIndInfo->handle = fapiCrcInd->crc[crcInfoIdx].handle; crcIndInfo->rnti = fapiCrcInd->crc[crcInfoIdx].rnti; crcIndInfo->harqId = fapiCrcInd->crc[crcInfoIdx].harqId; @@ -245,20 +277,17 @@ uint8_t handleCrcInd(fapi_crc_ind_t *fapiCrcInd) crcIndInfo->numCb = fapiCrcInd->crc[crcInfoIdx].numCb; for(crcStatusIdx = 0; crcStatusIdx < crcIndInfo->numCb; crcStatusIdx++) { - crcIndInfo->cbCrcStatus[crcStatusIdx] = \ - fapiCrcInd->crc[crcInfoIdx].cbCrcStatus[crcStatusIdx]; + crcIndInfo->cbCrcStatus[crcStatusIdx] = \ + fapiCrcInd->crc[crcInfoIdx].cbCrcStatus[crcStatusIdx]; } crcIndInfo->ul_cqi = fapiCrcInd->crc[crcInfoIdx].ul_cqi; crcIndInfo->timingAdvance = fapiCrcInd->crc[crcInfoIdx].timingAdvance; crcIndInfo->rssi = fapiCrcInd->crc[crcInfoIdx].rssi; } - fillLwrMacToMacPst(&pst); - pst.event = EVENT_CRC_IND_TO_MAC; - - (*sendCrcIndOpts[pst.selector])(&pst, &crcInd); - return ROK; - + /* Fill post and sent to MAC */ + FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_CRC_IND_TO_MAC); + return (*sendCrcIndOpts[pst.selector])(&pst, crcInd); } /* handleCrcInd */ /******************************************************************* @@ -267,7 +296,7 @@ uint8_t handleCrcInd(fapi_crc_ind_t *fapiCrcInd) * * @details * - * Function : handleRxDataInd + * Function : procRxDataInd * * Functionality: * Handles Rx Data indication from PHY and sends to MAC @@ -277,109 +306,342 @@ uint8_t handleCrcInd(fapi_crc_ind_t *fapiCrcInd) * RFAILED - failure * * ****************************************************************/ - -uint8_t handleRxDataInd(fapi_rx_data_indication_t *fapiRxDataInd) + +uint8_t procRxDataInd(fapi_rx_data_indication_t *fapiRxDataInd) { Pst pst; - uint8_t pduIdx; - RxDataInd rxDataInd; - RxDataIndPdu *pdu; + uint8_t pduIdx =0; + RxDataInd *rxDataInd = NULLP; + RxDataIndPdu *pdu = NULLP; - rxDataInd.timingInfo.sfn = fapiRxDataInd->sfn; - rxDataInd.timingInfo.slot = fapiRxDataInd->slot; - rxDataInd.numPdus = fapiRxDataInd->numPdus; + MAC_ALLOC_SHRABL_BUF(rxDataInd, sizeof(RxDataInd)); + if(!rxDataInd) + { + DU_LOG("\nERROR --> LWR_MAC : Memory Allocation failed in procRxDataInd"); + return RFAILED; + } + if(!fapiRxDataInd->numPdus) + { + DU_LOG("\nDEBUG --> LWR_MAC : No PDU in RX_Data.indication at [%d, %d]", fapiRxDataInd->sfn, fapiRxDataInd->slot); + return ROK; + } + + rxDataInd->cellId = lwrMacCb.cellCb[0].cellId; + rxDataInd->timingInfo.sfn = fapiRxDataInd->sfn; + rxDataInd->timingInfo.slot = fapiRxDataInd->slot; + rxDataInd->numPdus = fapiRxDataInd->numPdus; - for(pduIdx = 0; pduIdx < rxDataInd.numPdus; pduIdx++) + for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++) { - pdu = &rxDataInd.pdus[pduIdx]; + pdu = &rxDataInd->pdus[pduIdx]; pdu->handle = fapiRxDataInd->pdus[pduIdx].handle; pdu->rnti = fapiRxDataInd->pdus[pduIdx].rnti; pdu->harqId = fapiRxDataInd->pdus[pduIdx].harqId; - pdu->pduLength = fapiRxDataInd->pdus[pduIdx].pduLength; + pdu->pduLength = fapiRxDataInd->pdus[pduIdx].pdu_length; pdu->ul_cqi = fapiRxDataInd->pdus[pduIdx].ul_cqi; pdu->timingAdvance = fapiRxDataInd->pdus[pduIdx].timingAdvance; pdu->rssi = fapiRxDataInd->pdus[pduIdx].rssi; - /* TODO : Copy pdu from FAPI msg to MAC structure*/ - //pdu->pduData; + + MAC_ALLOC_SHRABL_BUF(pdu->pduData, pdu->pduLength); + memcpy(pdu->pduData, fapiRxDataInd->pdus[pduIdx].pduData, pdu->pduLength); +#ifdef INTEL_WLS_MEM + /* Free WLS memory allocated for Rx PDU */ + WLS_MEM_FREE(fapiRxDataInd->pdus[pduIdx].pduData, LWR_MAC_WLS_BUF_SIZE); +#endif } - fillLwrMacToMacPst(&pst); - pst.event = EVENT_RX_DATA_IND_TO_MAC; - - (*sendRxDataIndOpts[pst.selector])(&pst, &rxDataInd); - return ROK; + /* Fill post and sent to MAC */ + FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RX_DATA_IND_TO_MAC); + return (*sendRxDataIndOpts[pst.selector])(&pst, rxDataInd); } -#endif /* FAPI */ - -void handlePhyMessages(uint16_t msgType, uint32_t msgSize, void *msg) +/******************************************************************* + * + * @brief Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1 + * + * @details + * + * Function : fillUciIndPucchF0F1 + * + * Functionality: + * Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1 + * + *@params[in] UciPucchF0F1 * + * fapi_uci_o_pucch_f0f1_t * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t fillUciIndPucchF0F1(UciPucchF0F1 *pduInfo, fapi_uci_o_pucch_f0f1_t *fapiPduInfo) { -#ifdef FAPI - /* extract the header */ - fapi_msg_t *header; - header = (fapi_msg_t *)msg; - switch(header->message_type_id) + uint8_t harqIdx; + uint8_t ret = ROK; + + pduInfo->handle = fapiPduInfo->handle; + pduInfo->pduBitmap = fapiPduInfo->pduBitmap; + pduInfo->pucchFormat = fapiPduInfo->pucchFormat; + pduInfo->ul_cqi = fapiPduInfo->ul_cqi; + pduInfo->crnti = fapiPduInfo->rnti; + pduInfo->timingAdvance = fapiPduInfo->timingAdvance; + pduInfo->rssi = fapiPduInfo->rssi; + if(fapiPduInfo->srInfo.srIndication) { - case FAPI_PARAM_RESPONSE: - case FAPI_CONFIG_RESPONSE: + pduInfo->srInfo.srIndPres = fapiPduInfo->srInfo.srIndication; + pduInfo->srInfo.srConfdcLevel = fapiPduInfo->srInfo.srConfidenceLevel; + } + if(fapiPduInfo->harqInfo.numHarq) + { + pduInfo->harqInfo.numHarq = fapiPduInfo->harqInfo.numHarq; + pduInfo->harqInfo.harqConfdcLevel = fapiPduInfo->harqInfo.harqConfidenceLevel; + for(harqIdx = 0; harqIdx < pduInfo->harqInfo.numHarq; harqIdx++) { - sendToLowerMac(msgType, msgSize, msg); - break; + pduInfo->harqInfo.harqValue[harqIdx] = fapiPduInfo->harqInfo.harqValue[harqIdx]; } - case FAPI_SLOT_INDICATION: + } + return ret; +} + +/******************************************************************* + * + * @brief Handles Uci indication from PHY and sends to MAC + * + * @details + * + * Function : procUciInd + * + * Functionality: + * Handles Uci indication from PHY and sends to MAC + * + * @params[in] fapi_uci_indication_t message pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t procUciInd(fapi_uci_indication_t *fapiUciInd) +{ + uint8_t pduIdx; + uint8_t ret = ROK; + Pst pst; + UciInd *macUciInd = NULLP; + + MAC_ALLOC_SHRABL_BUF(macUciInd, sizeof(UciInd)); + if(!macUciInd) + { + DU_LOG("\nERROR --> LWR_MAC: Memory Allocation failed in procUciInd"); + return RFAILED; + } + + DU_LOG("\nDEBUG --> LWR_MAC: Processing UCI Indication"); + memset(macUciInd, 0, sizeof(UciInd)); + macUciInd->cellId = lwrMacCb.cellCb[0].cellId; + macUciInd->slotInd.sfn = fapiUciInd->sfn; + macUciInd->slotInd.slot = fapiUciInd->slot; + macUciInd->numUcis = fapiUciInd->numUcis; + + for(pduIdx = 0; pduIdx < macUciInd->numUcis; pduIdx++) + { + macUciInd->pdus[pduIdx].pduType = fapiUciInd->uciPdu[pduIdx].pduType; + switch(macUciInd->pdus[pduIdx].pduType) { - if(clGlobalCp.phyState == PHY_STATE_CONFIGURED) + case UCI_IND_PUSCH: + break; + case UCI_IND_PUCCH_F0F1: { - DU_LOG("\nLWR_MAC: PHY has moved to running state"); - clGlobalCp.phyState = PHY_STATE_RUNNING; + UciPucchF0F1 *pduInfo = NULLP; + macUciInd->pdus[pduIdx].pduSize = fapiUciInd->uciPdu[pduIdx].pduSize; + pduInfo = &macUciInd->pdus[pduIdx].uci.uciPucchF0F1; + ret = fillUciIndPucchF0F1(pduInfo, &fapiUciInd->uciPdu[pduIdx].uci.uciPucchF0F1); } - - fapi_slot_ind_t *slotInd; - slotInd = (fapi_slot_ind_t *)msg; - handleSlotInd(slotInd); break; + case UCI_IND_PUCCH_F2F3F4: + break; + default: + DU_LOG("\nERROR --> LWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType); + ret = RFAILED; + break; } + } + if(!ret) + { + FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_UCI_IND_TO_MAC); + ret = (*sendUciIndOpts[pst.selector])(&pst, macUciInd); + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Failed sending UCI Ind to MAC"); + } + return ret; +} +#endif /* FAPI */ + +/******************************************************************* + * @brief Function prints src, dest, msg infor about all the msgs that + received. + * + * @details + * + * Function :callFlowFromPhyToLwrMac + * + * Function call Flow From Phy To LwrMac + * + * @param[in] Pst *pst, Post structure of the primitive. + * + * @return void + * ****************************************************************/ +void callFlowFromPhyToLwrMac(uint16_t msgId) +{ + char message[100]; + switch(msgId) + { +#ifdef INTEL_TIMER_MODE + case FAPI_VENDOR_EXT_UL_IQ_SAMPLES: + strcpy(message,"FAPI_VENDOR_EXT_UL_IQ_SAMPLES"); + break; +#endif + case FAPI_PARAM_RESPONSE: + strcpy(message,"FAPI_PARAM_RESPONSE"); + break; + case FAPI_CONFIG_RESPONSE: + strcpy(message,"FAPI_CONFIG_RESPONSE"); + break; + case FAPI_SLOT_INDICATION: + strcpy(message,"FAPI_SLOT_INDICATION"); + break; case FAPI_ERROR_INDICATION: - { + strcpy(message,"FAPI_ERROR_INDICATION"); break; - } case FAPI_RX_DATA_INDICATION: - { - fapi_rx_data_indication_t *rxDataInd; - rxDataInd = (fapi_rx_data_indication_t *)msg; - handleRxDataInd(rxDataInd); + strcpy(message,"FAPI_RX_DATA_INDICATION"); break; - } case FAPI_CRC_INDICATION: - { - fapi_crc_ind_t *crcInd; - crcInd = (fapi_crc_ind_t *)msg; - handleCrcInd(crcInd); + strcpy(message,"FAPI_CRC_INDICATION"); break; - } case FAPI_UCI_INDICATION: - { + strcpy(message,"FAPI_UCI_INDICATION"); break; - } case FAPI_SRS_INDICATION: - { + strcpy(message,"FAPI_SRS_INDICATION"); break; - } case FAPI_RACH_INDICATION: - { - fapi_rach_indication_t *rachInd; - rachInd = (fapi_rach_indication_t *)msg; - handleRachInd(rachInd); + strcpy(message,"FAPI_RACH_INDICATION"); + break; + case FAPI_STOP_INDICATION: + strcpy(message,"FAPI_STOP_INDICATION"); break; - } } -#ifdef INTEL_WLS - WLS_MEM_FREE(msg, LWR_MAC_WLS_BUF_SIZE); + DU_LOG("\nCall Flow: PHY -> ENTLWRMAC : %s\n",message); +} + +/******************************************************************* + * + * @brief Processes message from PHY + * + * @details + * + * Function : procPhyMessages + * + * Functionality: Processes message from PHY + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg) +{ +#ifdef INTEL_FAPI + /* extract the header */ + fapi_msg_t *header = NULLP; + header = (fapi_msg_t *)msg; + +#ifdef CALL_FLOW_DEBUG_LOG + callFlowFromPhyToLwrMac(header->msg_id); +#endif + + switch(header->msg_id) + { +#ifdef INTEL_TIMER_MODE + case FAPI_VENDOR_EXT_UL_IQ_SAMPLES: + { + DU_LOG("\nDEBUG --> LWR_MAC: Received FAPI_VENDOR_EXT_UL_IQ_SAMPLES"); + //send config req + uint16_t cellId = 1; + sendToLowerMac(CONFIG_REQUEST, 0, (void *)&cellId); + break; + } #endif + case FAPI_PARAM_RESPONSE: + { + sendToLowerMac(PARAM_RESPONSE, msgSize, msg); + break; + } + case FAPI_CONFIG_RESPONSE: + { + sendToLowerMac(CONFIG_RESPONSE, msgSize, msg); + break; + } + case FAPI_SLOT_INDICATION: + { + if(lwrMacCb.phyState == PHY_STATE_CONFIGURED) + { + DU_LOG("\nINFO --> LWR_MAC: PHY has moved to running state"); + lwrMacCb.phyState = PHY_STATE_RUNNING; + lwrMacCb.cellCb[0].state = PHY_STATE_RUNNING; + } + + fapi_slot_ind_t *slotInd = NULLP; + slotInd = (fapi_slot_ind_t *)msg; + procSlotInd(slotInd); + break; + } + case FAPI_ERROR_INDICATION: + { + break; + } + case FAPI_RX_DATA_INDICATION: + { + fapi_rx_data_indication_t *rxDataInd; + rxDataInd = (fapi_rx_data_indication_t *)msg; + procRxDataInd(rxDataInd); + break; + } + case FAPI_CRC_INDICATION: + { + fapi_crc_ind_t *crcInd; + crcInd = (fapi_crc_ind_t *)msg; + procCrcInd(crcInd); + break; + } + case FAPI_UCI_INDICATION: + { + fapi_uci_indication_t *phyUciInd = NULLP; + phyUciInd = (fapi_uci_indication_t*)msg; + procUciInd(phyUciInd); + break; + } + case FAPI_SRS_INDICATION: + { + break; + } + case FAPI_RACH_INDICATION: + { + fapi_rach_indication_t *rachInd; + rachInd = (fapi_rach_indication_t *)msg; + procRachInd(rachInd); + break; + } + case FAPI_STOP_INDICATION: + { + DU_LOG("\nINFO --> LWR_MAC: Handling Stop Indication"); + procStopInd(); + break; + } + } #endif } /********************************************************************** - End of file -**********************************************************************/ + End of file + **********************************************************************/