From 6f769128e3fa5a83ee92e668ef9ac152c96b3200 Mon Sep 17 00:00:00 2001 From: Balaji Shankaran Date: Mon, 15 Jun 2020 20:50:40 +0530 Subject: [PATCH] PHY_DELTA changes Change-Id: I5c67a57b1f61464af776bc6af27e12d5b16ec350 Signed-off-by: Balaji Shankaran --- src/5gnrmac/lwr_mac_fsm.c | 562 +++++++++++++++++++++++---------------------- src/5gnrmac/lwr_mac_fsm.h | 2 - src/5gnrmac/mac.h | 4 +- src/5gnrmac/mac_msg_hdl.c | 1 + src/5gnrmac/mac_mux.c | 1 + src/5gnrmac/mac_rach.c | 9 +- src/5gnrmac/mac_slot_ind.c | 53 +++-- src/5gnrmac/mac_stop_ind.c | 1 + src/5gnrmac/rg_lim.c | 1 + src/5gnrmac/rg_lmm.c | 41 ++-- src/5gnrmac/rg_tom.c | 7 +- src/5gnrsch/sch.c | 81 +++---- src/5gnrsch/sch.h | 19 +- src/5gnrsch/sch_common.c | 108 ++++----- src/5gnrsch/sch_rach.c | 93 ++++---- src/5gnrsch/sch_slot_ind.c | 119 ++++++---- src/5gnrsch/sch_utils.c | 114 ++++++++- src/5gnrsch/sch_utils.h | 2 +- src/cm/common_def.h | 20 ++ src/cm/du_app_mac_inf.h | 11 +- src/cm/mac_sch_interface.c | 9 +- src/cm/mac_sch_interface.h | 62 +++-- src/du_app/du_cfg.c | 25 +- src/phy_stub/l1_bdy1.c | 4 +- 24 files changed, 802 insertions(+), 547 deletions(-) create mode 100644 src/cm/common_def.h diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index 2e92246e1..96cd18e4e 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -18,6 +18,7 @@ #include #include +#include /* header include files -- defines (.h) */ #include "envopt.h" /* environment options */ @@ -62,6 +63,7 @@ #include "mac.h" #include "rg.x" /* typedefs for MAC */ #include "lwr_mac_phy.h" +#include "common_def.h" #include "math.h" #define MIB_SFN_BITMASK 0xFC @@ -78,7 +80,7 @@ extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX]; /* Global variables */ uint8_t slotIndIdx; -uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo); +uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo); void lwrMacInit() { @@ -2714,27 +2716,35 @@ Msg4Info *msg4Info) * @return ROK * ******************************************************************/ - -S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t *msgLen, RntiType rntiType) +S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, uint32_t *msgLen, RntiType rntiType) { if(dlTtiReqPdu != NULLP) { PdcchCfg *pdcchInfo = NULLP; + BwpCfg *bwp = NULLP; + + dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \ + (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \ + (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*))); + if(rntiType == SI_RNTI_TYPE) { - pdcchInfo = &dlAlloc->brdcstAlloc.sib1Alloc.sib1PdcchCfg; + pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg; + bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp; fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); } else if(rntiType == RA_RNTI_TYPE) { - pdcchInfo = &dlAlloc->rarAlloc.rarPdcchCfg; + pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg; + bwp = &dlInfo->rarAlloc->bwp; fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); } else if(rntiType == TC_RNTI_TYPE) { - pdcchInfo = &dlAlloc->msg4Alloc->msg4PdcchCfg; + pdcchInfo = &dlInfo->msg4Alloc->msg4PdcchCfg; + bwp = &dlInfo->msg4Alloc->bwp; fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\ - &dlAlloc->msg4Alloc->msg4Info); + &dlInfo->msg4Alloc->msg4Info); } else { @@ -2742,10 +2752,10 @@ S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t return RFAILED;; } dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; - dlTtiReqPdu->u.pdcch_pdu.bwpSize = pdcchInfo->pdcchBwpCfg.BWPSize; - dlTtiReqPdu->u.pdcch_pdu.bwpPart = pdcchInfo->pdcchBwpCfg.BWPStart; - dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = pdcchInfo->pdcchBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = pdcchInfo->pdcchBwpCfg.cyclicPrefix; + dlTtiReqPdu->u.pdcch_pdu.bwpSize = bwp->BWPSize; + dlTtiReqPdu->u.pdcch_pdu.bwpPart = bwp->BWPStart; + dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing; + dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = bwp->cyclicPrefix; dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex; dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols; memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6); @@ -2756,9 +2766,6 @@ S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t dlTtiReqPdu->u.pdcch_pdu.shiftIndex = pdcchInfo->coreset0Cfg.shiftIndex; dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity; dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci; - dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \ - (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \ - (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*))); /* Calculating PDU length. Considering only one dl dci pdu for now */ dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t); @@ -2766,8 +2773,8 @@ S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize)); } - return ROK; + return ROK; } /******************************************************************* @@ -2790,7 +2797,7 @@ S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t ******************************************************************/ void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo, -uint32_t *msgLen, uint16_t pduIndex) + BwpCfg bwp,uint32_t *msgLen, uint16_t pduIndex) { uint8_t idx; @@ -2800,10 +2807,10 @@ uint32_t *msgLen, uint16_t pduIndex) dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap; dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti; dlTtiReqPdu->u.pdsch_pdu.pduIndex = pduIndex; - dlTtiReqPdu->u.pdsch_pdu.bwpSize = pdschInfo->pdschBwpCfg.BWPSize; - dlTtiReqPdu->u.pdsch_pdu.bwpStart = pdschInfo->pdschBwpCfg.BWPStart; - dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = pdschInfo->pdschBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = pdschInfo->pdschBwpCfg.cyclicPrefix; + dlTtiReqPdu->u.pdsch_pdu.bwpSize = bwp.BWPSize; + dlTtiReqPdu->u.pdsch_pdu.bwpStart = bwp.BWPStart; + dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing; + dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = bwp.cyclicPrefix; dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords; for(idx = 0; idx < MAX_CODEWORDS ; idx++) { @@ -2864,7 +2871,7 @@ uint32_t *msgLen, uint16_t pduIndex) * @return count * * ********************************************************************/ -uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo) +uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo) { uint8_t count = 0; uint8_t idx = 0; @@ -2875,20 +2882,24 @@ uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo) { for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++) { + /* SSB PDU is filled */ count++; } } if(dlInfo->brdcstAlloc.sib1Trans) { + /* PDCCH and PDSCH PDU is filled */ count += 2; } } - if(dlInfo->isRarPres) + if(dlInfo->rarAlloc != NULLP) { + /* PDCCH and PDSCH PDU is filled */ count += 2; } - if(dlInfo->msg4Alloc) + if(dlInfo->msg4Alloc != NULLP) { + /* PDCCH and PDSCH PDU is filled */ count += 2; } @@ -2910,7 +2921,7 @@ uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo) * @return count * * ********************************************************************/ -uint8_t calcTxDataReqPduCount(DlAlloc *dlInfo) +uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo) { uint8_t count = 0; @@ -2918,11 +2929,11 @@ uint8_t calcTxDataReqPduCount(DlAlloc *dlInfo) { count++; } - if(dlInfo->isRarPres) + if(dlInfo->rarAlloc != NULLP) { count++; } - if(dlInfo->msg4Alloc) + if(dlInfo->msg4Alloc != NULLP) { count++; } @@ -3109,7 +3120,7 @@ uint8_t fillMsg4TxDataReq(fapi_tx_pdu_desc_t *pduDesc, Msg4Info *msg4Info, * RFAILED - failure * * ****************************************************************/ -uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) +uint16_t handleDlTtiReq(SlotIndInfo currTimingInfo) { #ifdef FAPI uint8_t idx; @@ -3118,7 +3129,10 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) uint16_t pduIndex = 0; uint32_t msgLen = 0; uint32_t dlTtiReqMsgSize = 0; + fapi_dl_tti_req_t *dlTtiReq = NULLP; + SlotIndInfo dlTtiReqTimingInfo; + RgCellCb *cellCbParams = NULLP; MacDlSlot *currDlSlot = NULLP; MacCellCfg macCellCfg; @@ -3128,154 +3142,153 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) if(clGlobalCp.phyState == PHY_STATE_RUNNING) { + /* consider phy delay */ + ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA); + cellCbParams = rgCb[inst].cell; - macCellCfg = cellCbParams->macCellCfg; - - if(currTimingInfo != NULLP) - { - currDlSlot = &macCb.macCell->dlSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED]; - nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo); - dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \ - sizeof(fapi_dl_tti_req_pdu_t)); - if(nPdu > 0) - { - if(currDlSlot->dlInfo.isBroadcastPres) - { - if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) - { - dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); - } - - } - if(currDlSlot->dlInfo.isRarPres) - { - dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); - } - if(currDlSlot->dlInfo.msg4Alloc) - { - dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); - } - } - LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize); - if(dlTtiReq != NULLP) - { - memset(dlTtiReq, 0, dlTtiReqMsgSize); - dlTtiReq->sfn = currTimingInfo->sfn; - dlTtiReq->slot = currTimingInfo->slot; - dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */ - nPdu = dlTtiReq->nPdus; - dlTtiReq->nGroup = 0; - - if(dlTtiReq->nPdus > 0) - { - dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \ - (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*))); - if(!dlTtiReq->pdus) - { - DU_LOG("\nLWR_MAC: Memory allocation failed"); - return RFAILED; - } - - if(currDlSlot->dlInfo.isBroadcastPres) - { - if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans) - { - if(dlTtiReq->pdus != NULLP) - { - for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++) - { - fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\ - currDlSlot, &msgLen, idx, dlTtiReq->sfn); - numPduEncoded++; - } - } - printf("\033[1;31m"); - DU_LOG("\nLWR_MAC: MIB sent.."); - printf("\033[0m"); - } - if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) - { - /* Filling SIB1 param */ - if(numPduEncoded != nPdu) - { - rntiType = SI_RNTI_TYPE; - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\ - &msgLen, rntiType); - numPduEncoded++; - fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\ - sib1Alloc.sib1PdschCfg, &msgLen, pduIndex); - pduIndex++; - numPduEncoded++; - } - printf("\033[1;34m"); - DU_LOG("\nLWR_MAC: SIB1 sent..."); - printf("\033[0m"); - } - } - if(currDlSlot->dlInfo.isRarPres) - { - /* Filling RAR param */ - rntiType = RA_RNTI_TYPE; - fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo); - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \ - &currDlSlot->dlInfo, &msgLen, rntiType); - numPduEncoded++; - fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], \ - &currDlSlot->dlInfo.rarAlloc.rarPdschCfg, &msgLen, pduIndex); - numPduEncoded++; - pduIndex++; - - printf("\033[1;32m"); - DU_LOG("\nLWR_MAC: RAR sent..."); - printf("\033[0m"); - } - if(currDlSlot->dlInfo.msg4Alloc) - { - /* Filling Msg4 param */ - rntiType = TC_RNTI_TYPE; - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \ - &currDlSlot->dlInfo, &msgLen, rntiType); - numPduEncoded++; - fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], \ - &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg, &msgLen, pduIndex); - numPduEncoded++; - pduIndex++; - - printf("\033[1;32m"); - DU_LOG("\nLWR_MAC: MSG4 sent..."); - printf("\033[0m"); - } - msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); - LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \ - (void *)dlTtiReq); - - /* send Tx-DATA req message */ - sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo); - } - else - { - msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); - LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq); - } - return ROK; - } - else - { - DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request"); - return RFAILED; - } - } - else - { - DU_LOG("\nLWR_MAC: Current TTI Info is NULL"); - return RFAILED; - } - } + macCellCfg = cellCbParams->macCellCfg; + + currDlSlot = &macCb.macCell->dlSlot[dlTtiReqTimingInfo.slot]; + nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo); + dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \ + sizeof(fapi_dl_tti_req_pdu_t)); + if(nPdu > 0) + { + if(currDlSlot->dlInfo.isBroadcastPres) + { + if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) + { + dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); + } + } + if(currDlSlot->dlInfo.rarAlloc != NULLP) + { + dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); + } + if(currDlSlot->dlInfo.msg4Alloc != NULLP) + { + dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); + } + } + LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize); + if(dlTtiReq != NULLP) + { + memset(dlTtiReq, 0, dlTtiReqMsgSize); + dlTtiReq->sfn = dlTtiReqTimingInfo.sfn; + dlTtiReq->slot = dlTtiReqTimingInfo.slot; + dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */ + nPdu = dlTtiReq->nPdus; + dlTtiReq->nGroup = 0; + + if(dlTtiReq->nPdus > 0) + { + dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \ + (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*))); + if(!dlTtiReq->pdus) + { + DU_LOG("\nLWR_MAC: Memory allocation failed"); + return RFAILED; + } + + if(currDlSlot->dlInfo.isBroadcastPres) + { + if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans) + { + if(dlTtiReq->pdus != NULLP) + { + for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++) + { + fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\ + currDlSlot, &msgLen, idx, dlTtiReq->sfn); + numPduEncoded++; + } + } + printf("\033[1;31m"); + DU_LOG("\nLWR_MAC: MIB sent.."); + printf("\033[0m"); + } + if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) + { + /* Filling SIB1 param */ + if(numPduEncoded != nPdu) + { + rntiType = SI_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\ + &msgLen, rntiType); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], + &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg, + currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp, + &msgLen, pduIndex); + pduIndex++; + numPduEncoded++; + } + printf("\033[1;34m"); + DU_LOG("\nLWR_MAC: SIB1 sent..."); + printf("\033[0m"); + } + } + if(currDlSlot->dlInfo.rarAlloc != NULLP) + { + /* Filling RAR param */ + rntiType = RA_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \ + &currDlSlot->dlInfo, &msgLen, rntiType); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], + &currDlSlot->dlInfo.rarAlloc->rarPdschCfg, + currDlSlot->dlInfo.rarAlloc->bwp, + &msgLen, pduIndex); + numPduEncoded++; + pduIndex++; + + printf("\033[1;32m"); + DU_LOG("\nLWR_MAC: RAR sent..."); + printf("\033[0m"); + } + if(currDlSlot->dlInfo.msg4Alloc != NULLP) + { + /* Filling Msg4 param */ + rntiType = TC_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \ + &currDlSlot->dlInfo, &msgLen, rntiType); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], + &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg, + currDlSlot->dlInfo.msg4Alloc->bwp, + &msgLen, pduIndex); + numPduEncoded++; + pduIndex++; + + printf("\033[1;32m"); + DU_LOG("\nLWR_MAC: MSG4 sent..."); + printf("\033[0m"); + } + msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \ + (void *)dlTtiReq); + + /* send Tx-DATA req message */ + sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo); + } + else + { + msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq); + } + return ROK; + } + else + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request"); + return RFAILED; + } + } else { - lwr_mac_handleInvalidEvt(currTimingInfo); + lwr_mac_handleInvalidEvt(&currTimingInfo); return RFAILED; } #endif @@ -3298,7 +3311,7 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) * RFAILED - failure * * ****************************************************************/ -uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo) +uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo) { #ifdef FAPI uint8_t nPdu = 0; @@ -3318,11 +3331,11 @@ uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo) { txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen; } - if(dlInfo->isRarPres) + if(dlInfo->rarAlloc != NULLP) { - txDataReqMsgSize += dlInfo->rarAlloc.rarInfo.rarPduLen; + txDataReqMsgSize += dlInfo->rarAlloc->rarInfo.rarPduLen; } - if(dlInfo->msg4Alloc) + if(dlInfo->msg4Alloc != NULLP) { txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen; } @@ -3335,8 +3348,8 @@ uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo) } memset(txDataReq, 0, txDataReqMsgSize); - txDataReq->sfn = currTimingInfo->sfn; - txDataReq->slot = currTimingInfo->slot; + txDataReq->sfn = currTimingInfo.sfn; + txDataReq->slot = currTimingInfo.slot; txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \ (sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *))); @@ -3347,19 +3360,24 @@ uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo) pduIndex++; txDataReq->numPdus++; } - if(dlInfo->isRarPres) + if(dlInfo->rarAlloc != NULLP) { - fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc.\ - rarInfo, &msgLen, pduIndex); + fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc->rarInfo, &msgLen, pduIndex); pduIndex++; txDataReq->numPdus++; + + MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc)); + dlInfo->rarAlloc = NULLP; } - if(dlInfo->msg4Alloc) + if(dlInfo->msg4Alloc != NULLP) { fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\ msg4Info, &msgLen, pduIndex); pduIndex++; txDataReq->numPdus++; + + MAC_FREE(dlInfo->msg4Alloc,sizeof(Msg4Alloc)); + dlInfo->msg4Alloc = NULLP; } msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t); fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen); @@ -3392,31 +3410,31 @@ uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot) if(currUlSlot != NULLP) { - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) { pduCount++; if(ulTtiReq) ulTtiReq->rachPresent = PDU_PRESENT; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) { pduCount++; if(ulTtiReq) ulTtiReq->nUlsch++; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI) { pduCount++; if(ulTtiReq) ulTtiReq->nUlsch = PDU_PRESENT; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI) { pduCount++; if(ulTtiReq) ulTtiReq->nUlcch = PDU_PRESENT; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS) { pduCount++; } @@ -3476,12 +3494,12 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma { ulTtiReqPdu->pduType = PRACH_PDU_TYPE; ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId; - ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulCellInfo.prachSchInfo.numPrachOcas; + ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulInfo.prachSchInfo.numPrachOcas; ulTtiReqPdu->u.prach_pdu.prachFormat = \ - currUlSlot->ulCellInfo.prachSchInfo.prachFormat; - ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa; + currUlSlot->ulInfo.prachSchInfo.prachFormat; + ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa; ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \ - currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb; + currUlSlot->ulInfo.prachSchInfo.prachStartSymb; setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg); ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0; ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0; @@ -3501,7 +3519,7 @@ void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma { ulTtiReqPdu->pduType = PUSCH_PDU_TYPE; ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1; - ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulCellInfo.crnti; + ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulInfo.crnti; /* TODO : Fill handle in raCb when scheduling pusch and access here */ ulTtiReqPdu->u.pusch_pdu.handle = 100; ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb; @@ -3513,39 +3531,39 @@ void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308; ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2; ulTtiReqPdu->u.pusch_pdu.mcsIndex = \ - currUlSlot->ulCellInfo.schPuschInfo.tbInfo.mcs; + currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs; ulTtiReqPdu->u.pusch_pdu.mcsTable = 0; ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1; - ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulCellInfo.cellId; + ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId; ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1; ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4; ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0; - ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulCellInfo.cellId; + ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId; ulTtiReqPdu->u.pusch_pdu.scid = 0; ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1; ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0; ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \ - currUlSlot->ulCellInfo.schPuschInfo.resAllocType; + currUlSlot->ulInfo.schPuschInfo.resAllocType; ulTtiReqPdu->u.pusch_pdu.rbStart = \ - currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.startPrb; + currUlSlot->ulInfo.schPuschInfo.fdAlloc.startPrb; ulTtiReqPdu->u.pusch_pdu.rbSize = \ - currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.numPrb; + currUlSlot->ulInfo.schPuschInfo.fdAlloc.numPrb; ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0; ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0; ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0; ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0; ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \ - currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.startSymb; + currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb; ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \ - currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.numSymb; + currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb; ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \ - currUlSlot->ulCellInfo.schPuschInfo.tbInfo.rv; + currUlSlot->ulInfo.schPuschInfo.tbInfo.rv; ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \ - currUlSlot->ulCellInfo.schPuschInfo.harqProcId; + currUlSlot->ulInfo.schPuschInfo.harqProcId; ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \ - currUlSlot->ulCellInfo.schPuschInfo.tbInfo.ndi; + currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi; ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \ - currUlSlot->ulCellInfo.schPuschInfo.tbInfo.tbSize; + currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize; /* numCb is 0 for new transmission */ ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0; @@ -3573,7 +3591,7 @@ void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma * RFAILED - failure * ******************************************************************/ -uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo) +uint16_t handleUlTtiReq(SlotIndInfo currTimingInfo) { #ifdef FAPI uint8_t pduIdx = -1; @@ -3582,86 +3600,82 @@ uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo) uint32_t msgSize = 0; fapi_ul_tti_req_t *ulTtiReq = NULLP; + SlotIndInfo ulTtiReqTimingInfo; + RgCellCb *cellCbParams = NULLP; MacUlSlot *currUlSlot = NULLP; MacCellCfg macCellCfg; Inst inst = 0; if(clGlobalCp.phyState == PHY_STATE_RUNNING) - { - cellCbParams = rgCb[inst].cell; - macCellCfg = cellCbParams->macCellCfg; - - if(currTimingInfo != NULLP) - { - currUlSlot = &macCb.macCell->ulSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED]; - numPdu = getnPdus(NULL, currUlSlot); - msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu * \ - sizeof(fapi_ul_tti_req_pdu_t)); - LWR_MAC_ALLOC(ulTtiReq, msgSize); + { + cellCbParams = rgCb[inst].cell; + macCellCfg = cellCbParams->macCellCfg; - if(ulTtiReq != NULLP) - { - memset(ulTtiReq, 0, msgSize); - ulTtiReq->sfn = currTimingInfo->sfn; - ulTtiReq->slot = currTimingInfo->slot; - ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); - ulTtiReq->nGroup = 0; - if(ulTtiReq->nPdus > 0) - { - ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \ - (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*))); - /* Fill Prach Pdu */ - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) - { - pduIdx++; - fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen); - } + /* add PHY delta */ + ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA); - /* Fill PUSCH PDU */ - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH) - { - pduIdx++; - fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen); - } + currUlSlot = &macCb.macCell->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED]; + numPdu = getnPdus(NULL, currUlSlot); + msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu*sizeof(fapi_ul_tti_req_pdu_t)); + LWR_MAC_ALLOC(ulTtiReq, msgSize); - if((currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) || \ - (currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)) - { - msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t)); - fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); - - DU_LOG("\nLWR_MAC: Sending UL TTI Request"); - LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); - } - } - else - { - msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); - - DU_LOG("\nLWR_MAC: Sending UL TTI Request"); - LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); - } - memset(&currUlSlot, 0, sizeof(MacUlSlot)); - return ROK; - } - else - { - DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request"); - memset(&currUlSlot, 0, sizeof(MacUlSlot)); - return RFAILED; - } - } - else - { - DU_LOG("\nLWR_MAC: Current TTI Info in UL is NULL"); - return RFAILED; - } - } + if(ulTtiReq != NULLP) + { + memset(ulTtiReq, 0, msgSize); + ulTtiReq->sfn = currTimingInfo.sfn; + ulTtiReq->slot = currTimingInfo.slot; + ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); + ulTtiReq->nGroup = 0; + if(ulTtiReq->nPdus > 0) + { + ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \ + (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*))); + /* Fill Prach Pdu */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) + { + pduIdx++; + fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen); + } + + /* Fill PUSCH PDU */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) + { + pduIdx++; + fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen); + } + + if((currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) || \ + (currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)) + { + msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t)); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); + + DU_LOG("\nLWR_MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); + } + } + else + { + msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); + + DU_LOG("\nLWR_MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); + } + memset(&currUlSlot, 0, sizeof(MacUlSlot)); + return ROK; + } + else + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request"); + memset(&currUlSlot, 0, sizeof(MacUlSlot)); + return RFAILED; + } + } else { - lwr_mac_handleInvalidEvt(currTimingInfo); + lwr_mac_handleInvalidEvt(&currTimingInfo); } #endif return ROK; diff --git a/src/5gnrmac/lwr_mac_fsm.h b/src/5gnrmac/lwr_mac_fsm.h index 43f3c950a..351a7eadb 100644 --- a/src/5gnrmac/lwr_mac_fsm.h +++ b/src/5gnrmac/lwr_mac_fsm.h @@ -44,8 +44,6 @@ S16 lwr_mac_handleConfigRspEvt(void *msg); S16 lwr_mac_handleStartReqEvt(void *msg); S16 lwr_mac_handleStopReqEvt(void *msg); void sendToLowerMac(U16, U32, void *); -uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo); -uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo); void handlePhyMessages(uint16_t msgType, uint32_t msgSize, void *msg); typedef S16 (*lwrMacFsmHdlr)(void *); diff --git a/src/5gnrmac/mac.h b/src/5gnrmac/mac.h index 979381f6e..82fa48437 100644 --- a/src/5gnrmac/mac.h +++ b/src/5gnrmac/mac.h @@ -80,12 +80,12 @@ typedef struct macDlSlot { - DlAlloc dlInfo; + DlSchedInfo dlInfo; }MacDlSlot; typedef struct macUlSlot { - UlSchInfo ulCellInfo; + UlSchedInfo ulInfo; }MacUlSlot; typedef struct macCbInfo diff --git a/src/5gnrmac/mac_msg_hdl.c b/src/5gnrmac/mac_msg_hdl.c index 5f75dc79e..eed1dad94 100644 --- a/src/5gnrmac/mac_msg_hdl.c +++ b/src/5gnrmac/mac_msg_hdl.c @@ -17,6 +17,7 @@ *******************************************************************************/ /* header include files -- defines (.h) */ +#include #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ diff --git a/src/5gnrmac/mac_mux.c b/src/5gnrmac/mac_mux.c index e5dda1464..266a57258 100644 --- a/src/5gnrmac/mac_mux.c +++ b/src/5gnrmac/mac_mux.c @@ -18,6 +18,7 @@ #include #include +#include /* header include files -- defines (.h) */ #include "envopt.h" /* environment options */ diff --git a/src/5gnrmac/mac_rach.c b/src/5gnrmac/mac_rach.c index 4520aab89..8cc5f0c24 100644 --- a/src/5gnrmac/mac_rach.c +++ b/src/5gnrmac/mac_rach.c @@ -16,6 +16,7 @@ ################################################################################ *******************************************************************************/ /* header include files (.h) */ +#include #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ @@ -129,13 +130,13 @@ uint16_t fapiMacRachInd(Pst *pst, RachInd *rachInd) uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX] = {0, 2, 4, 6, 8, 10, 12, 13, 15, 17, 19, 23, 27, 34, 46, 69}; -int MacProcUlSchInfo(Pst *pst, UlSchInfo *ulSchInfo) +int MacProcUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo) { - if(ulSchInfo != NULLP) + if(ulSchedInfo != NULLP) { MacUlSlot *currUlSlot = - &macCb.macCell->ulSlot[ulSchInfo->slotIndInfo.slot % MAX_SLOT_SUPPORTED]; - memcpy(&currUlSlot->ulCellInfo, ulSchInfo, sizeof(UlSchInfo)); + &macCb.macCell->ulSlot[ulSchedInfo->slotIndInfo.slot % MAX_SLOT_SUPPORTED]; + memcpy(&currUlSlot->ulInfo, ulSchedInfo, sizeof(ulSchedInfo)); } return ROK; } diff --git a/src/5gnrmac/mac_slot_ind.c b/src/5gnrmac/mac_slot_ind.c index cece12953..8f686b3f7 100644 --- a/src/5gnrmac/mac_slot_ind.c +++ b/src/5gnrmac/mac_slot_ind.c @@ -16,6 +16,7 @@ ################################################################################ *******************************************************************************/ /* header include files (.h) */ +#include "stdbool.h" #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ @@ -78,23 +79,42 @@ MacSchSlotIndFunc macSchSlotIndOpts[] = * -# ROK * -# RFAILED **/ -int MacProcDlAlloc(Pst *pst, DlAlloc *dlAlloc) +int MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) { - if(dlAlloc != NULLP) + MacDlSlot *currDlSlot = NULLP; + + if(dlSchedInfo != NULLP) { - MacDlSlot *currDlSlot = - &macCb.macCell->dlSlot[dlAlloc->slotIndInfo.slot % MAX_SLOT_SUPPORTED]; - memcpy(&currDlSlot->dlInfo, dlAlloc, sizeof(DlAlloc)); - - if(currDlSlot->dlInfo.msg4Alloc) + 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) { + Msg4Alloc *msg4Alloc = NULLP; MacDlData msg4DlData; MacCeInfo macCeData; + + currDlSlot = &macCb.macCell->dlSlot[dlSchedInfo->schSlotValue.msg4Time.slot]; + currDlSlot->dlInfo.msg4Alloc = dlSchedInfo->msg4Alloc; /* copy msg4 alloc pointer in MAC slot info */ + msg4Alloc = dlSchedInfo->msg4Alloc; + memset(&msg4DlData, 0, sizeof(MacDlData)); memset(&macCeData, 0, sizeof(MacCeInfo)); - macCb.macCell->macRaCb[0].msg4TbSize = \ - dlAlloc->msg4Alloc->msg4PdschCfg.codeword[0].tbSize; + macCb.macCell->macRaCb[0].msg4TbSize = msg4Alloc->msg4PdschCfg.codeword[0].tbSize; if(macCb.macCell->macRaCb[0].msg4Pdu != NULLP) { @@ -105,20 +125,23 @@ int MacProcDlAlloc(Pst *pst, DlAlloc *dlAlloc) fillMsg4DlData(&msg4DlData); } } + + /* MUXing for msg4 */ fillMacCe(&macCeData); macMuxPdu(&msg4DlData, &macCeData, macCb.macCell->macRaCb[0].msg4TbSize); - /* storing msg4 Pdu in dlAlloc */ - MAC_ALLOC(dlAlloc->msg4Alloc->msg4Info.msg4Pdu, macCb.macCell->macRaCb[0].msg4PduLen); - if(dlAlloc->msg4Alloc->msg4Info.msg4Pdu != NULLP) + /* storing msg4 Pdu in macDlSlot */ + MAC_ALLOC(msg4Alloc->msg4Info.msg4Pdu, macCb.macCell->macRaCb[0].msg4PduLen); + if(msg4Alloc->msg4Info.msg4Pdu != NULLP) { - dlAlloc->msg4Alloc->msg4Info.msg4Pdu = macCb.macCell->macRaCb[0].msg4Pdu; - dlAlloc->msg4Alloc->msg4Info.msg4PduLen = macCb.macCell->macRaCb[0].msg4PduLen; + msg4Alloc->msg4Info.msg4Pdu = macCb.macCell->macRaCb[0].msg4Pdu; + msg4Alloc->msg4Info.msg4PduLen = macCb.macCell->macRaCb[0].msg4PduLen; } + /* 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(dlAlloc->msg4Alloc->msg4Info.msg4Pdu,\ + MAC_FREE(dlSchedInfo->msg4Alloc->msg4Info.msg4Pdu,\ macCb.macCell->macRaCb[0].msg4PduLen); //TODO: To be freed after lower-mac is succesfull MAC_FREE(msg4DlData.pduInfo[0].dlPdu, macCb.macCell->macRaCb[0].msg4PduLen); MAC_FREE(macCb.macCell->macRaCb[0].msg4Pdu, macCb.macCell->macRaCb[0].msg4PduLen); */ diff --git a/src/5gnrmac/mac_stop_ind.c b/src/5gnrmac/mac_stop_ind.c index 3249eb1e2..e609e1733 100644 --- a/src/5gnrmac/mac_stop_ind.c +++ b/src/5gnrmac/mac_stop_ind.c @@ -16,6 +16,7 @@ ################################################################################ *******************************************************************************/ /* header include files (.h) */ +#include #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ diff --git a/src/5gnrmac/rg_lim.c b/src/5gnrmac/rg_lim.c index be24dac76..072f221a5 100755 --- a/src/5gnrmac/rg_lim.c +++ b/src/5gnrmac/rg_lim.c @@ -36,6 +36,7 @@ static const char* RLOG_MODULE_NAME="MAC"; static int RLOG_FILE_ID=182; static int RLOG_MODULE_ID=4096; /* header include files -- defines (.h) */ +#include #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ diff --git a/src/5gnrmac/rg_lmm.c b/src/5gnrmac/rg_lmm.c index e96308a33..8502480ae 100755 --- a/src/5gnrmac/rg_lmm.c +++ b/src/5gnrmac/rg_lmm.c @@ -38,6 +38,7 @@ static int RLOG_FILE_ID=220; static int RLOG_MODULE_ID=4096; /* header include files (.h) */ +#include "stdbool.h" #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ @@ -2222,26 +2223,26 @@ int MacSchCellCfgReq schCellCfg.schInitialDlBwp.bwp.numPrb = macCellCfg->initialDlBwp.bwp.numPrb; schCellCfg.schInitialDlBwp.bwp.scs = macCellCfg->initialDlBwp.bwp.scs; schCellCfg.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->initialDlBwp.bwp.cyclicPrefix; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.searchSpaceId = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.searchSpaceId; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.coresetId = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.coresetId; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.monitoringSlot = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.monitoringSlot; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.duration = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.duration; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.monitoringSymbol = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.monitoringSymbol; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel1 = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel1; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel2 = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel2; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel4 = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel4; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel8 = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel8; - schCellCfg.schInitialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel16 = - macCellCfg->initialDlBwp.pdcchCommon.raSearchSpace.candidate.aggLevel16; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.coresetId; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.duration; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8; + schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 = + macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16; schCellCfg.schInitialDlBwp.pdschCommon.k0 = macCellCfg->initialDlBwp.pdschCommon.k0; schCellCfg.schInitialDlBwp.pdschCommon.mappingType = macCellCfg->initialDlBwp.pdschCommon.mappingType; diff --git a/src/5gnrmac/rg_tom.c b/src/5gnrmac/rg_tom.c index f18947bef..316d2162f 100755 --- a/src/5gnrmac/rg_tom.c +++ b/src/5gnrmac/rg_tom.c @@ -36,6 +36,7 @@ static int RLOG_MODULE_ID=4096; invoked by PHY towards MAC */ /* header include files -- defines (.h) */ +#include #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ @@ -613,14 +614,12 @@ SlotIndInfo slotInd } #endif - CmLteTimingInfo timingInfo; - RGADDTOCRNTTIME(cellCb->crntTime, timingInfo, TFU_DELTA); /* Trigger for DL TTI REQ */ - handleDlTtiReq(&timingInfo); + handleDlTtiReq(slotInd); /* Trigger for UL TTI REQ */ - handleUlTtiReq(&timingInfo); + handleUlTtiReq(slotInd); dlSf = &cellCb->subFrms[(slotInd.slot % RG_NUM_SUB_FRAMES)]; diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index aa937129c..7fe972958 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -65,6 +65,8 @@ #include "sch.h" #include "sch_utils.h" #include "du_log.h" +#include "common_def.h" + extern SchCb schCb[SCH_MAX_INST]; void SchFillCfmPst(Pst *reqPst,Pst *cfmPst,RgMngmt *cfm); /* local defines */ @@ -403,41 +405,41 @@ int InitSchCellCb(Inst inst, SchCellCfg *schCellCfg) for(uint8_t idx=0; idxtotalPrb = schUlAlloc->totalPrb = MAX_NUM_RB; + schDlSlotInfo->totalPrb = schUlSlotInfo->totalPrb = MAX_NUM_RB; for(uint8_t itr=0; itrassignedPrb[itr] = 0; - schUlAlloc->assignedPrb[itr] = 0; + schDlSlotInfo->assignedPrb[itr] = 0; + schUlSlotInfo->assignedPrb[itr] = 0; } - schUlAlloc->schPuschInfo = NULLP; + schUlSlotInfo->schPuschInfo = NULLP; for(uint8_t itr=0; itrssbInfo[itr], 0, sizeof(SsbInfo)); + memset(&schDlSlotInfo->ssbInfo[itr], 0, sizeof(SsbInfo)); } - cell->dlAlloc[idx] = schDlAlloc; - cell->ulAlloc[idx] = schUlAlloc; + cell->schDlSlotInfo[idx] = schDlSlotInfo; + cell->schUlSlotInfo[idx] = schUlSlotInfo; } schCb[inst].cells[inst] = cell; @@ -466,9 +468,12 @@ uint8_t offsetPointA uint8_t firstSymbol = 0; /* need to calculate using formula mentioned in 38.213 */ uint8_t slotIndex = 0; uint8_t FreqDomainResource[6] = {0}; + uint16_t tbSize = 0; + uint8_t numPdschSymbols = 12; /* considering pdsch region from 2 to 13 */ PdcchCfg *pdcch = &(sib1SchCfg->sib1PdcchCfg); PdschCfg *pdsch = &(sib1SchCfg->sib1PdschCfg); + BwpCfg *bwp = &(sib1SchCfg->bwp); coreset0Idx = sib1SchCfg->coresetZeroIndex; searchSpace0Idx = sib1SchCfg->searchSpaceZeroIndex; @@ -496,11 +501,13 @@ uint8_t offsetPointA /* calculate the PRBs */ calculatePRB( ((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource); + /* fill BWP */ + bwp->BWPSize = MAX_NUM_RB; /* whole of BW */ + bwp->BWPStart = 0; + bwp->subcarrierSpacing = 0; /* 15Khz */ + bwp->cyclicPrefix = 0; /* normal */ + /* fill the PDCCH PDU */ - pdcch->pdcchBwpCfg.BWPSize = MAX_NUM_RB; /* whole of BW */ - pdcch->pdcchBwpCfg.BWPStart = 0; - pdcch->pdcchBwpCfg.subcarrierSpacing = 0; /* 15Khz */ - pdcch->pdcchBwpCfg.cyclicPrefix = 0; /* normal */ pdcch->coreset0Cfg.coreSet0Size = numRbs; pdcch->coreset0Cfg.startSymbolIndex = firstSymbol; pdcch->coreset0Cfg.durationSymbols = numSymbols; @@ -533,8 +540,6 @@ uint8_t offsetPointA pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */ pdsch->rnti = 0xFFFF; /* SI-RNTI */ pdsch->pduIndex = 0; - pdsch->pdschBwpCfg.BWPSize = MAX_NUM_RB; /* whole of BW */ - pdsch->pdschBwpCfg.BWPStart = 0; pdsch->numCodewords = 1; for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++) { @@ -543,8 +548,8 @@ uint8_t offsetPointA pdsch->codeword[cwCount].mcsIndex = sib1SchCfg->sib1Mcs; pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */ pdsch->codeword[cwCount].rvIndex = 0; - pdsch->codeword[cwCount].tbSize = 768/8; /* 38.214: Table 5.1.3.2-1, - devided by 8 to get the value in bytes */ + tbSize = schCalcTbSize(sib1SchCfg->sib1PduLen); + pdsch->codeword[cwCount].tbSize = tbSize; } pdsch->dataScramblingId = pci; pdsch->numLayers = 1; @@ -558,15 +563,11 @@ uint8_t offsetPointA pdsch->dmrs.dmrsPorts = 0; pdsch->freqAlloc.resourceAlloc = 1; /* RAT type-1 RIV format */ pdsch->freqAlloc.rbStart = offset + SCH_SSB_PRB_DURATION; /* the RB numbering starts from coreset0, and PDSCH is always above SSB */ - /* formula used for calculation of rbSize, 38.213 section 5.1.3.2 * - * Ninfo = Nre . R . Qm . v * - * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh * - * Nre = min(156,Nre') . nPrb */ - pdsch->freqAlloc.rbSize = 10; /* This value is calculated from above formulae */ + pdsch->freqAlloc.rbSize = schCalcNumPrb(tbSize,sib1SchCfg->sib1Mcs,numPdschSymbols); pdsch->freqAlloc.vrbPrbMapping = 0; /* non-interleaved */ pdsch->timeAlloc.rowIndex = 1; pdsch->timeAlloc.startSymbolIndex = 2; /* spec-38.214, Table 5.1.2.1-1 */ - pdsch->timeAlloc.numSymbols = 12; + pdsch->timeAlloc.numSymbols = numPdschSymbols; pdsch->beamPdschInfo.numPrgs = 1; pdsch->beamPdschInfo.prgSize = 1; pdsch->beamPdschInfo.digBfInterfaces = 0; @@ -650,28 +651,28 @@ uint8_t macSchDlRlcBoInfo(Pst *pst, DlRlcBOInfo *dlBoInfo) DU_LOG("\nSCH : Received RLC BO Status indication"); SchCellCb *cell = schCb[inst].cells[inst]; - SchDlAlloc *dlAlloc = \ - cell->dlAlloc[(cell->slotInfo.slot + SCHED_DELTA) % SCH_NUM_SLOTS]; + SchDlSlotInfo *schDlSlotInfo = \ + cell->schDlSlotInfo[(cell->slotInfo.slot + SCHED_DELTA + PHY_DELTA) % SCH_NUM_SLOTS]; for(lcIdx = 0; lcIdx < dlBoInfo->numLc; lcIdx++) { if(dlBoInfo->boInfo[lcIdx].lcId == CCCH_LCID) { - SCH_ALLOC(dlAlloc->msg4Info, sizeof(Msg4Info)); - if(!dlAlloc->msg4Info) + SCH_ALLOC(schDlSlotInfo->msg4Info, sizeof(Msg4Info)); + if(!schDlSlotInfo->msg4Info) { DU_LOG("\nSCH : Memory allocation failed for msg4Info"); - dlAlloc = NULL; + schDlSlotInfo = NULL; return RFAILED; } - dlAlloc->msg4Info->crnti = dlBoInfo->crnti; - dlAlloc->msg4Info->ndi = 1; - dlAlloc->msg4Info->harqProcNum = 0; - dlAlloc->msg4Info->dlAssignIdx = 0; - dlAlloc->msg4Info->pucchTpc = 0; - dlAlloc->msg4Info->pucchResInd = 0; - dlAlloc->msg4Info->harqFeedbackInd = 0; - dlAlloc->msg4Info->dciFormatId = 1; + schDlSlotInfo->msg4Info->crnti = dlBoInfo->crnti; + schDlSlotInfo->msg4Info->ndi = 1; + schDlSlotInfo->msg4Info->harqProcNum = 0; + schDlSlotInfo->msg4Info->dlAssignIdx = 0; + schDlSlotInfo->msg4Info->pucchTpc = 0; + schDlSlotInfo->msg4Info->pucchResInd = 0; + schDlSlotInfo->msg4Info->harqFeedbackInd = 0; + schDlSlotInfo->msg4Info->dciFormatId = 1; } } diff --git a/src/5gnrsch/sch.h b/src/5gnrsch/sch.h index efc785179..96f3d225f 100644 --- a/src/5gnrsch/sch.h +++ b/src/5gnrsch/sch.h @@ -33,7 +33,8 @@ #define SCH_MEM_REGION 4 #define SCH_POOL 1 #define SCHED_DELTA 1 -#define RAR_DELAY 1 +#define BO_DELTA 1 +#define RAR_DELAY 2 #define SCH_MAX_UE 1 #define PUSCH_START_RB 15 #define SI_RNTI 0xFFFF @@ -91,7 +92,7 @@ typedef struct schGenCb * @brief * scheduler allocationsfor DL per cell. */ -typedef struct schDlAlloc +typedef struct schDlSlotInfo { uint16_t totalPrb; /*!< Number of RBs in the cell */ uint16_t assignedPrb[SCH_SYMBOL_PER_SLOT]; /*!< Num RBs and corresponding symbols allocated */ @@ -99,10 +100,10 @@ typedef struct schDlAlloc uint8_t ssbIdxSupported; /*!< Max SSB index */ SsbInfo ssbInfo[MAX_SSB_IDX]; /*!< SSB info */ bool sib1Pres; - bool rarPres; - RarInfo rarInfo; + //bool rarPres; + RarInfo *rarInfo; Msg4Info *msg4Info; -}SchDlAlloc; +}SchDlSlotInfo; typedef struct schRaCb { @@ -113,13 +114,13 @@ typedef struct schRaCb * @brief * scheduler allocationsfor UL per cell. */ -typedef struct schUlAlloc +typedef struct schUlSlotInfo { uint16_t totalPrb; /*!< Number of RBs in the cell */ uint16_t assignedPrb[SCH_SYMBOL_PER_SLOT]; /*!< Num RBs and corresponding symbols allocated */ bool puschPres; /*!< PUSCH presence field */ SchPuschInfo *schPuschInfo; /*!< PUSCH info */ -}SchUlAlloc; +}SchUlSlotInfo; /** * @brief @@ -132,8 +133,8 @@ typedef struct schCellCb Inst macInst; /*!< Index of the MAC instance */ uint8_t numSlots; /*!< Number of slots in current frame */ SlotIndInfo slotInfo; /*!< SFN, Slot info being processed*/ - SchDlAlloc *dlAlloc[SCH_NUM_SLOTS]; /*!< SCH resource allocations in DL */ - SchUlAlloc *ulAlloc[SCH_NUM_SLOTS]; /*!< SCH resource allocations in UL */ + SchDlSlotInfo *schDlSlotInfo[SCH_NUM_SLOTS]; /*!< SCH resource allocations in DL */ + SchUlSlotInfo *schUlSlotInfo[SCH_NUM_SLOTS]; /*!< SCH resource allocations in UL */ SchCellCfg cellCfg; /*!< Cell ocnfiguration */ SchRaCb raCb[SCH_MAX_UE]; }SchCellCb; diff --git a/src/5gnrsch/sch_common.c b/src/5gnrsch/sch_common.c index 8a1ad711e..de0d76477 100644 --- a/src/5gnrsch/sch_common.c +++ b/src/5gnrsch/sch_common.c @@ -61,6 +61,7 @@ File: sch_common.c #include "mac_sch_interface.h" #include "sch.h" #include "sch_utils.h" +#include "common_def.h" extern SchCb schCb[SCH_MAX_INST]; extern uint16_t prachCfgIdxTable[MAX_PRACH_CONFIG_IDX][8]; @@ -127,10 +128,10 @@ uint8_t schBroadcastAlloc(SchCellCb *cell, DlBrdcstAlloc *dlBrdcstAlloc, /* schedule SSB */ uint8_t scs, ssbStartPrb, ssbStartSymb, idx; uint8_t ssbStartSymbArr[SCH_MAX_SSB_BEAM]; - SchDlAlloc *dlAlloc; + SchDlSlotInfo *schDlSlotInfo; SsbInfo ssbInfo; - dlAlloc = cell->dlAlloc[slot]; + schDlSlotInfo = cell->schDlSlotInfo[slot]; if(dlBrdcstAlloc->ssbTrans) { scs = cell->cellCfg.ssbSchCfg.scsCommon; @@ -148,27 +149,26 @@ uint8_t schBroadcastAlloc(SchCellCb *cell, DlBrdcstAlloc *dlBrdcstAlloc, ssbInfo.tdAlloc.startSymb = ssbStartSymb; ssbInfo.tdAlloc.numSymb = SCH_SSB_SYMB_DURATION; dlBrdcstAlloc->ssbInfo[idx] = ssbInfo; - dlAlloc->ssbInfo[idx] = ssbInfo; - + schDlSlotInfo->ssbInfo[idx] = ssbInfo; } - dlAlloc->ssbPres = true; - dlAlloc->ssbIdxSupported = dlBrdcstAlloc->ssbIdxSupported; + schDlSlotInfo->ssbPres = true; + schDlSlotInfo->ssbIdxSupported = dlBrdcstAlloc->ssbIdxSupported; for(idx=ssbStartSymb; idxassignedPrb[idx] = ssbStartPrb + SCH_SSB_PRB_DURATION + 1; /* +1 for kSsb */ + schDlSlotInfo->assignedPrb[idx] = ssbStartPrb + SCH_SSB_PRB_DURATION + 1; /* +1 for kSsb */ } - } /* SIB1 allocation */ if(dlBrdcstAlloc->sib1Trans) { - dlAlloc->sib1Pres = true; + schDlSlotInfo->sib1Pres = true; for(idx=0; idxassignedPrb[idx] = ssbStartPrb + SCH_SSB_PRB_DURATION + 1 + 10; /* 10 PRBs for sib1 */ + schDlSlotInfo->assignedPrb[idx] = ssbStartPrb + SCH_SSB_PRB_DURATION + 1 + 10; /* 10 PRBs for sib1 */ } + memcpy(&dlBrdcstAlloc->sib1Alloc.bwp, &cell->cellCfg.sib1SchCfg.bwp, sizeof(BwpCfg)); memcpy(&dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg, &cell->cellCfg.sib1SchCfg.sib1PdcchCfg, sizeof(PdcchCfg)); memcpy(&dlBrdcstAlloc->sib1Alloc.sib1PdschCfg, &cell->cellCfg.sib1SchCfg.sib1PdschCfg, sizeof(PdschCfg)); } @@ -191,7 +191,7 @@ uint8_t schBroadcastAlloc(SchCellCb *cell, DlBrdcstAlloc *dlBrdcstAlloc, * RFAILED - failure * * ****************************************************************/ -int sendUlSchInfoToMac(UlSchInfo *ulSchInfo, Inst inst) +int sendUlSchInfoToMac(UlSchedInfo *ulSchedInfo, Inst inst) { Pst pst; @@ -199,8 +199,7 @@ int sendUlSchInfoToMac(UlSchInfo *ulSchInfo, Inst inst) SCH_FILL_RSP_PST(pst, inst); pst.event = EVENT_UL_SCH_INFO; - return(*schMacUlSchInfoOpts[pst.selector])(&pst, ulSchInfo); - + return(*schMacUlSchInfoOpts[pst.selector])(&pst, ulSchedInfo); } /** * @brief resource allocation for PRACH @@ -212,16 +211,14 @@ int sendUlSchInfoToMac(UlSchInfo *ulSchInfo, Inst inst) * This function handles PRACH allocation * * @param[in] SchCellCb *cell, cell cb - * @param[in] UlSchInfo *ulSchInfo, UL scheduling info + * @param[in] UlSchedInfo *ulSchedInfo, UL scheduling info * @return void **/ -int schPrachResAlloc(SchCellCb *cell, UlSchInfo *ulSchInfo) +int schPrachResAlloc(SchCellCb *cell, UlSchedInfo *ulSchedInfo, SlotIndInfo prachOccasionTimingInfo) { uint8_t numPrachRb = 0; uint8_t numRa = 0; uint8_t freqStart = 0; - uint16_t sfn = 0; - uint16_t slot = 0; uint8_t prachCfgIdx = 0; uint8_t prachFormat = 0; uint8_t x = 0; @@ -231,11 +228,9 @@ int schPrachResAlloc(SchCellCb *cell, UlSchInfo *ulSchInfo) uint8_t prachOcas = 0; uint8_t dataType = 0; uint8_t idx = 0; - SchUlAlloc *ulAlloc = NULLP; + SchUlSlotInfo *schUlSlotInfo = NULLP; - sfn = cell->slotInfo.sfn; - slot = cell->slotInfo.slot; - ulAlloc = cell->ulAlloc[cell->slotInfo.slot]; + schUlSlotInfo = cell->schUlSlotInfo[prachOccasionTimingInfo.slot]; prachCfgIdx = cell->cellCfg.schRachCfg.prachCfgIdx; /* derive the prachCfgIdx table paramters */ @@ -243,14 +238,14 @@ int schPrachResAlloc(SchCellCb *cell, UlSchInfo *ulSchInfo) y = prachCfgIdxTable[prachCfgIdx][2]; prachSubframe = prachCfgIdxTable[prachCfgIdx][3]; - if((sfn%x) != y) + if((prachOccasionTimingInfo.sfn%x) != y) { /* prach occasion does not lie in this SFN */ DU_LOG("\nPRACH ocassion doesn't lie in this SFN"); return RFAILED; } /* check for subFrame number */ - if ((1 << slot) & prachSubframe) + if ((1 << prachOccasionTimingInfo.slot) & prachSubframe) { /* prach ocassion present in this subframe */ @@ -272,19 +267,15 @@ int schPrachResAlloc(SchCellCb *cell, UlSchInfo *ulSchInfo) dataType |= SCH_DATATYPE_PRACH; /* Considering first slot in the frame for PRACH */ idx = 0; - ulAlloc->assignedPrb[idx] = freqStart+numPrachRb; + schUlSlotInfo->assignedPrb[idx] = freqStart+numPrachRb; } - /* Fill UL SCH Info */ - ulSchInfo->cellId = cell->cellId; - ulSchInfo->slotIndInfo.sfn = sfn; - ulSchInfo->slotIndInfo.slot = slot; - ulSchInfo->dataType = dataType; + ulSchedInfo->dataType = dataType; /* prach info */ - ulSchInfo->prachSchInfo.numPrachOcas = prachOcas; - ulSchInfo->prachSchInfo.prachFormat = prachFormat; - ulSchInfo->prachSchInfo.numRa = numRa; - ulSchInfo->prachSchInfo.prachStartSymb = prachStartSymbol; + ulSchedInfo->prachSchInfo.numPrachOcas = prachOcas; + ulSchedInfo->prachSchInfo.prachFormat = prachFormat; + ulSchedInfo->prachSchInfo.numRa = numRa; + ulSchedInfo->prachSchInfo.prachStartSymb = prachStartSymbol; return ROK; } @@ -304,26 +295,34 @@ int schPrachResAlloc(SchCellCb *cell, UlSchInfo *ulSchInfo) uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst) { int ret = ROK; - UlSchInfo ulSchInfo; - SchUlAlloc *ulAlloc; + UlSchedInfo ulSchedInfo; + SchUlSlotInfo *schUlSlotInfo; + SlotIndInfo ulTimingInfo; + + /* add PHY delta */ + ADD_DELTA_TO_TIME(cell->slotInfo,ulTimingInfo,PHY_DELTA+SCHED_DELTA); + + ulSchedInfo.cellId = cell->cellId; + ulSchedInfo.slotIndInfo.sfn = ulTimingInfo.sfn; + ulSchedInfo.slotIndInfo.slot = ulTimingInfo.slot; /* Schedule resources for PRACH */ - schPrachResAlloc(cell, &ulSchInfo); + schPrachResAlloc(cell, &ulSchedInfo, ulTimingInfo); - ulAlloc = cell->ulAlloc[cell->slotInfo.slot]; + schUlSlotInfo = cell->schUlSlotInfo[ulTimingInfo.slot]; - if(ulAlloc->schPuschInfo) + if(schUlSlotInfo->schPuschInfo) { - ulSchInfo.crnti = cell->raCb[0].tcrnti; - ulSchInfo.dataType |= SCH_DATATYPE_PUSCH; - memcpy(&ulSchInfo.schPuschInfo, ulAlloc->schPuschInfo, + ulSchedInfo.crnti = cell->raCb[0].tcrnti; + ulSchedInfo.dataType |= SCH_DATATYPE_PUSCH; + memcpy(&ulSchedInfo.schPuschInfo, schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo)); - SCH_FREE(ulAlloc->schPuschInfo, sizeof(SchPuschInfo)); - ulAlloc->schPuschInfo = NULL; + SCH_FREE(schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo)); + schUlSlotInfo->schPuschInfo = NULL; } //send msg to MAC - ret = sendUlSchInfoToMac(&ulSchInfo, schInst); + ret = sendUlSchInfoToMac(&ulSchedInfo, schInst); if(ret != ROK) { DU_LOG("\nSending UL Sch info from SCH to MAC failed"); @@ -361,10 +360,11 @@ uint8_t schDlRsrcAllocMsg4(Msg4Alloc *msg4Alloc, SchCellCb *cell, uint16_t slot) PdcchCfg *pdcch = &msg4Alloc->msg4PdcchCfg; PdschCfg *pdsch = &msg4Alloc->msg4PdschCfg; + BwpCfg *bwp = &msg4Alloc->bwp; initialBwp = &cell->cellCfg.schInitialDlBwp; offsetPointA = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - coreset0Idx = initialBwp->pdcchCommon.raSearchSpace.coresetId; + coreset0Idx = initialBwp->pdcchCommon.commonSearchSpace.coresetId; /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */ numRbs = coresetIdxTable[coreset0Idx][1]; @@ -375,7 +375,7 @@ uint8_t schDlRsrcAllocMsg4(Msg4Alloc *msg4Alloc, SchCellCb *cell, uint16_t slot) uint16_t mask = 0x2000; for(firstSymbol=0; firstSymbol<14;firstSymbol++) { - if(initialBwp->pdcchCommon.raSearchSpace.monitoringSymbol & mask) + if(initialBwp->pdcchCommon.commonSearchSpace.monitoringSymbol & mask) break; else mask = mask>>1; @@ -384,11 +384,13 @@ uint8_t schDlRsrcAllocMsg4(Msg4Alloc *msg4Alloc, SchCellCb *cell, uint16_t slot) /* calculate the PRBs */ calculatePRB( ((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource); + /* fill BWP */ + bwp->BWPSize = initialBwp->bwp.numPrb; + bwp->BWPStart = initialBwp->bwp.firstPrb; + bwp->subcarrierSpacing = initialBwp->bwp.scs; + bwp->cyclicPrefix = initialBwp->bwp.cyclicPrefix; + /* fill the PDCCH PDU */ - pdcch->pdcchBwpCfg.BWPSize = initialBwp->bwp.numPrb; - pdcch->pdcchBwpCfg.BWPStart = initialBwp->bwp.firstPrb; - pdcch->pdcchBwpCfg.subcarrierSpacing = initialBwp->bwp.scs; - pdcch->pdcchBwpCfg.cyclicPrefix = initialBwp->bwp.cyclicPrefix; pdcch->coreset0Cfg.startSymbolIndex = firstSymbol; pdcch->coreset0Cfg.durationSymbols = numSymbols; memcpy(pdcch->coreset0Cfg.freqDomainResource,FreqDomainResource,6); @@ -400,7 +402,7 @@ uint8_t schDlRsrcAllocMsg4(Msg4Alloc *msg4Alloc, SchCellCb *cell, uint16_t slot) pdcch->coreset0Cfg.shiftIndex = cell->cellCfg.phyCellId; pdcch->coreset0Cfg.precoderGranularity = 0; /* sameAsRegBundle */ pdcch->numDlDci = 1; - pdcch->dci.rnti = cell->dlAlloc[slot]->msg4Info->crnti; + pdcch->dci.rnti = cell->schDlSlotInfo[slot]->msg4Info->crnti; pdcch->dci.scramblingId = cell->cellCfg.phyCellId; pdcch->dci.scramblingRnti = 0; pdcch->dci.cceIndex = 4; /* considering SIB1 is sent at cce 0-1-2-3 */ @@ -416,10 +418,8 @@ uint8_t schDlRsrcAllocMsg4(Msg4Alloc *msg4Alloc, SchCellCb *cell, uint16_t slot) /* fill the PDSCH PDU */ uint8_t cwCount = 0; pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */ - pdsch->rnti = cell->dlAlloc[slot]->msg4Info->crnti; + pdsch->rnti = cell->schDlSlotInfo[slot]->msg4Info->crnti; pdsch->pduIndex = 0; - pdsch->pdschBwpCfg.BWPSize = initialBwp->bwp.numPrb; - pdsch->pdschBwpCfg.BWPStart = initialBwp->bwp.firstPrb; pdsch->numCodewords = 1; for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++) { diff --git a/src/5gnrsch/sch_rach.c b/src/5gnrsch/sch_rach.c index 69d2a62df..c6f3bde66 100644 --- a/src/5gnrsch/sch_rach.c +++ b/src/5gnrsch/sch_rach.c @@ -62,6 +62,7 @@ #include "mac_sch_interface.h" #include "sch.h" #include "sch_utils.h" +#include "common_def.h" extern SchCb schCb[SCH_MAX_INST]; extern uint8_t puschDeltaTable[MAX_MU_PUSCH]; @@ -124,8 +125,8 @@ void createSchRaCb(uint16_t tcrnti, Inst schInst) uint8_t schAllocMsg3Pusch(Inst schInst, uint16_t slot, uint16_t *msg3StartRb, uint8_t *msg3NumRb) { - SchCellCb *cell = NULLP; - SchUlAlloc *ulAlloc = NULLP; + SchCellCb *cell = NULLP; + SchUlSlotInfo *schUlSlotInfo = NULLP; uint8_t puschMu = 0; uint8_t msg3SlotAlloc = 0; uint8_t delta = 0; @@ -161,26 +162,26 @@ uint8_t *msg3NumRb) for(idx=startSymb; idxulAlloc[msg3SlotAlloc]->assignedPrb[idx] = startRb + numRb; + cell->schUlSlotInfo[msg3SlotAlloc]->assignedPrb[idx] = startRb + numRb; } - ulAlloc = cell->ulAlloc[msg3SlotAlloc]; + schUlSlotInfo = cell->schUlSlotInfo[msg3SlotAlloc]; - SCH_ALLOC(ulAlloc->schPuschInfo, sizeof(SchPuschInfo)); - if(!ulAlloc->schPuschInfo) + SCH_ALLOC(schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo)); + if(!schUlSlotInfo->schPuschInfo) { DU_LOG("SCH: Memory allocation failed in schAllocMsg3Pusch"); return RFAILED; } - ulAlloc->schPuschInfo->harqProcId = SCH_HARQ_PROC_ID; - ulAlloc->schPuschInfo->resAllocType = SCH_ALLOC_TYPE_1; - ulAlloc->schPuschInfo->fdAlloc.startPrb = startRb; - ulAlloc->schPuschInfo->fdAlloc.numPrb = numRb; - ulAlloc->schPuschInfo->tdAlloc.startSymb = startSymb; - ulAlloc->schPuschInfo->tdAlloc.numSymb = symbLen; - ulAlloc->schPuschInfo->tbInfo.mcs = 4; - ulAlloc->schPuschInfo->tbInfo.ndi = 1; /* new transmission */ - ulAlloc->schPuschInfo->tbInfo.rv = 0; - ulAlloc->schPuschInfo->tbInfo.tbSize = 24; /*Considering 2 PRBs */ + schUlSlotInfo->schPuschInfo->harqProcId = SCH_HARQ_PROC_ID; + schUlSlotInfo->schPuschInfo->resAllocType = SCH_ALLOC_TYPE_1; + schUlSlotInfo->schPuschInfo->fdAlloc.startPrb = startRb; + schUlSlotInfo->schPuschInfo->fdAlloc.numPrb = numRb; + schUlSlotInfo->schPuschInfo->tdAlloc.startSymb = startSymb; + schUlSlotInfo->schPuschInfo->tdAlloc.numSymb = symbLen; + schUlSlotInfo->schPuschInfo->tbInfo.mcs = 4; + schUlSlotInfo->schPuschInfo->tbInfo.ndi = 1; /* new transmission */ + schUlSlotInfo->schPuschInfo->tbInfo.rv = 0; + schUlSlotInfo->schPuschInfo->tbInfo.tbSize = 24; /*Considering 2 PRBs */ *msg3StartRb = startRb; *msg3NumRb = numRb; @@ -206,20 +207,28 @@ uint8_t *msg3NumRb) uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst) { SchCellCb *cell = schCb[schInst].cells[schInst]; + RarInfo *rarInfo = NULLP; uint16_t raRnti = 0; - uint16_t slot; + uint16_t rarSlot = 0; uint16_t msg3StartRb; uint8_t msg3NumRb; uint8_t ret = ROK; - /* RAR will sent in the next slot */ - slot = (rachInd->timingInfo.slot+SCHED_DELTA+RAR_DELAY)%SCH_NUM_SLOTS; - SchDlAlloc *dlAlloc = cell->dlAlloc[slot]; - RarInfo *rarInfo = &(dlAlloc->rarInfo); + /* RAR will sent with a delay of RAR_DELAY */ + rarSlot = (rachInd->timingInfo.slot+RAR_DELAY+PHY_DELTA)%SCH_NUM_SLOTS; - /* rar message presense in next slot ind and will be scheduled */ - dlAlloc->rarPres = true; + SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[rarSlot]; /* RAR will sent in the next slot */ + /* Allocate the rarInfo, this pointer will be checked at schProcessSlotInd function */ + SCH_ALLOC(rarInfo, sizeof(RarInfo)); + if(rarInfo == NULLP) + { + DU_LOG("\nMAC: Memory Allocation failed for rarInfo"); + return RFAILED; + } + + schDlSlotInfo->rarInfo = rarInfo; + /* calculate the ra-rnti value */ raRnti = calculateRaRnti(rachInd->symbolIdx,rachInd->slotIdx,rachInd->freqIdx); @@ -227,10 +236,9 @@ uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst) createSchRaCb(rachInd->crnti,schInst); /* allocate resources for msg3 */ - ret = schAllocMsg3Pusch(schInst, slot, &msg3StartRb, &msg3NumRb); + ret = schAllocMsg3Pusch(schInst, rarSlot, &msg3StartRb, &msg3NumRb); if(ret == ROK) { - /* fill RAR info */ rarInfo->raRnti = raRnti; rarInfo->tcrnti = rachInd->crnti; @@ -266,12 +274,17 @@ uint8_t schFillRar(RarAlloc *rarAlloc, uint16_t raRnti, uint16_t pci, uint8_t of uint8_t numSymbols = 0; uint8_t offset = 0; uint8_t FreqDomainResource[6] = {0}; + uint16_t tbSize = 0; + uint8_t numPdschSymbols = 12; /* considering pdsch region from 2 to 13 */ + uint8_t mcs = 4; /* MCS fixed to 4 */ + SchBwpDlCfg *initialBwp = &schCb[inst].cells[inst]->cellCfg.schInitialDlBwp; PdcchCfg *pdcch = &rarAlloc->rarPdcchCfg; PdschCfg *pdsch = &rarAlloc->rarPdschCfg; + BwpCfg *bwp = &rarAlloc->bwp; - coreset0Idx = initialBwp->pdcchCommon.raSearchSpace.coresetId; + coreset0Idx = initialBwp->pdcchCommon.commonSearchSpace.coresetId; /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */ numRbs = coresetIdxTable[coreset0Idx][1]; @@ -283,7 +296,7 @@ uint8_t schFillRar(RarAlloc *rarAlloc, uint16_t raRnti, uint16_t pci, uint8_t of uint16_t mask = 0x2000; for(firstSymbol=0; firstSymbol<14;firstSymbol++) { - if(initialBwp->pdcchCommon.raSearchSpace.monitoringSymbol & mask) + if(initialBwp->pdcchCommon.commonSearchSpace.monitoringSymbol & mask) break; else mask = mask>>1; @@ -292,11 +305,13 @@ uint8_t schFillRar(RarAlloc *rarAlloc, uint16_t raRnti, uint16_t pci, uint8_t of /* calculate the PRBs */ calculatePRB( ((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource); + /* fill BWP */ + bwp->BWPSize = initialBwp->bwp.numPrb; + bwp->BWPStart = initialBwp->bwp.firstPrb; + bwp->subcarrierSpacing = initialBwp->bwp.scs; + bwp->cyclicPrefix = initialBwp->bwp.cyclicPrefix; + /* fill the PDCCH PDU */ - pdcch->pdcchBwpCfg.BWPSize = initialBwp->bwp.numPrb; - pdcch->pdcchBwpCfg.BWPStart = initialBwp->bwp.firstPrb; - pdcch->pdcchBwpCfg.subcarrierSpacing = initialBwp->bwp.scs; - pdcch->pdcchBwpCfg.cyclicPrefix = initialBwp->bwp.cyclicPrefix; pdcch->coreset0Cfg.startSymbolIndex = firstSymbol; pdcch->coreset0Cfg.durationSymbols = numSymbols; memcpy(pdcch->coreset0Cfg.freqDomainResource,FreqDomainResource,6); @@ -326,18 +341,16 @@ uint8_t schFillRar(RarAlloc *rarAlloc, uint16_t raRnti, uint16_t pci, uint8_t of pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */ pdsch->rnti = raRnti; /* RA-RNTI */ pdsch->pduIndex = 0; - pdsch->pdschBwpCfg.BWPSize = initialBwp->bwp.numPrb; - pdsch->pdschBwpCfg.BWPStart = initialBwp->bwp.firstPrb; pdsch->numCodewords = 1; for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++) { pdsch->codeword[cwCount].targetCodeRate = 308; pdsch->codeword[cwCount].qamModOrder = 2; - pdsch->codeword[cwCount].mcsIndex = 4; /* mcs configured to 4 */ - pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */ + pdsch->codeword[cwCount].mcsIndex = mcs; /* mcs configured to 4 */ + pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */ pdsch->codeword[cwCount].rvIndex = 0; - pdsch->codeword[cwCount].tbSize = 80/8; /* 38.214: Table 5.1.3.2-1, - devided by 8 to get the value in bytes */ + tbSize = schCalcTbSize(10); /* 8 bytes RAR and 2 bytes padding */ + pdsch->codeword[cwCount].tbSize = tbSize; } pdsch->dataScramblingId = pci; pdsch->numLayers = 1; @@ -351,11 +364,7 @@ uint8_t schFillRar(RarAlloc *rarAlloc, uint16_t raRnti, uint16_t pci, uint8_t of pdsch->dmrs.dmrsPorts = 0; pdsch->freqAlloc.resourceAlloc = 1; /* RAT type-1 RIV format */ pdsch->freqAlloc.rbStart = offset + SCH_SSB_PRB_DURATION; /* the RB numbering starts from coreset0, and PDSCH is always above SSB */ - /* formula used for calculation of rbSize, 38.213 section 5.1.3.2 * - * Ninfo = S . Nre . R . Qm . v * - * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh * - * Nre = min(156,Nre') . nPrb */ - pdsch->freqAlloc.rbSize = 1; /* This value is calculated from above formulae */ + pdsch->freqAlloc.rbSize = schCalcNumPrb(tbSize,mcs,numPdschSymbols); pdsch->freqAlloc.vrbPrbMapping = 0; /* non-interleaved */ pdsch->timeAlloc.startSymbolIndex = initialBwp->pdschCommon.startSymbol; pdsch->timeAlloc.numSymbols = initialBwp->pdschCommon.lengthSymbol; diff --git a/src/5gnrsch/sch_slot_ind.c b/src/5gnrsch/sch_slot_ind.c index 604ad1feb..bb62aa265 100644 --- a/src/5gnrsch/sch_slot_ind.c +++ b/src/5gnrsch/sch_slot_ind.c @@ -61,6 +61,7 @@ File: sch_slot_ind.c #include "mac_sch_interface.h" #include "sch.h" #include "sch_utils.h" +#include "common_def.h" SchMacDlAllocFunc schMacDlAllocOpts[] = { @@ -89,7 +90,7 @@ offsetPointA); * RFAILED - failure * * ****************************************************************/ -int sendDlAllocToMac(DlAlloc *dlAlloc, Inst inst) +int sendDlAllocToMac(DlSchedInfo *dlSchedInfo, Inst inst) { Pst pst; @@ -97,10 +98,49 @@ int sendDlAllocToMac(DlAlloc *dlAlloc, Inst inst) SCH_FILL_RSP_PST(pst, inst); pst.event = EVENT_DL_ALLOC; - return(*schMacDlAllocOpts[pst.selector])(&pst, dlAlloc); + return(*schMacDlAllocOpts[pst.selector])(&pst, dlSchedInfo); } + +/******************************************************************* + * + * @brief Handles slot indication at SCH + * + * @details + * + * Function : schCalcSlotValues + * + * Functionality: + * Handles TTI indication received from PHY + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void schCalcSlotValues(SlotIndInfo slotInd, SchSlotValue *schSlotValue) +{ + /**************************************************************** + * PHY_DELTA - the physical layer delta * + * SCHED_DELTA - scheduler schedules one slot ahead * + * BO_DELTA - this delay is considered for BO response and * + * RLC buffer packet to received at MAC * + * lower-mac (FAPI filling) will be working on PHY_DELTA * + * brdcast scheduler will working on PHY_DELTA + SCHED_DELTA * + * RAR scheduler will working on PHY_DELTA + SCHED_DELTA * + * msg4 scheduler will working on PHY_DELTA + SCHED_DELTA * + * dedicated DL msg scheduler will working * + * on PHY_DELTA + SCHED_DELTA + BO_DELTA * + ****************************************************************/ + + ADD_DELTA_TO_TIME(slotInd,schSlotValue->currentTime,PHY_DELTA); + ADD_DELTA_TO_TIME(slotInd,schSlotValue->broadcastTime,PHY_DELTA+SCHED_DELTA); + ADD_DELTA_TO_TIME(slotInd,schSlotValue->rarTime,PHY_DELTA+SCHED_DELTA); + ADD_DELTA_TO_TIME(slotInd,schSlotValue->msg4Time,PHY_DELTA+SCHED_DELTA); + ADD_DELTA_TO_TIME(slotInd,schSlotValue->dlMsgTime,PHY_DELTA+SCHED_DELTA+BO_DELTA); +} + /******************************************************************* * * @brief Handles slot indication at SCH @@ -121,40 +161,27 @@ uint8_t schProcessSlotInd(SlotIndInfo *slotInd, Inst schInst) { int ret = ROK; uint8_t ssb_rep; - uint16_t sfn = slotInd->sfn; - uint16_t slot = slotInd->slot; uint16_t sfnSlot = 0; - DlAlloc dlAlloc; - memset(&dlAlloc,0,sizeof(DlAlloc)); - DlBrdcstAlloc *dlBrdcstAlloc = &dlAlloc.brdcstAlloc; - RarAlloc *rarAlloc = &dlAlloc.rarAlloc; + DlSchedInfo dlSchedInfo; + memset(&dlSchedInfo,0,sizeof(DlSchedInfo)); + DlBrdcstAlloc *dlBrdcstAlloc = &dlSchedInfo.brdcstAlloc; + RarAlloc *rarAlloc; Msg4Alloc *msg4Alloc; dlBrdcstAlloc->ssbTrans = NO_SSB; dlBrdcstAlloc->sib1Trans = NO_SIB1; - SchCellCb *cell = schCb[schInst].cells[schInst]; -#ifdef LTE_L2_MEAS - glblTtiCnt++; -#endif - -// schDlResAlloc(cell, slotInd); + schCalcSlotValues(*slotInd, &dlSchedInfo.schSlotValue); ssb_rep = cell->cellCfg.ssbSchCfg.ssbPeriod; memcpy(&cell->slotInfo, slotInd, sizeof(SlotIndInfo)); dlBrdcstAlloc->ssbIdxSupported = 1; - if((slot + SCHED_DELTA) >= SCH_NUM_SLOTS) - { - sfn = (sfn+1)%SCH_MAX_SFN; - } - slot = ((slot + SCHED_DELTA) % SCH_NUM_SLOTS); - sfnSlot = ((sfn * 10) + slot); + sfnSlot = ((dlSchedInfo.schSlotValue.broadcastTime.sfn * 10) + + dlSchedInfo.schSlotValue.broadcastTime.slot); - dlAlloc.slotIndInfo.sfn = sfn; - dlAlloc.slotIndInfo.slot = slot; - dlAlloc.cellId = cell->cellId; + dlSchedInfo.cellId = cell->cellId; /* Identify SSB ocassion*/ if (sfnSlot % SCH_MIB_TRANS == 0) @@ -186,8 +213,8 @@ uint8_t schProcessSlotInd(SlotIndInfo *slotInd, Inst schInst) if(dlBrdcstAlloc->ssbTrans || dlBrdcstAlloc->sib1Trans) { - dlAlloc.isBroadcastPres = true; - ret = schBroadcastAlloc(cell, dlBrdcstAlloc,slot); + dlSchedInfo.isBroadcastPres = true; + ret = schBroadcastAlloc(cell,dlBrdcstAlloc,dlSchedInfo.schSlotValue.broadcastTime.slot); if(ret != ROK) { DU_LOG("\nschBroadcastAlloc failed"); @@ -196,23 +223,33 @@ uint8_t schProcessSlotInd(SlotIndInfo *slotInd, Inst schInst) } /* check for RAR */ - if(cell->dlAlloc[slot]->rarPres == true) + if(cell->schDlSlotInfo[dlSchedInfo.schSlotValue.rarTime.slot]->rarInfo != NULLP) { - dlAlloc.isRarPres = true; + SCH_ALLOC(rarAlloc, sizeof(RarAlloc)); + if(!rarAlloc) + { + DU_LOG("\nMAC: Memory Allocation failed for RAR alloc"); + return RFAILED; + } + + dlSchedInfo.rarAlloc = rarAlloc; + /* RAR info is copied, this was earlier filled in schProcessRachInd */ - memcpy(&rarAlloc->rarInfo, &cell->dlAlloc[slot]->rarInfo, sizeof(RarInfo)); + memcpy(&rarAlloc->rarInfo,cell->schDlSlotInfo[dlSchedInfo.schSlotValue.rarTime.slot]->rarInfo, \ + sizeof(RarInfo)); - /* pdcch and pdsch data is filled */ - schFillRar(rarAlloc, - cell->dlAlloc[slot]->rarInfo.raRnti, - cell->cellCfg.phyCellId, - cell->cellCfg.ssbSchCfg.ssbOffsetPointA); + /* pdcch and pdsch data is filled */ + schFillRar(rarAlloc, + cell->schDlSlotInfo[dlSchedInfo.schSlotValue.rarTime.slot]->rarInfo->raRnti, + cell->cellCfg.phyCellId, + cell->cellCfg.ssbSchCfg.ssbOffsetPointA); - cell->dlAlloc[slot]->rarPres = false; + SCH_FREE(cell->schDlSlotInfo[dlSchedInfo.schSlotValue.rarTime.slot]->rarInfo,sizeof(RarAlloc)); + cell->schDlSlotInfo[dlSchedInfo.schSlotValue.rarTime.slot]->rarInfo = NULLP; } /* check for MSG4 */ - if(cell->dlAlloc[slot]->msg4Info) + if(cell->schDlSlotInfo[dlSchedInfo.schSlotValue.msg4Time.slot]->msg4Info != NULLP) { SCH_ALLOC(msg4Alloc, sizeof(Msg4Alloc)); if(!msg4Alloc) @@ -221,21 +258,21 @@ uint8_t schProcessSlotInd(SlotIndInfo *slotInd, Inst schInst) return RFAILED; } - dlAlloc.msg4Alloc = msg4Alloc; + dlSchedInfo.msg4Alloc = msg4Alloc; /* Msg4 info is copied, this was earlier filled in macSchDlRlcBoInfo */ - memcpy(&msg4Alloc->msg4Info, cell->dlAlloc[slot]->msg4Info, \ + memcpy(&msg4Alloc->msg4Info, cell->schDlSlotInfo[dlSchedInfo.schSlotValue.msg4Time.slot]->msg4Info, \ sizeof(Msg4Info)); /* pdcch and pdsch data is filled */ - schDlRsrcAllocMsg4(msg4Alloc, cell, slot); - SCH_FREE(cell->dlAlloc[slot]->msg4Info, sizeof(Msg4Info)); - cell->dlAlloc[slot]->msg4Info = NULL; + schDlRsrcAllocMsg4(msg4Alloc, cell, dlSchedInfo.schSlotValue.msg4Time.slot); + SCH_FREE(cell->schDlSlotInfo[dlSchedInfo.schSlotValue.msg4Time.slot]->msg4Info, sizeof(Msg4Info)); + cell->schDlSlotInfo[dlSchedInfo.schSlotValue.msg4Time.slot]->msg4Info = NULL; } /* send msg to MAC */ - ret = sendDlAllocToMac(&dlAlloc, schInst); + ret = sendDlAllocToMac(&dlSchedInfo, schInst); if(ret != ROK) { DU_LOG("\nSending DL Broadcast allocation from SCH to MAC failed"); diff --git a/src/5gnrsch/sch_utils.c b/src/5gnrsch/sch_utils.c index 0a79d678b..b3d038d88 100644 --- a/src/5gnrsch/sch_utils.c +++ b/src/5gnrsch/sch_utils.c @@ -382,12 +382,58 @@ uint16_t prachCfgIdxTable[MAX_PRACH_CONFIG_IDX][8] = { /* Defintion of delta value Table 6.1.2.1.1-5 spec 38.214 */ uint8_t puschDeltaTable[MAX_MU_PUSCH] = { 2, 3, 4, 6 }; +uint16_t tbSizeTable[TOTAL_TBSIZE_VALUES] = { + 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, \ + 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, \ + 184, 192, 208, 224, 240, 256, 272, 288, 304, 320, \ + 336, 352, 368, 384, 408, 432, 456, 480, 504, 528, \ + 552, 576, 608, 640, 672, 704, 736, 768, 808, 848, \ + 888, 928, 984, 1032, 1064, 1128, 1160, 1192, 1224, 1256, \ + 1288, 1320, 1352, 1416, 1480, 1544, 1608, 1672, 1736, 1800, \ + 1864, 1928, 2024, 2088, 2152, 2216, 2280, 2408, 2472, 2536, \ + 2600, 2664, 2728, 2792, 2856, 2976, 3104, 3240, 3368, 3496, \ + 3624, 3752, 3824 }; + +uint16_t mcsTable[32][3] = { + { 0, 2, 120}, /* mcs index 0 */ + { 1, 2, 157}, /* mcs index 1 */ + { 2, 2, 193}, /* mcs index 2 */ + { 3, 2, 251}, /* mcs index 3 */ + { 4, 2, 308}, /* mcs index 4 */ + { 5, 2, 379}, /* mcs index 5 */ + { 6, 2, 449}, /* mcs index 6 */ + { 7, 2, 526}, /* mcs index 7 */ + { 8, 2, 602}, /* mcs index 8 */ + { 9, 2, 679}, /* mcs index 9 */ + { 10, 4, 340}, /* mcs index 10 */ + { 11, 4, 378}, /* mcs index 11 */ + { 12, 4, 434}, /* mcs index 12 */ + { 13, 4, 490}, /* mcs index 13 */ + { 14, 4, 553}, /* mcs index 14 */ + { 15, 4, 616}, /* mcs index 15 */ + { 16, 4, 658}, /* mcs index 16 */ + { 17, 6, 438}, /* mcs index 17 */ + { 18, 6, 466}, /* mcs index 18 */ + { 19, 6, 517}, /* mcs index 19 */ + { 20, 6, 567}, /* mcs index 20 */ + { 21, 6, 616}, /* mcs index 21 */ + { 22, 6, 666}, /* mcs index 22 */ + { 23, 6, 719}, /* mcs index 23 */ + { 24, 6, 772}, /* mcs index 24 */ + { 25, 6, 822}, /* mcs index 25 */ + { 26, 6, 873}, /* mcs index 26 */ + { 27, 6, 910}, /* mcs index 27 */ + { 28, 6, 948}, /* mcs index 28 */ + { 29, 2, 0}, /* mcs index 29 */ + { 30, 4, 0}, /* mcs index 30 */ + { 31, 6, 0}}; /* mcs index 31 */ + /** * @brief frequency domain allocation function. * * @details * - * Function: canclulatePRB + * Function: calculatePRB * * This function does allocation in frequency domain resource. using * bitwise operator, the bits are set for the PRBs. @@ -439,6 +485,72 @@ void calculatePRB(uint16_t startPrb, uint16_t prbSize, uint8_t *freqDomain) } } +/** + * @brief frequency domain allocation function. + * + * @details + * + * Function: schCalcTbSize + * + * This function finds the TBSize from table Table 5.1.3.2-1 spec 38.214 + * + * @param[in] payLoadSize - size of payload + * @return TBsize from the Table + **/ +uint16_t schCalcTbSize(uint16_t payLoadSize) +{ + uint8_t tbsIndex = 0; + payLoadSize = payLoadSize*8; + + while(payLoadSize > tbSizeTable[tbsIndex]) + { + tbsIndex++; + } + + /* return the TBsize in bytes */ + return (tbSizeTable[tbsIndex]/8); +} + +/** + * @brief frequency domain allocation function. + * + * @details + * + * Function: schCalcNumPrb + * + * This function calculates the number of PRbs + * + * @param[in] tbSize + * @param[in] mcs + * @param[in] number of symbols + * @return number PRBs + **/ +uint16_t schCalcNumPrb(uint16_t tbSize, uint16_t mcs, uint8_t numSymbols) +{ + uint16_t numPrb = 0; + uint16_t nre = 0; + uint16_t nreDash = 0; + uint8_t qm = mcsTable[mcs][1]; + uint16_t rValue = mcsTable[mcs][2]; + uint8_t numLayer = 1; /* v value */ + uint8_t numDmrsSymbols = 12; /* considering whole of one symbols with 12 SCs for DMRS */ + + /* formula used for calculation of rbSize, 38.213 section 5.1.3.2 * + * Ninfo = Nre . R . Qm . v * + * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh * + * Nre = min(156,Nre') . nPrb */ + + nre = ceil( (float)tbSize * 1024 / (qm * rValue * numLayer)); + + nreDash = ceil( (12 * numSymbols) - numDmrsSymbols - 0); + + if (nreDash > 156) + nre = 156; + + numPrb = ceil((float)nre / nreDash); + return numPrb; +} + /********************************************************************** End of file **********************************************************************/ diff --git a/src/5gnrsch/sch_utils.h b/src/5gnrsch/sch_utils.h index 6616e3ab5..5d86c4eec 100644 --- a/src/5gnrsch/sch_utils.h +++ b/src/5gnrsch/sch_utils.h @@ -24,7 +24,7 @@ #define MAX_RACH_NUM_RB_IDX 16 #define MAX_PRACH_CONFIG_IDX 256 #define MAX_MU_PUSCH 4 - +#define TOTAL_TBSIZE_VALUES 93 #define SET_BITS(_startBit, _numBits, _byte) \ { \ _byte = (((~((~0)<<_numBits))<<_startBit)); \ diff --git a/src/cm/common_def.h b/src/cm/common_def.h new file mode 100644 index 000000000..7ef5121dd --- /dev/null +++ b/src/cm/common_def.h @@ -0,0 +1,20 @@ +/******************************************************************************* +################################################################################ +# Copyright (c) [2017-2019] [Radisys] # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +################################################################################ +*******************************************************************************/ + +/* 5G ORAN phy delay */ +#define PHY_DELTA 2 diff --git a/src/cm/du_app_mac_inf.h b/src/cm/du_app_mac_inf.h index 3b1c5585e..907573c27 100644 --- a/src/cm/du_app_mac_inf.h +++ b/src/cm/du_app_mac_inf.h @@ -29,8 +29,15 @@ #define SIB1_NEW_TX_PERIOD 160 #define SIB1_REPETITION_PERIOD 20 #define CORESET_0_INDEX 0 +#define CORESET_1_INDEX 1 +#define CORESET_2_INDEX 2 +#define CORESET_3_INDEX 3 +#define CORESET_4_INDEX 4 #define SEARCHSPACE_0_INDEX 0 #define SEARCHSPACE_1_INDEX 1 +#define SEARCHSPACE_2_INDEX 2 +#define SEARCHSPACE_3_INDEX 3 +#define SEARCHSPACE_4_INDEX 4 #define SS_MONITORING_SLOT_SL1 0 /* all slots */ #define SS_MONITORING_SYMBOL 0x2000; /* symbol-0, set 14th bit */ #define SIB1_MCS 4 @@ -225,7 +232,9 @@ typedef struct searchSpaceCfg typedef struct pdcchConfigCommon { - SearchSpaceCfg raSearchSpace; + /* only one search space is configured during SIB1 */ + SearchSpaceCfg commonSearchSpace; + uint8_t raSearchSpaceId; }PdcchConfigCommon; typedef struct pdschConfigCommon diff --git a/src/cm/mac_sch_interface.c b/src/cm/mac_sch_interface.c index be2439c47..d870a0036 100644 --- a/src/cm/mac_sch_interface.c +++ b/src/cm/mac_sch_interface.c @@ -1,4 +1,5 @@ /* header include files (.h) */ +#include "stdbool.h" #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ @@ -154,11 +155,11 @@ uint8_t packMacSchDlRlcBoInfo(Pst *pst, DlRlcBOInfo *dlBoInfo) * * * @param[in] Pst *pst, the post structure - * @param[in] DlAlloc *dlAlloc + * @param[in] DlSchedInfo *dlSchedInfo * @return S16 * -# ROK **/ -int packSchMacDlAlloc(Pst *pst, DlAlloc *dlAlloc) +int packSchMacDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo) { return ROK; } @@ -173,11 +174,11 @@ int packSchMacDlAlloc(Pst *pst, DlAlloc *dlAlloc) * * * @param[in] Pst *pst, the post structure - * @param[in] *ulSchInfo, UlSchInfo + * @param[in] UlSchedInfo *ulSchedInfo * @return S16 * -# ROK **/ -int packSchMacUlSchInfo(Pst *pst, UlSchInfo *ulSchInfo) +int packSchMacUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo) { return ROK; } diff --git a/src/cm/mac_sch_interface.h b/src/cm/mac_sch_interface.h index 6fc4caf9e..78faf021a 100644 --- a/src/cm/mac_sch_interface.h +++ b/src/cm/mac_sch_interface.h @@ -55,8 +55,20 @@ #define MAX_NUMBER_OF_CRC_IND_BITS 1 #define MAX_NUM_LOGICAL_CHANNELS 11 - +/* can we have a common numslot numscs between mac sch */ +#define MAX_SLOTS 10 +#define MAX_SFN 1024 #define CCCH_LCID 0 +#define ADD_DELTA_TO_TIME(crntTime, toFill, incr) \ + if ((crntTime.slot + incr) > (MAX_SLOTS - 1)) \ + toFill.sfn = (crntTime.sfn + 1); \ + else \ + toFill.sfn = crntTime.sfn; \ + toFill.slot = (crntTime.slot + incr) % MAX_SLOTS; \ + if (toFill.sfn >= MAX_SFN) \ + { \ + toFill.sfn%=MAX_SFN; \ + } \ /*structures*/ @@ -148,7 +160,6 @@ typedef struct pdschCfg uint16_t pduBitmap; uint16_t rnti; uint16_t pduIndex; - BwpCfg pdschBwpCfg; uint8_t numCodewords; CodewordInfo codeword[MAX_CODEWORDS]; uint16_t dataScramblingId; @@ -201,7 +212,6 @@ typedef struct dlDCI typedef struct pdcchCfg { - BwpCfg pdcchBwpCfg; /* coreset-0 configuration */ CoresetCfg coreset0Cfg; @@ -222,6 +232,7 @@ typedef struct /* parameters derived in scheduler */ uint8_t n0; + BwpCfg bwp; PdcchCfg sib1PdcchCfg; PdschCfg sib1PdschCfg; }SchSib1Cfg; @@ -271,7 +282,8 @@ typedef struct schSearchSpaceCfg typedef struct schPdcchCfgCmn { - SchSearchSpaceCfg raSearchSpace; + SchSearchSpaceCfg commonSearchSpace; + uint8_t raSearchSpaceId; }SchPdcchCfgCmn; typedef struct schPdschCfgCmn @@ -344,6 +356,7 @@ typedef struct ssbInfo typedef struct sib1AllocInfo { + BwpCfg bwp; PdcchCfg sib1PdcchCfg; PdschCfg sib1PdschCfg; } Sib1AllocInfo; @@ -389,6 +402,7 @@ typedef struct rarInfo typedef struct rarAlloc { RarInfo rarInfo; + BwpCfg bwp; PdcchCfg rarPdcchCfg; PdschCfg rarPdschCfg; }RarAlloc; @@ -410,26 +424,36 @@ typedef struct msg4Info typedef struct msg4Alloc { Msg4Info msg4Info; + BwpCfg bwp; PdcchCfg msg4PdcchCfg; PdschCfg msg4PdschCfg; }Msg4Alloc; -typedef struct dlAlloc +typedef struct schSlotValue +{ + SlotIndInfo currentTime; + SlotIndInfo broadcastTime; + SlotIndInfo rarTime; + SlotIndInfo msg4Time; + SlotIndInfo dlMsgTime; +}SchSlotValue; + +typedef struct dlSchedInfo { uint16_t cellId; /* Cell Id */ - SlotIndInfo slotIndInfo; /* Slot Info: sfn, slot number */ + SchSlotValue schSlotValue; /* Allocation for broadcast messages */ - uint8_t isBroadcastPres; + bool isBroadcastPres; DlBrdcstAlloc brdcstAlloc; /* Allocation for RAR message */ - uint8_t isRarPres; - RarAlloc rarAlloc; + //uint8_t isRarPres; + RarAlloc *rarAlloc; /* Allocation from MSG4 */ Msg4Alloc *msg4Alloc; -}DlAlloc; +}DlSchedInfo; typedef struct tbInfo { @@ -449,7 +473,7 @@ typedef struct schPuschInfo }SchPuschInfo; -typedef struct ulSchInfo +typedef struct ulSchedInfo { uint16_t cellId; /* Cell Id */ uint16_t crnti; /* CRNI */ @@ -457,7 +481,7 @@ typedef struct ulSchInfo uint8_t dataType; /* Type of info being scheduled */ PrachSchInfo prachSchInfo; /* Prach scheduling info */ SchPuschInfo schPuschInfo; /* Pusch scheduling info */ -}UlSchInfo; +}UlSchedInfo; typedef struct rachIndInfo { @@ -510,28 +534,28 @@ typedef int (*SchCellCfgFunc) ARGS(( typedef int (*SchMacDlAllocFunc) ARGS(( Pst *pst, /* Post Structure */ - DlAlloc *dlAlloc /* dl allocation Info */ + DlSchedInfo *dlSchedInfo /* dl allocation Info */ )); typedef int (*SchMacUlSchInfoFunc) ARGS(( - Pst *pst, /* Post Structure */ - UlSchInfo *ulSchInfo /* UL Sch Info */ + Pst *pst, /* Post Structure */ + UlSchedInfo *ulSchedInfo /* UL Alloc Sch Info */ )); /* function declarations */ int packMacSchSlotInd(Pst *pst, SlotIndInfo *slotInd); -int packSchMacDlAlloc(Pst *pst, DlAlloc *dlAlloc); -int packSchMacUlSchInfo(Pst *pst, UlSchInfo *ulSchInfo); +int packSchMacDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo); +int packSchMacUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo); EXTERN int packSchCellCfg(Pst *pst, SchCellCfg *schCellCfg); EXTERN int packSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm); -EXTERN int MacProcDlAlloc(Pst *pst, DlAlloc *dlAlloc); +EXTERN int MacProcDlAlloc(Pst *pst, DlSchedInfo *dlSchedInfo); EXTERN int MacProcSchCellCfg(Pst *pst, SchCellCfg *schCellCfg); EXTERN int MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm); EXTERN int SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg); EXTERN int schActvInit(Ent entity, Inst instId, Region region, Reason reason); EXTERN S16 SchSendCfgCfm(Pst *pst, RgMngmt *cfm); -EXTERN int MacProcUlSchInfo(Pst *pst, UlSchInfo *ulSchInfo); +EXTERN int MacProcUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo); typedef int (*MacSchRachIndFunc)(Pst *pst, RachIndInfo *rachInd); int packMacSchRachInd(Pst *pst, RachIndInfo *rachInd); int macSchRachInd(Pst *pst, RachIndInfo *rachInd); diff --git a/src/du_app/du_cfg.c b/src/du_app/du_cfg.c index 05aefd07d..b1ebacb0d 100644 --- a/src/du_app/du_cfg.c +++ b/src/du_app/du_cfg.c @@ -234,22 +234,22 @@ S16 readMacCfg() duCfgParam.macCellCfg.initialDlBwp.bwp.numPrb = TOTAL_PRB_BW; /* configured to total BW */ duCfgParam.macCellCfg.initialDlBwp.bwp.scs = SUBCARRIER_SPACING; /* numerology is 0, 15Khz */ duCfgParam.macCellCfg.initialDlBwp.bwp.cyclicPrefix = NORMAL_CYCLIC_PREFIX; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace.searchSpaceId = SEARCHSPACE_1_INDEX; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace.coresetId = CORESET_0_INDEX; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace.monitoringSlot = + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId = SEARCHSPACE_1_INDEX; + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.coresetId = CORESET_0_INDEX; + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot = SS_MONITORING_SLOT_SL1; /* sl1 - all slots */ - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace.duration = 0; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace.monitoringSymbol = + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.duration = 0; + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol = SS_MONITORING_SYMBOL; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace. + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace. candidate.aggLevel1 = 8; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace. + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace. candidate.aggLevel2 = 4; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace. + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace. candidate.aggLevel4 = 2; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace. + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace. candidate.aggLevel8 = 1; - duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpace. + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.commonSearchSpace. candidate.aggLevel16 = 0; duCfgParam.macCellCfg.initialDlBwp.pdschCommon.k0 = PDSCH_K0; duCfgParam.macCellCfg.initialDlBwp.pdschCommon.mappingType = @@ -258,8 +258,9 @@ S16 readMacCfg() PDSCH_START_SYMBOL; duCfgParam.macCellCfg.initialDlBwp.pdschCommon.lengthSymbol = PDSCH_LENGTH_SYMBOL; - - /* fill Intial DL BWP */ + /* ra-searchSpace ID is set to 1 */ + duCfgParam.macCellCfg.initialDlBwp.pdcchCommon.raSearchSpaceId = SEARCHSPACE_1_INDEX; + /* fill Intial UL BWP */ duCfgParam.macCellCfg.initialUlBwp.bwp.firstPrb = 0; duCfgParam.macCellCfg.initialUlBwp.bwp.numPrb = TOTAL_PRB_BW; /* configured to total BW */ duCfgParam.macCellCfg.initialUlBwp.bwp.scs = SUBCARRIER_SPACING; /* numerology is 0, 15Khz */ diff --git a/src/phy_stub/l1_bdy1.c b/src/phy_stub/l1_bdy1.c index 086cd1e2c..6a21f117e 100644 --- a/src/phy_stub/l1_bdy1.c +++ b/src/phy_stub/l1_bdy1.c @@ -595,7 +595,7 @@ PUBLIC S16 l1HdlDlTtiReq(uint16_t msgLen, void *msg) fapi_dl_tti_req_t *dlTtiReq; dlTtiReq = (fapi_dl_tti_req_t *)msg; - printf("\nPHY STUB: Received DL TTI Request"); + printf("\nPHY STUB: DL TTI Request at sfn=%d slot=%d",dlTtiReq->sfn,dlTtiReq->slot); #if 0 printf("\nPHY_STUB: SFN %d", dlTtiReq->sfn); printf("\nPHY_STUB: SLOT %d", dlTtiReq->slot); @@ -656,7 +656,7 @@ PUBLIC S16 l1HdlTxDataReq(uint16_t msgLen, void *msg) fapi_tx_data_req_t *txDataReq; txDataReq = (fapi_tx_data_req_t *)msg; - DU_LOG("\nPHY STUB: Received TX DATA Request"); + DU_LOG("\nPHY STUB: TX DATA Request at sfn=%d slot=%d",txDataReq->sfn,txDataReq->slot); MAC_FREE(txDataReq, msgLen); #endif -- 2.16.6