X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Fmac_slot_ind.c;h=cbcf1c347d5c7bd8a4ead567c86526475d879bd5;hb=bb267bb17ec2897af706e7307790d3b1e5b3ea8d;hp=78756cfc996c7d1c338d00bc9adaad2c47c38de4;hpb=e6391c742645c17e4494d52f94fdeb66cfc99d1e;p=o-du%2Fl2.git diff --git a/src/5gnrmac/mac_slot_ind.c b/src/5gnrmac/mac_slot_ind.c index 78756cfc9..cbcf1c347 100644 --- a/src/5gnrmac/mac_slot_ind.c +++ b/src/5gnrmac/mac_slot_ind.c @@ -28,14 +28,8 @@ #include "lwr_mac.h" #include "lwr_mac_fsm.h" #include "mac_utils.h" - -/* function pointers for packing slot ind from mac to sch */ -MacSchSlotIndFunc macSchSlotIndOpts[] = -{ - packMacSchSlotInd, - MacSchSlotInd, - packMacSchSlotInd -}; +#include "mac_harq_dl.h" +#include "lwr_mac_phy.h" /** * @brief process DL allocation from scheduler @@ -54,9 +48,14 @@ MacSchSlotIndFunc macSchSlotIndOpts[] = **/ uint8_t MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) { - uint8_t ueIdx; - uint16_t cellIdx; - MacDlSlot *currDlSlot = NULLP; + uint8_t schInfoIdx = 0, cwIdx = 0; + uint8_t ueId = 0, ueIdx = 0; + uint16_t cellIdx = 0; + uint8_t *retxTb = NULLP, *txPdu = NULLP; + uint16_t txPduLen = 0; + MacDlSlot *currDlSlot = NULLP; + DlMsgSchInfo *schedInfo; + DlHarqProcCb *hqProcCb = NULLP; #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_DL_SCH_INFO\n"); @@ -70,8 +69,6 @@ uint8_t MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) 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; } for(ueIdx=0; ueIdxdlInfo.rarAlloc[ueIdx]->rarInfo); } - } - - if(dlSchedInfo->dlMsgAlloc != NULLP) - { - 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) - { - GET_UE_IDX(dlSchedInfo->dlMsgAlloc->dlMsgInfo.crnti, ueIdx); - ueIdx = ueIdx -1; - macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize = \ - dlSchedInfo->dlMsgAlloc->dlMsgPdschCfg.codeword[0].tbSize; - } - else + if(dlSchedInfo->dlMsgAlloc[ueIdx] != NULLP) { - memcpy(&currDlSlot->dlInfo.schSlotValue, &dlSchedInfo->schSlotValue, sizeof(SchSlotValue)); - /* Send LC schedule result to RLC */ - sendSchedRptToRlc(currDlSlot->dlInfo, dlSchedInfo->schSlotValue.dlMsgTime); + currDlSlot = &macCb.macCell[cellIdx]->\ + dlSlot[dlSchedInfo->schSlotValue.dlMsgTime.slot]; + currDlSlot->dlInfo.dlMsgAlloc[ueIdx] = dlSchedInfo->dlMsgAlloc[ueIdx]; /* copy msg4 alloc pointer in MAC slot info */ + currDlSlot->dlInfo.cellId = dlSchedInfo->cellId; + + if(dlSchedInfo->dlMsgAlloc[ueIdx]->dlMsgPdcchCfg && dlSchedInfo->dlMsgAlloc[ueIdx]->dlMsgPdcchCfg->coresetCfg.coreSetType == CORESET_TYPE0) + { + MAC_ALLOC(macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status, sizeof(bool)); + } + + /* Check if the downlink pdu is msg4 */ + if((macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status)) + { + GET_UE_ID(dlSchedInfo->dlMsgAlloc[ueIdx]->crnti, ueId); + ueIdx = ueId -1; + schedInfo = dlSchedInfo->dlMsgAlloc[ueIdx]; + hqProcCb = &macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4HqInfo; + + if(!dlSchedInfo->dlMsgAlloc[ueIdx]->transportBlock[0].ndi) + { + /* First transmission of MSG4 */ + hqProcCb->procId = schedInfo->harqProcNum; + for(cwIdx = 0; cwIdx < schedInfo->dlMsgPdschCfg->numCodewords; cwIdx++) + { + memcpy(&hqProcCb->tbInfo[hqProcCb->numTb].txTime, &dlSchedInfo->schSlotValue.dlMsgTime, \ + sizeof(SlotTimingInfo)); + hqProcCb->tbInfo[hqProcCb->numTb].tbSize = schedInfo->dlMsgPdschCfg->codeword[cwIdx].tbSize; + hqProcCb->numTb++; + } + } + else + { + /* MSG4 retransmission */ + if(hqProcCb->procId == schedInfo->harqProcNum) + { + memcpy(&hqProcCb->tbInfo[0].txTime, &dlSchedInfo->schSlotValue.dlMsgTime, \ + sizeof(SlotTimingInfo)); + } + } + } + else + { + memcpy(&currDlSlot->dlInfo.schSlotValue, &dlSchedInfo->schSlotValue, sizeof(SchSlotValue)); + + if(!dlSchedInfo->dlMsgAlloc[ueIdx]->transportBlock[0].ndi) + { + /* If new data transmission is scheduled, send schedule results to RLC */ + if(dlSchedInfo->dlMsgAlloc[ueIdx]->dlMsgPdschCfg) + { + sendSchedRptToRlc(currDlSlot->dlInfo, dlSchedInfo->schSlotValue.dlMsgTime, ueIdx, schInfoIdx); + + /* Add HARQ Proc to DL HARQ Proc Entity in UE */ + addDlHqProcInUe(currDlSlot->dlInfo.schSlotValue.dlMsgTime, &macCb.macCell[cellIdx]->ueCb[ueIdx], \ + dlSchedInfo->dlMsgAlloc[ueIdx]); + } + } + else + { + /* For retransmission, fetch PDU to be retransmitted from DL HARQ entity and schedule on corresponding slot */ + + /* As of now this loop will run only once for one TB. + * TODO : update handling of fetched TB appropriately when support for two TB is added + */ + for(cwIdx = 0; cwIdx < dlSchedInfo->dlMsgAlloc[ueIdx]->dlMsgPdschCfg->numCodewords; cwIdx++) + { + /* Fetch TB to be retransmitted */ + txPduLen = dlSchedInfo->dlMsgAlloc[ueIdx]->dlMsgPdschCfg->codeword[cwIdx].tbSize; + retxTb = fetchTbfromDlHarqProc(currDlSlot->dlInfo.schSlotValue.dlMsgTime, \ + &macCb.macCell[cellIdx]->ueCb[ueIdx], \ + dlSchedInfo->dlMsgAlloc[ueIdx]->harqProcNum, txPduLen); + + /* Store PDU in corresponding DL slot */ + MAC_ALLOC(txPdu, txPduLen); + if(!txPdu) + { + DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcDlAlloc"); + return RFAILED; + } + memcpy(txPdu, retxTb, txPduLen); + + currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPduLen = txPduLen; + currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdu = txPdu; + } + } + } } } if(dlSchedInfo->ulGrant != NULLP) { - currDlSlot = &macCb.macCell[cellIdx]->\ - dlSlot[dlSchedInfo->schSlotValue.ulDciTime.slot]; + currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlSchedInfo->schSlotValue.ulDciTime.slot]; currDlSlot->dlInfo.ulGrant = dlSchedInfo->ulGrant; } } @@ -120,7 +182,51 @@ uint8_t MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) } /** - * @brief Forming anf filling the MUX Pdu + * @brief process DL Paging allocation from scheduler + * + * @details + * + * Function : MacProcDlPageAlloc + * + * This function copied dl Pag info in the mac slot info + * + * @param[in] Pst *pst + * @param[in] DL Paging allocation from scheduler + * @return + * -# ROK + * -# RFAILED + **/ +uint8_t MacProcDlPageAlloc(Pst *pst, DlPageAlloc *dlPageAlloc) +{ + uint16_t cellIdx = 0; + MacDlSlot *currDlSlot = NULLP; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_DL_PAGING_ALLOC\n"); +#endif + if(dlPageAlloc != NULLP) + { + GET_CELL_IDX(dlPageAlloc->cellId, cellIdx); + + currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlPageAlloc->dlPageTime.slot]; + MAC_ALLOC(currDlSlot->pageAllocInfo, sizeof(DlPageAlloc)); + if(currDlSlot->pageAllocInfo == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcDlPageAlloc : Memory Allocation is failed!"); + return RFAILED; + } + memcpy(currDlSlot->pageAllocInfo, dlPageAlloc, sizeof(DlPageAlloc)); + } + else + { + DU_LOG("\nERROR --> MAC : DL Paging Allocation is failed!"); + return RFAILED; + } + return ROK; +} + +/** + * @brief Forming and filling the MUX Pdu * @details * * Function : fillMsg4Pdu @@ -130,21 +236,22 @@ uint8_t MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) * @param[in] DlMsgAlloc *msg4Alloc * @return void **/ -void fillMsg4Pdu(uint16_t cellId, DlMsgAlloc *msg4Alloc) +void fillMsg4Pdu(uint16_t cellId, DlMsgSchInfo *msg4SchInfo) { - uint8_t ueIdx; + uint8_t ueId = 0, ueIdx = 0; uint16_t cellIdx; uint16_t msg4TxPduLen; MacDlData msg4DlData; MacCeInfo macCeData; + DlHarqProcCb *hqProcCb; GET_CELL_IDX(cellId, cellIdx); memset(&msg4DlData, 0, sizeof(MacDlData)); memset(&macCeData, 0, sizeof(MacCeInfo)); - GET_UE_IDX(msg4Alloc->dlMsgInfo.crnti, ueIdx); - ueIdx = ueIdx -1; + GET_UE_ID(msg4SchInfo->crnti, ueId); + ueIdx = ueId -1; if(macCb.macCell[cellIdx] == NULLP) { @@ -152,23 +259,25 @@ void fillMsg4Pdu(uint16_t cellId, DlMsgAlloc *msg4Alloc) return; } + hqProcCb = &macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4HqInfo; + msg4TxPduLen = hqProcCb->tbInfo[0].tbSize - TX_PAYLOAD_HDR_LEN; + if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu != NULLP) { MAC_ALLOC(msg4DlData.pduInfo[msg4DlData.numPdu].dlPdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); if(msg4DlData.pduInfo[msg4DlData.numPdu].dlPdu != NULLP) { - msg4TxPduLen = macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize - TX_PAYLOAD_HDR_LEN; - 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, msg4TxPduLen); - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu != NULLP) + hqProcCb->tbInfo[0].tb = NULLP; + MAC_ALLOC(hqProcCb->tbInfo[0].tb, msg4TxPduLen); + if(hqProcCb->tbInfo[0].tb != NULLP) { - memset(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, 0, msg4TxPduLen); - macMuxPdu(&msg4DlData, &macCeData, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, msg4TxPduLen); + memset(hqProcCb->tbInfo[0].tb, 0, msg4TxPduLen); + macMuxPdu(&msg4DlData, &macCeData, hqProcCb->tbInfo[0].tb, msg4TxPduLen); } else { @@ -176,24 +285,28 @@ void fillMsg4Pdu(uint16_t cellId, DlMsgAlloc *msg4Alloc) } /* Free memory allocated */ MAC_FREE(msg4DlData.pduInfo[msg4DlData.numPdu-1].dlPdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); + MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu = NULLP; + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen = 0; msg4DlData.numPdu--; + } } /* storing msg4 Pdu in macDlSlot */ - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu) + if(hqProcCb->tbInfo[0].tb) { - msg4Alloc->dlMsgInfo.dlMsgPduLen = msg4TxPduLen; - MAC_ALLOC(msg4Alloc->dlMsgInfo.dlMsgPdu, msg4Alloc->dlMsgInfo.dlMsgPduLen); - if(msg4Alloc->dlMsgInfo.dlMsgPdu != NULLP) + msg4SchInfo->dlMsgPduLen = msg4TxPduLen; + MAC_ALLOC(msg4SchInfo->dlMsgPdu, msg4SchInfo->dlMsgPduLen); + if(msg4SchInfo->dlMsgPdu != NULLP) { - memcpy(msg4Alloc->dlMsgInfo.dlMsgPdu, macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, \ - msg4Alloc->dlMsgInfo.dlMsgPduLen); + memcpy(msg4SchInfo->dlMsgPdu, hqProcCb->tbInfo[0].tb, \ + msg4SchInfo->dlMsgPduLen); } } else { - DU_LOG("\nERROR --> MAC: Failed at macMuxPdu()"); + DU_LOG("\nERROR --> MAC: Failed at fillMsg4Pdu()"); } } @@ -212,6 +325,7 @@ void fillMsg4Pdu(uint16_t cellId, DlMsgAlloc *msg4Alloc) void buildAndSendMuxPdu(SlotTimingInfo currTimingInfo) { + uint8_t ueIdx; uint16_t cellIdx; MacDlSlot *currDlSlot = NULLP; SlotTimingInfo muxTimingInfo; @@ -219,14 +333,17 @@ void buildAndSendMuxPdu(SlotTimingInfo currTimingInfo) GET_CELL_IDX(currTimingInfo.cellId, cellIdx); - ADD_DELTA_TO_TIME(currTimingInfo, muxTimingInfo, PHY_DELTA_DL); + ADD_DELTA_TO_TIME(currTimingInfo, muxTimingInfo, gConfigInfo.gPhyDeltaDl, macCb.macCell[cellIdx]->numOfSlots); currDlSlot = &macCb.macCell[cellIdx]->dlSlot[muxTimingInfo.slot]; - if(currDlSlot->dlInfo.dlMsgAlloc) + + for(ueIdx=0; ueIdxdlInfo.dlMsgAlloc->dlMsgInfo.isMsg4Pdu) + if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]) { - fillMsg4Pdu(currTimingInfo.cellId, currDlSlot->dlInfo.dlMsgAlloc); - currDlSlot = NULLP; + if((macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status)&& (currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg)) + { + fillMsg4Pdu(currTimingInfo.cellId, currDlSlot->dlInfo.dlMsgAlloc[ueIdx]); + } } } } @@ -251,7 +368,7 @@ int sendSlotIndMacToSch(SlotTimingInfo *slotInd) Pst pst; FILL_PST_MAC_TO_SCH(pst, EVENT_SLOT_IND_TO_SCH); - return(*macSchSlotIndOpts[pst.selector])(&pst,slotInd); + return(SchMessageRouter(&pst, (void *)slotInd)); } /******************************************************************* @@ -298,6 +415,49 @@ int sendCellUpIndMacToDuApp(uint16_t cellId) return ret; } /* sendCellUpIndMacToDuApp */ +/******************************************************************* + * + * @brief Send slot indication to DU APP + * + * @details + * + * Function : sendSlotIndToDuApp + * + * Functionality: + * Send cell up indication to DU APP + * + * @params[in] Cell Up indication info + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t sendSlotIndToDuApp(SlotTimingInfo *slotInd) +{ + Pst pst; + uint16_t ret; + SlotTimingInfo *slotIndInfo; + + /* Allocate sharable memory */ + MAC_ALLOC_SHRABL_BUF(slotIndInfo, sizeof(SlotTimingInfo)); + if(!slotIndInfo) + { + DU_LOG("\nERROR --> MAC : Memory allocation failed for slot indication"); + return RFAILED; + } + memcpy(slotIndInfo, slotInd,sizeof(SlotTimingInfo)); + + /* Fill Pst */ + FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_SLOT_IND); + + ret = MacDuAppSlotInd(&pst, slotIndInfo); + if(ret != ROK) + { + DU_LOG("\nERROR --> MAC: Failed to send slot up indication to DU APP"); + MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, slotIndInfo, sizeof(SlotTimingInfo)); + } + + return ret; +} /******************************************************************* * * @brief Process slot indication at MAC @@ -366,9 +526,9 @@ uint8_t fapiMacSlotInd(Pst *pst, SlotTimingInfo *slotInd) #endif /*starting Task*/ ODU_START_TASK(&startTime, PID_MAC_TTI_IND); - gSlotCount++; + gConfigInfo.gSlotCount++; - if(gSlotCount == 1) + if(gConfigInfo.gSlotCount == 1) { GET_CELL_IDX(slotInd->cellId, cellIdx); macCb.macCell[cellIdx]->state = CELL_STATE_UP; @@ -395,16 +555,25 @@ uint8_t fapiMacSlotInd(Pst *pst, SlotTimingInfo *slotInd) } #endif - /* send slot indication to du app */ - if(gSlotCount == 1) + /*First Slot Ind is for CellUp. Any other Slot, will be notified to DUAPP as + * SLOT_IND*/ + if(gConfigInfo.gSlotCount == 1) { + /* send cell up indication to du app */ ret = sendCellUpIndMacToDuApp(slotInd->cellId); - if(ret != ROK) - { - DU_LOG("\nERROR --> MAC :Sending of slot ind msg from MAC to DU APP failed"); - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotTimingInfo)); - return ret; - } + + } + else + { + /* send slot indication to du app */ + ret = sendSlotIndToDuApp(slotInd); + } + + if(ret != ROK) + { + DU_LOG("\nERROR --> MAC :Sending of slot ind msg from MAC to DU APP failed"); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotTimingInfo)); + return ret; } /*stoping Task*/