X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2F5gnrmac%2Fmac_slot_ind.c;h=a58a1b7097fee85825b072d60ef548a22573db4c;hb=ba2574ac618b40905509604da8d3a2b1b9e39664;hp=bca05f28a0f70d9279261e729d3677094dd62d34;hpb=e4e50f696285e2554d237169091026bf9f1b6257;p=o-du%2Fl2.git diff --git a/src/5gnrmac/mac_slot_ind.c b/src/5gnrmac/mac_slot_ind.c index bca05f28a..a58a1b709 100644 --- a/src/5gnrmac/mac_slot_ind.c +++ b/src/5gnrmac/mac_slot_ind.c @@ -17,31 +17,22 @@ *******************************************************************************/ /* header include files (.h) */ #include "common_def.h" -#include "rgu.h" -#include "tfu.h" /* RGU Interface includes */ #include "lrg.h" -#include "crg.h" /* layer management defines for LTE-MAC */ -#include "rg_sch_inf.h" /* layer management defines for LTE-MAC */ -#include "rg_env.h" -#include "rg.h" - -#include "rgu.x" -#include "tfu.x" /* RGU Interface includes */ #include "lrg.x" -#include "crg.x" /* layer management typedefs for MAC */ -#include "rg_sch_inf.x" /* SCH interface typedefs */ -#include "rg_prg.x" #include "du_app_mac_inf.h" +#include "mac_sch_interface.h" +#include "lwr_mac_upr_inf.h" +#include "rlc_mac_inf.h" #include "mac.h" -#include "du_log.h" -#include "rg.x" #include "mac_upr_inf_api.h" +#include "lwr_mac_fsm.h" +#include "mac_utils.h" /* function pointers for packing slot ind from mac to sch */ MacSchSlotIndFunc macSchSlotIndOpts[] = { packMacSchSlotInd, - macSchSlotInd, + MacSchSlotInd, packMacSchSlotInd }; @@ -56,39 +47,63 @@ MacSchSlotIndFunc macSchSlotIndOpts[] = * * @param[in] Pst *pst * @param[in] DL allocation from scheduler - * @return S16 + * @return * -# ROK * -# RFAILED **/ -int MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) +uint8_t MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) { + uint16_t cellIdx; MacDlSlot *currDlSlot = NULLP; if(dlSchedInfo != NULLP) { - if(dlSchedInfo->isBroadcastPres) - { - currDlSlot = &macCb.macCell->dlSlot[dlSchedInfo->schSlotValue.broadcastTime.slot]; - currDlSlot->dlInfo.isBroadcastPres = true; - memcpy(&currDlSlot->dlInfo.brdcstAlloc, &dlSchedInfo->brdcstAlloc, sizeof(DlBrdcstAlloc)); - } - - if(dlSchedInfo->rarAlloc != NULLP) - { - currDlSlot = &macCb.macCell->dlSlot[dlSchedInfo->schSlotValue.rarTime.slot]; - currDlSlot->dlInfo.rarAlloc = dlSchedInfo->rarAlloc; - - /* MUXing of RAR */ - fillRarPdu(&currDlSlot->dlInfo.rarAlloc->rarInfo); - } - - if(dlSchedInfo->msg4Alloc != NULLP) + GET_CELL_IDX(dlSchedInfo->cellId, cellIdx); + if(dlSchedInfo->isBroadcastPres) + { + currDlSlot = &macCb.macCell[cellIdx]->\ + dlSlot[dlSchedInfo->schSlotValue.broadcastTime.slot]; + currDlSlot->dlInfo.isBroadcastPres = true; + memcpy(&currDlSlot->dlInfo.brdcstAlloc, &dlSchedInfo->brdcstAlloc, sizeof(DlBrdcstAlloc)); + currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg.dci.pdschCfg = \ + &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg; + } + + if(dlSchedInfo->rarAlloc != NULLP) + { + currDlSlot = &macCb.macCell[cellIdx]->\ + dlSlot[dlSchedInfo->schSlotValue.rarTime.slot]; + currDlSlot->dlInfo.rarAlloc = dlSchedInfo->rarAlloc; + + /* MUXing of RAR */ + fillRarPdu(&currDlSlot->dlInfo.rarAlloc->rarInfo); + } + + if(dlSchedInfo->dlMsgAlloc != NULLP) { - Msg4Alloc *msg4Alloc = NULLP; - currDlSlot = &macCb.macCell->dlSlot[dlSchedInfo->schSlotValue.msg4Time.slot]; - currDlSlot->dlInfo.msg4Alloc = dlSchedInfo->msg4Alloc; /* copy msg4 alloc pointer in MAC slot info */ - msg4Alloc = dlSchedInfo->msg4Alloc; - macCb.macCell->macRaCb[0].msg4TbSize = msg4Alloc->msg4PdschCfg.codeword[0].tbSize; + currDlSlot = &macCb.macCell[cellIdx]->\ + dlSlot[dlSchedInfo->schSlotValue.dlMsgTime.slot]; + currDlSlot->dlInfo.dlMsgAlloc = dlSchedInfo->dlMsgAlloc; /* copy msg4 alloc pointer in MAC slot info */ + currDlSlot->dlInfo.cellId = dlSchedInfo->cellId; + + /* Check if the downlink pdu is msg4 */ + if(dlSchedInfo->dlMsgAlloc->dlMsgInfo.isMsg4Pdu) + { + macCb.macCell[cellIdx]->macRaCb[0].msg4TbSize = dlSchedInfo->dlMsgAlloc->dlMsgPdschCfg.codeword[0].tbSize; + } + else + { + memcpy(&currDlSlot->dlInfo.schSlotValue, &dlSchedInfo->schSlotValue, sizeof(SchSlotValue)); + /* Send LC schedule result to RLC */ + sendSchedRptToRlc(currDlSlot->dlInfo, dlSchedInfo->schSlotValue.dlMsgTime); + } + } + + if(dlSchedInfo->ulGrant != NULLP) + { + currDlSlot = &macCb.macCell[cellIdx]->\ + dlSlot[dlSchedInfo->schSlotValue.ulDciTime.slot]; + currDlSlot->dlInfo.ulGrant = dlSchedInfo->ulGrant; } } return ROK; @@ -102,63 +117,68 @@ int MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) * * Forming and filling of Msg4Pdu * - * @param[in] Msg4Alloc *msg4Alloc + * @param[in] DlMsgAlloc *msg4Alloc * @return void **/ -void fillMsg4Pdu(Msg4Alloc *msg4Alloc) +void fillMsg4Pdu(uint16_t cellId, DlMsgAlloc *msg4Alloc) { + uint8_t ueIdx; + uint16_t cellIdx; MacDlData msg4DlData; MacCeInfo macCeData; + GET_CELL_IDX(cellId, cellIdx); + memset(&msg4DlData, 0, sizeof(MacDlData)); memset(&macCeData, 0, sizeof(MacCeInfo)); - - if(macCb.macCell->macRaCb[0].msg4Pdu != NULLP) + + GET_UE_IDX(msg4Alloc->dlMsgInfo.crnti, ueIdx); + ueIdx = ueIdx -1; + if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu != NULLP) { - MAC_ALLOC(msg4DlData.pduInfo[0].dlPdu, \ - macCb.macCell->macRaCb[0].msg4PduLen); - if(msg4DlData.pduInfo[0].dlPdu != NULLP) + MAC_ALLOC(msg4DlData.pduInfo[ueIdx].dlPdu, \ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); + if(msg4DlData.pduInfo[ueIdx].dlPdu != NULLP) { - fillMsg4DlData(&msg4DlData, macCb.macCell->macRaCb[0].msg4Pdu); - fillMacCe(&macCeData, macCb.macCell->macRaCb[0].msg3Pdu); - /* Forming Mux Pdu */ - macCb.macCell->macRaCb[0].msg4TxPdu = NULLP; - MAC_ALLOC(macCb.macCell->macRaCb[0].msg4TxPdu, macCb.macCell->macRaCb[0].msg4TbSize); - if(macCb.macCell->macRaCb[0].msg4TxPdu != NULLP) - { - memset(macCb.macCell->macRaCb[0].msg4TxPdu, 0, macCb.macCell->macRaCb[0].msg4TbSize); - macMuxPdu(&msg4DlData, &macCeData, macCb.macCell->macRaCb[0].msg4TxPdu,\ - macCb.macCell->macRaCb[0].msg4TbSize); - - } - else - { - DU_LOG("\nMAC: Failed allocating memory for msg4TxPdu"); - } - /* Free memory allocated */ - MAC_FREE(msg4DlData.pduInfo[0].dlPdu, macCb.macCell->macRaCb[0].msg4PduLen); + fillMsg4DlData(&msg4DlData, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen,\ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu); + fillMacCe(&macCeData, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg3Pdu); + /* Forming Mux Pdu */ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu = NULLP; + MAC_ALLOC(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, \ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize); + if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu != NULLP) + { + memset(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, 0, \ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize); + macMuxPdu(&msg4DlData, &macCeData, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu,\ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize); + + } + else + { + DU_LOG("\nMAC: Failed allocating memory for msg4TxPdu"); + } + /* Free memory allocated */ + MAC_FREE(msg4DlData.pduInfo[0].dlPdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); } } - + /* storing msg4 Pdu in macDlSlot */ - if(macCb.macCell->macRaCb[0].msg4TxPdu) + if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu) + { + msg4Alloc->dlMsgInfo.dlMsgPduLen = macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize; + MAC_ALLOC(msg4Alloc->dlMsgInfo.dlMsgPdu, msg4Alloc->dlMsgInfo.dlMsgPduLen); + if(msg4Alloc->dlMsgInfo.dlMsgPdu != NULLP) + { + memcpy(msg4Alloc->dlMsgInfo.dlMsgPdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, \ + msg4Alloc->dlMsgInfo.dlMsgPduLen); + } + } + else { - msg4Alloc->msg4Info.msg4PduLen = macCb.macCell->macRaCb[0].msg4TbSize; - MAC_ALLOC(msg4Alloc->msg4Info.msg4Pdu, msg4Alloc->msg4Info.msg4PduLen); - if(msg4Alloc->msg4Info.msg4Pdu != NULLP) - { - memcpy(msg4Alloc->msg4Info.msg4Pdu, macCb.macCell->macRaCb[0].msg4TxPdu, \ - msg4Alloc->msg4Info.msg4PduLen); - } - } - else - { DU_LOG("\nMAC: Failed at macMuxPdu()"); - } - /* TODO: Free all allocated memory, after the usage */ - /* MAC_FREE(macCb.macCell->macRaCb[0].msg4TxPdu, \ - macCb.macCell->macRaCb[0].msg4TbSize); // TODO: To be freed after re-transmission is successful. - MAC_FREE(macCb.macCell->macRaCb[0].msg4Pdu, macCb.macCell->macRaCb[0].msg4PduLen); */ + } } /** @@ -176,16 +196,22 @@ void fillMsg4Pdu(Msg4Alloc *msg4Alloc) void buildAndSendMuxPdu(SlotIndInfo currTimingInfo) { + uint16_t cellIdx; MacDlSlot *currDlSlot = NULLP; SlotIndInfo muxTimingInfo; memset(&muxTimingInfo, 0, sizeof(SlotIndInfo)); - - ADD_DELTA_TO_TIME(currTimingInfo, muxTimingInfo, PHY_DELTA); - currDlSlot = &macCb.macCell->dlSlot[muxTimingInfo.slot]; - if(currDlSlot->dlInfo.msg4Alloc) - { - fillMsg4Pdu(currDlSlot->dlInfo.msg4Alloc); - currDlSlot = NULLP; + + GET_CELL_IDX(currTimingInfo.cellId, cellIdx); + + ADD_DELTA_TO_TIME(currTimingInfo, muxTimingInfo, PHY_DELTA); + currDlSlot = &macCb.macCell[cellIdx]->dlSlot[muxTimingInfo.slot]; + if(currDlSlot->dlInfo.dlMsgAlloc) + { + if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.isMsg4Pdu) + { + fillMsg4Pdu(currTimingInfo.cellId, currDlSlot->dlInfo.dlMsgAlloc); + currDlSlot = NULLP; + } } } @@ -199,7 +225,7 @@ void buildAndSendMuxPdu(SlotIndInfo currTimingInfo) * This API is invoked by MAC to send slot ind to scheduler. * * @param[in] SlotIndInfo *slotInd - * @return S16 + * @return * -# ROK * -# RFAILED **/ @@ -208,71 +234,94 @@ int sendSlotIndMacToSch(SlotIndInfo *slotInd) /* fill Pst structure to send to lwr_mac to MAC */ Pst pst; - fillMacToSchPst(&pst); - pst.event = EVENT_SLOT_IND_TO_SCH; - + FILL_PST_MAC_TO_SCH(pst, EVENT_SLOT_IND_TO_SCH); return(*macSchSlotIndOpts[pst.selector])(&pst,slotInd); } /******************************************************************* * - * @brief Send slot indication to DU APP + * @brief Send cell up indication to DU APP * * @details * - * Function : sendSlotIndMacToDuApp + * Function : sendCellUpIndMacToDuApp * * Functionality: - * Send slot indication to DU APP + * Send cell up indication to DU APP * - * @params[in] Slot indication info + * @params[in] Cell Up indication info * @return ROK - success * RFAILED - failure * * ****************************************************************/ -int sendSlotIndMacToDuApp(SlotIndInfo *slotInd) +int sendCellUpIndMacToDuApp(uint16_t cellId) { Pst pst; uint16_t ret; - SlotInfo *slotInfo; - + OduCellId *oduCellId; + /* Allocate sharable memory */ - MAC_ALLOC_SHRABL_BUF(slotInfo, sizeof(SlotInfo)); - if(!slotInfo) + MAC_ALLOC_SHRABL_BUF(oduCellId, sizeof(OduCellId)); + if(!oduCellId) { - DU_LOG("\nMAC : Slot Indication memory allocation failed"); + DU_LOG("\nMAC : Memory allocation failed for cell up indication"); return RFAILED; - } - - slotInfo->cellId = macCb.macCell->cellId; - slotInfo->sfn = slotInd->sfn; - slotInfo->slot = slotInd->slot; - - /* Fill Pst */ - pst.selector = ODU_SELECTOR_LWLC; - pst.srcEnt = ENTRG; - pst.dstEnt = ENTDUAPP; - pst.dstInst = 0; - pst.srcInst = macCb.macInst; - pst.dstProcId = rgCb[pst.srcInst].rgInit.procId; - pst.srcProcId = rgCb[pst.srcInst].rgInit.procId; - pst.region = MAC_MEM_REGION; - pst.pool = MAC_POOL; - pst.event = EVENT_MAC_SLOT_IND; - pst.route = 0; - pst.prior = 0; - pst.intfVer = 0; - - ret = MacDuAppSlotInd(&pst, slotInfo); - if(ret != ROK) - { - DU_LOG("\nMAC: Failed to send slot indication to DU APP"); - MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, slotInfo, sizeof(SlotInfo)); - } - - return ret; -} /* sendSlotIndMacToDuApp */ + } + oduCellId->cellId = cellId; + /* Fill Pst */ + FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_CELL_UP_IND); + + ret = MacDuAppCellUpInd(&pst, oduCellId); + if(ret != ROK) + { + DU_LOG("\nMAC: Failed to send cell up indication to DU APP"); + MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, oduCellId, sizeof(OduCellId)); + } + + return ret; +} /* sendCellUpIndMacToDuApp */ + +/******************************************************************* + * + * @brief Process slot indication at MAC + * + * @details + * + * Function : macProcSlotInd + * + * Functionality: Process slot indication at MAC + * + * @params[in] Slot indication info + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t macProcSlotInd(SlotIndInfo slotInd) +{ + uint16_t cellIdx = 0; + + GET_CELL_IDX(slotInd.cellId, cellIdx); + + /* Store current time info */ + macCb.macCell[cellIdx]->currTime.cellId = slotInd.cellId; + macCb.macCell[cellIdx]->currTime.slot = slotInd.slot; + macCb.macCell[cellIdx]->currTime.sfn = slotInd.sfn; + + /* Mux Pdu for Msg4 */ + buildAndSendMuxPdu(slotInd); + + /* Trigger for DL TTI REQ */ + fillDlTtiReq(slotInd); + + /* Trigger for UL TTI REQ */ + fillUlTtiReq(slotInd); + + /* Trigger for UL DCI REQ */ + fillUlDciReq(slotInd); + + return ROK; +} /* macProcSlotInd */ /** * @brief Transmission time interval indication from PHY. @@ -286,53 +335,59 @@ int sendSlotIndMacToDuApp(SlotIndInfo *slotInd) * @param[in] Pst *pst * @param[in] SuId suId * @param[in] SlotIndInfo *slotInd - * @return S16 + * @return * -# ROK * -# RFAILED **/ -PUBLIC S16 fapiMacSlotInd -( -Pst *pst, -SlotIndInfo *slotInd -) +uint8_t fapiMacSlotInd(Pst *pst, SlotIndInfo *slotInd) { - S16 ret; - VOLATILE U32 startTime=0; - Inst inst; + uint8_t ret = ROK; + volatile uint32_t startTime=0; +#ifdef ODU_SLOT_IND_DEBUG_LOG DU_LOG("\nMAC : Slot Indication received"); - - inst = pst->dstInst; +#endif /*starting Task*/ - SStartTask(&startTime, PID_MAC_TTI_IND); + ODU_START_TASK(&startTime, PID_MAC_TTI_IND); + gSlotCount++; +/* When testing L2 with Intel-L1, any changes specific to + * timer mode testing must be guarded under INTEL_TIMER_MODE*/ +#ifndef INTEL_TIMER_MODE /* send slot indication to scheduler */ ret = sendSlotIndMacToSch(slotInd); if(ret != ROK) { DU_LOG("\nMAC : Sending of slot ind msg from MAC to SCH failed"); - RETVALUE(ret); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo)); + return ret; } - ret = macProcessSlotInd(inst,*slotInd); + ret = macProcSlotInd(*slotInd); if(ret != ROK) { - DU_LOG("\nMAC : macProcessSlotInd failed"); - RETVALUE(ret); + DU_LOG("\nMAC : macProcSlotInd failed"); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo)); + return ret; } +#endif /* send slot indication to du app */ - ret = sendSlotIndMacToDuApp(slotInd); - if(ret != ROK) + if(gSlotCount == 1) { - DU_LOG("\nMAC :Sending of slot ind msg from MAC to DU APP failed"); - RETVALUE(ret); + ret = sendCellUpIndMacToDuApp(slotInd->cellId); + if(ret != ROK) + { + DU_LOG("\nMAC :Sending of slot ind msg from MAC to DU APP failed"); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo)); + return ret; + } } /*stoping Task*/ - SStopTask(startTime, PID_MAC_TTI_IND); - - RETVALUE(ret); + ODU_STOP_TASK(startTime, PID_MAC_TTI_IND); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo)); + return ret; } /* fapiMacSlotInd */ /**********************************************************************