From 154ac5a3676b120c741184f7e58627df8003b5c0 Mon Sep 17 00:00:00 2001 From: "lal.harshita" Date: Mon, 15 Nov 2021 23:03:44 +0530 Subject: [PATCH] Signed-off-by: barveankit --- src/5gnrmac/lwr_mac_fsm.c | 3 +- src/5gnrmac/mac.h | 2 + src/5gnrmac/mac_demux.c | 331 ++++++++++++++++++------------- src/5gnrmac/mac_msg_hdl.c | 44 +++++ src/5gnrmac/mac_utils.c | 41 +++- src/5gnrmac/mac_utils.h | 2 + src/5gnrrlc/rlc_msg_hdl.c | 100 +++++----- src/5gnrrlc/rlc_upr_inf_mgr.c | 12 +- src/5gnrrlc/rlc_utl_dl.c | 24 +-- src/5gnrsch/sch.c | 122 ++++++++---- src/5gnrsch/sch.h | 19 +- src/5gnrsch/sch_common.c | 386 +++++++++++++++++++++++++++++-------- src/5gnrsch/sch_slot_ind.c | 25 ++- src/5gnrsch/sch_ue_mgr.c | 28 ++- src/5gnrsch/sch_utils.c | 24 +-- src/cm/mac_sch_interface.h | 2 + src/cu_stub/cu_f1ap_msg_hdl.c | 2 +- src/phy_stub/phy_stub.h | 13 ++ src/phy_stub/phy_stub_msg_hdl.c | 146 +++++++++++++- src/phy_stub/phy_stub_thread_hdl.c | 47 ++++- 20 files changed, 988 insertions(+), 385 deletions(-) diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index 538711e8d..5f8e04948 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -3463,7 +3463,6 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo) pduIndex++; numPduEncoded++; } - DU_LOG("\033[1;34m"); DU_LOG("\nDEBUG --> LWR_MAC: SIB1 sent..."); DU_LOG("\033[0m"); @@ -3705,7 +3704,7 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, DlSchedInfo *dlInfo, p_fap for(schInfoIdx=0; schInfoIdx < dlInfo->dlMsgAlloc[ueIdx]->numSchedInfo; schInfoIdx++) { if((dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == BOTH) || \ - (dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == PDSCH_PDU)) + (dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == PDSCH_PDU)) { fillDlMsgTxDataReq(txDataReq->pdu_desc, pduIndex, \ &dlInfo->dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo, \ diff --git a/src/5gnrmac/mac.h b/src/5gnrmac/mac.h index 68907fae6..bb154924a 100644 --- a/src/5gnrmac/mac.h +++ b/src/5gnrmac/mac.h @@ -258,6 +258,8 @@ uint8_t macProcShortBsr(uint16_t cellId, uint16_t crnti, uint8_t lcgId, uint32_t uint8_t macProcUlData(uint16_t cellId, uint16_t rnti, SlotTimingInfo slotInfo, \ uint8_t lcId, uint16_t pduLen, uint8_t *pdu); uint8_t sendSchedRptToRlc(DlSchedInfo dlInfo, SlotTimingInfo slotInfo, uint8_t ueIdx, uint8_t schInfoIdx); +uint8_t macProcLongBsr(uint16_t cellId, uint16_t crnti,uint8_t numLcg,\ + DataVolInfo dataVolInfo[MAX_NUM_LOGICAL_CHANNEL_GROUPS]); #endif /********************************************************************** End of file diff --git a/src/5gnrmac/mac_demux.c b/src/5gnrmac/mac_demux.c index 1ef38febb..a54228dd5 100644 --- a/src/5gnrmac/mac_demux.c +++ b/src/5gnrmac/mac_demux.c @@ -49,7 +49,7 @@ uint8_t unpackRxData(uint16_t cellId, SlotTimingInfo slotInfo, RxDataIndPdu *rxD uint8_t ueIdx = 0; /* Iterator for UE list */ uint8_t lcId = 0; /* LC ID of a sub pdu */ uint8_t fBit = 0; /* Value of F Bit in MAC sub-header */ - uint8_t idx = 0; /* Iterator for received PDU */ + uint8_t rxPduIdx = 0; /* Iterator for received PDU */ uint16_t length = 0; /* Length of payload in a sub-PDU */ uint8_t *pdu = NULLP; /* Payload in sub-PDU */ uint16_t pduLen = 0; /* Length of undecoded PDU */ @@ -58,6 +58,18 @@ uint8_t unpackRxData(uint16_t cellId, SlotTimingInfo slotInfo, RxDataIndPdu *rxD uint8_t ret =ROK; GET_CELL_IDX(cellId, cellIdx); + + if(rxDataIndPdu == NULLP) + { + DU_LOG("\nERROR --> MAC: Rx Data is empty"); + return RFAILED; + } + + if(macCb.macCell[cellIdx] == NULLP) + { + DU_LOG("\nERROR --> CellId :%d is not created, as CellCB is empty", cellId); + return RFAILED; + } pduLen = rxDataIndPdu->pduLength; rxDataPdu = rxDataIndPdu->pduData; GET_UE_IDX(rxDataIndPdu->rnti, ueIdx); @@ -66,153 +78,194 @@ uint8_t unpackRxData(uint16_t cellId, SlotTimingInfo slotInfo, RxDataIndPdu *rxD while(pduLen > 0) { /* MSB in 1st octet is Reserved bit. Hence not decoding it. - 2nd MSB in 1st octet is R/F bit depending upon type of payload */ - fBit = (1 << 7) & rxDataPdu[idx]; + 2nd MSB in 1st octet is R/F bit depending upon type of payload */ + fBit = (1 << 7) & rxDataPdu[rxPduIdx]; /* LC id is the 6 LSB in 1st octet */ - lcId = (~((~0) << 6)) & rxDataPdu[idx]; + lcId = (~((~0) << 6)) & rxDataPdu[rxPduIdx]; + pdu = NULLP; switch(lcId) { - case MAC_LCID_CCCH : - { - pduLen--; - - /* for UL CCCH,fixed length of MAC SDU */ - length = 6; - - /* Allocating sharable memory to send ul ccch msg to du app*/ - MAC_ALLOC_SHRABL_BUF(pdu, length); - if(!pdu) - { - DU_LOG("\nERROR --> MAC : UL CCCH PDU memory allocation failed"); - return RFAILED; - } - idx++; - memcpy(pdu, &rxDataPdu[idx], length); - pduLen -= length; - idx = idx + length; - - /* store msg3 pdu in macRaCb for CRI value */ - memcpy(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg3Pdu, pdu, length); - - /* Send UL-CCCH Indication to DU APP */ - ret = macProcUlCcchInd(macCb.macCell[cellIdx]->cellId, rxDataIndPdu->rnti, length, pdu); - break; - } - - case MAC_LCID_MIN ... MAC_LCID_MAX : - { - DU_LOG("\nINFO --> MAC : PDU received for LC ID %d", lcId); - pduLen--; - idx++; - - length = rxDataPdu[idx]; - if(fBit) - { - pduLen--; - idx++; - length = (length << 8) & rxDataPdu[idx]; - } - - /* Copying the payload to send to RLC */ - MAC_ALLOC_SHRABL_BUF(pdu, length); - if(!pdu) - { - DU_LOG("\nERROR --> MAC : Memory allocation failed while demuxing Rx Data PDU"); - return RFAILED; - } - pduLen--; - idx++; - memcpy(pdu, &rxDataPdu[idx], length); - pduLen -= length; - idx = idx + length; - - /* Delete RA cb once RRC setup complete received */ - if(macCb.macCell[cellIdx]->macRaCb[ueIdx].crnti == rxDataIndPdu->rnti) - { - MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu, \ - macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); - MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, \ - macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize - TX_PAYLOAD_HDR_LEN); - memset(&macCb.macCell[cellIdx]->macRaCb[ueIdx], 0, sizeof(MacRaCbInfo)); - } - - /* Send UL Data to RLC */ - ret = macProcUlData(cellId, rxDataIndPdu->rnti, slotInfo, lcId, length, pdu); - - break; - } - case MAC_LCID_RESERVED_MIN ... MAC_LCID_RESERVED_MAX : - break; - - case MAC_LCID_CCCH_48BIT : - break; - - case MAC_LCID_BIT_RATE_QUERY : - break; - - case MAC_LCID_MULT_PHR_FOUR_OCT : - break; - - case MAC_LCID_CFG_GRANT_CFM : - break; - - case MAC_LCID_MULT_PHR_ONE_OCT: - break; - - case MAC_LCID_SINGLE_PHR : - break; - - case MAC_LCID_CRNTI : - break; - - case MAC_LCID_SHORT_TRUNC_BSR : - break; - - case MAC_LCID_LONG_TRUNC_BSR : - break; - - case MAC_LCID_SHORT_BSR : - { - uint8_t lcgId = 0; - uint8_t bufferSizeIdx = 0; - uint8_t crnti = 0; - uint32_t bufferSize = 0; - - pduLen--; - - idx++; - crnti = rxDataIndPdu->rnti; - /* 5 LSB bits in pdu represent buffer size */ - bufferSizeIdx = (~((~0) << 5)) & rxDataPdu[idx]; - /* first 3 MSB bits in pdu represent LCGID */ - lcgId = (rxDataPdu[idx]) >> 5; - /* determine actual number of bytes requested */ - bufferSize = shortBsrBytesTable[bufferSizeIdx]; - ret = macProcShortBsr(macCb.macCell[cellIdx]->cellId, crnti, lcgId, bufferSize); - pduLen--; - idx++; - - break; - } - - case MAC_LCID_LONG_BSR : - break; - - case MAC_LCID_PADDING : - break; - - default: - { - DU_LOG("\nERROR --> MAC : Invalid LC Id %d", lcId); - return RFAILED; - } + case MAC_LCID_CCCH : + { + pduLen--; + + /* for UL CCCH,fixed length of MAC SDU */ + length = 6; + + /* Allocating sharable memory to send ul ccch msg to du app*/ + MAC_ALLOC_SHRABL_BUF(pdu, length); + if(!pdu) + { + DU_LOG("\nERROR --> MAC : UL CCCH PDU memory allocation failed"); + return RFAILED; + } + rxPduIdx++; + memcpy(pdu, &rxDataPdu[rxPduIdx], length); + pduLen -= length; + rxPduIdx = rxPduIdx + length; + + /* store msg3 pdu in macRaCb for CRI value */ + memcpy(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg3Pdu, pdu, length); + + /* Send UL-CCCH Indication to DU APP */ + ret = macProcUlCcchInd(macCb.macCell[cellIdx]->cellId, rxDataIndPdu->rnti, length, pdu); + break; + } + + case MAC_LCID_MIN ... MAC_LCID_MAX : + { + DU_LOG("\nINFO --> MAC : PDU received for LC ID %d", lcId); + pduLen--; + rxPduIdx++; + + length = rxDataPdu[rxPduIdx]; + if(fBit) + { + pduLen--; + rxPduIdx++; + length = (length << 8) & rxDataPdu[rxPduIdx]; + } + + pdu = NULLP; + /* Copying the payload to send to RLC */ + MAC_ALLOC_SHRABL_BUF(pdu, length); + if(!pdu) + { + DU_LOG("\nERROR --> MAC : Memory allocation failed while demuxing Rx Data PDU"); + return RFAILED; + } + pduLen--; + rxPduIdx++; + memcpy(pdu, &rxDataPdu[rxPduIdx], length); + pduLen -= length; + rxPduIdx = rxPduIdx + length; + + /* Delete RA cb once RRC setup complete received */ + if(macCb.macCell[cellIdx]->macRaCb[ueIdx].crnti == rxDataIndPdu->rnti) + { + MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4Pdu, \ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen); + MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TxPdu, \ + macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize - TX_PAYLOAD_HDR_LEN); + memset(&macCb.macCell[cellIdx]->macRaCb[ueIdx], 0, sizeof(MacRaCbInfo)); + } + + /* Send UL Data to RLC */ + ret = macProcUlData(cellId, rxDataIndPdu->rnti, slotInfo, lcId, length, pdu); + + break; + } + case MAC_LCID_RESERVED_MIN ... MAC_LCID_RESERVED_MAX : + break; + + case MAC_LCID_CCCH_48BIT : + break; + + case MAC_LCID_BIT_RATE_QUERY : + break; + + case MAC_LCID_MULT_PHR_FOUR_OCT : + break; + + case MAC_LCID_CFG_GRANT_CFM : + break; + + case MAC_LCID_MULT_PHR_ONE_OCT: + break; + + case MAC_LCID_SINGLE_PHR : + break; + + case MAC_LCID_CRNTI : + break; + + case MAC_LCID_SHORT_TRUNC_BSR : + break; + + case MAC_LCID_LONG_TRUNC_BSR : + break; + + case MAC_LCID_SHORT_BSR : + { + uint8_t lcgId = 0; + uint8_t bufferSizeIdx = 0; + uint8_t crnti = 0; + uint32_t bufferSize = 0; + + pduLen--; + + rxPduIdx++; + crnti = rxDataIndPdu->rnti; + /* 5 LSB bits in pdu represent buffer size */ + bufferSizeIdx = (~((~0) << 5)) & rxDataPdu[rxPduIdx]; + /* first 3 MSB bits in pdu represent LCGID */ + lcgId = (rxDataPdu[rxPduIdx]) >> 5; + /* determine actual number of bytes requested */ + bufferSize = shortBsrBytesTable[bufferSizeIdx]; + ret = macProcShortBsr(macCb.macCell[cellIdx]->cellId, crnti, lcgId, bufferSize); + pduLen--; + rxPduIdx++; + + break; + } + + case MAC_LCID_LONG_BSR : + { + DataVolInfo dataVolInfo[MAX_NUM_LOGICAL_CHANNEL_GROUPS]; + memset(dataVolInfo, 0,MAX_NUM_LOGICAL_CHANNEL_GROUPS * sizeof(DataVolInfo)); + uint8_t lcgIdx = 0; + uint8_t crnti = 0; + uint8_t numLcg = 0; + uint8_t lcgIdxPos = 0; + pduLen--; + + rxPduIdx++;/*To reach the Octet where lcgIdx will be present*/ + crnti = rxDataIndPdu->rnti; + + lcgIdxPos = rxPduIdx; + + pduLen--; + rxPduIdx++;/*To reach the Octet where bsrIdx starts*/ + for(lcgIdx = 0; lcgIdx < MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++) + { + if(rxDataPdu[lcgIdxPos] & (1 << lcgIdx)) + { + if(rxDataPdu[rxPduIdx] > 0 && rxDataPdu[rxPduIdx] < MAX_LONG_BSR_TABLE_ENTRIES) + { + dataVolInfo[numLcg].dataVol = longBsrBytesTable[rxDataPdu[rxPduIdx]]; + dataVolInfo[numLcg].lcgId = lcgIdx; + numLcg++; + } + else + { + DU_LOG("\nERROR --> MAC: Invalid BsrIdx:%d rcvd for lcgIdx:%d",lcgIdx,rxDataPdu[rxPduIdx]); + } + /*next byte in PDU*/ + pduLen--; + rxPduIdx++; + } + } + + ret = macProcLongBsr(macCb.macCell[cellIdx]->cellId, crnti, numLcg, dataVolInfo); + + break; + } + + case MAC_LCID_PADDING : + break; + + default: + { + DU_LOG("\nERROR --> MAC : Invalid LC Id %d", lcId); + return RFAILED; + } } /* End of switch */ if(lcId == MAC_LCID_PADDING) { - break; + break; } } /* End of While */ diff --git a/src/5gnrmac/mac_msg_hdl.c b/src/5gnrmac/mac_msg_hdl.c index bb3e65807..8eb566cb0 100644 --- a/src/5gnrmac/mac_msg_hdl.c +++ b/src/5gnrmac/mac_msg_hdl.c @@ -633,6 +633,8 @@ uint8_t macProcUlCcchInd(uint16_t cellId, uint16_t crnti, uint16_t rrcContSize, * lcg ID * buffer size * + * @return ROK - success + * RFAILED - failure * * ****************************************************************/ uint8_t macProcShortBsr(uint16_t cellId, uint16_t crnti, uint8_t lcgId, uint32_t bufferSize) @@ -654,6 +656,48 @@ uint8_t macProcShortBsr(uint16_t cellId, uint16_t crnti, uint8_t lcgId, uint32_t return(*macSchBsrOpts[pst.selector])(&pst, &bsrInd); } +/******************************************************************* + * + * @brief Processes received short BSR + * + * @details + * + * Function : macProcShortBsr + * + * Functionality: + * MAC sends Short BSR to SCH + * + * @params[in] cell ID + * crnti + * lcg ID + * buffer size + * + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t macProcLongBsr(uint16_t cellId, uint16_t crnti,uint8_t numLcg,\ + DataVolInfo dataVolInfo[MAX_NUM_LOGICAL_CHANNEL_GROUPS]) +{ + Pst pst; + UlBufferStatusRptInd bsrInd; + uint8_t lcgIdx = 0; + + memset(&pst, 0, sizeof(Pst)); + memset(&bsrInd, 0, sizeof(UlBufferStatusRptInd)); + + bsrInd.cellId = cellId; + bsrInd.crnti = crnti; + bsrInd.bsrType = LONG_BSR; + bsrInd.numLcg = numLcg; + + for(lcgIdx = 0; lcgIdx < numLcg; lcgIdx++) + memcpy(&(bsrInd.dataVolInfo[lcgIdx]), &(dataVolInfo[lcgIdx]), sizeof(DataVolInfo)); + + FILL_PST_MAC_TO_SCH(pst, EVENT_LONG_BSR); + return(*macSchBsrOpts[pst.selector])(&pst, &bsrInd); +} + /******************************************************************* * * @brief Builds and send SR UCI Indication to SCH diff --git a/src/5gnrmac/mac_utils.c b/src/5gnrmac/mac_utils.c index 00af8075f..c661f02af 100644 --- a/src/5gnrmac/mac_utils.c +++ b/src/5gnrmac/mac_utils.c @@ -19,12 +19,51 @@ #include "common_def.h" #include "mac_utils.h" - +/*!< This table is the Short BSR Table + * * Spec 38.321, Table 6.1.3.1-1*/ uint32_t shortBsrBytesTable[MAX_SHORT_BSR_TABLE_ENTRIES] = { 0, 10, 14, 20, 28, \ 38, 53, 74, 102, 142, 198, 276, 384, 535, 745, 1038, 1446, 2014, 2806, 3909, \ 5446, 7587, 10570, 14726, 20516, 28581, 39818, 55474, 77284, 107669, 150000, \ 150001 }; +/*!< This table is the Long BSR Table + * * Spec 38.321, Table 6.1.3.1-2*/ +uint32_t longBsrBytesTable[MAX_LONG_BSR_TABLE_ENTRIES] = { + 0,10,11,12,13,14,15,16, + 17,18,19,20,22,23,25,26, + 28,30,32,34,36,38,40,43, + 46,49,52,55,59,62,66,71, + 75,80,85,91,97,103,110,117, + 124,132,141,150,160,170,181,193, + 205,218,233,248,264,281,299,318, + 339,361,384,409,436,464,494,526, + 560,597,635,677,720,767,817,870, + 926,987,1051,1119,1191,1269,1351,1439, + 1532,1631,1737,1850,1970,2098,2234,2379, + 2533,2698,2873,3059,3258,3469,3694,3934, + 4189,4461,4751,5059,5387,5737,6109,6506, + 6928,7378,7857,8367,8910,9488,10104,10760, + 11458,12202,12994,13838,14736,15692,16711,17795, + 18951,20181,21491,22885,24371,25953,27638,29431, + 31342,33376,35543,37850,40307,42923,45709,48676, + 51836,55200,58784,62599,66663,70990,75598,80505, + 85730,91295,97221,103532,110252,117409,125030,133146, + 141789,150992,160793,171231,182345,194182,206786,220209, + 234503,249725,265935,283197,301579,321155,342002,364202, + 387842,413018,439827,468377,498780,531156,565634,602350, + 641449,683087,727427,774645,824928,878475,935498,996222, + 1060888,1129752,1203085,1281179,1364342,1452903,1547213,1647644, + 1754595,1868488,1989774,2118933,2256475,2402946,2558924,2725027, + 2901912,3090279,3290873,3504487,3731968,3974215,4232186,4506902, + 4799451,5110989,5442750,5796046,6172275,6572925,6999582,7453933, + 7937777,8453028,9001725,9586039,10208280,10870913,11576557,12328006, + 13128233,13980403,14887889,15854280,16883401,17979324,19146385,20389201, + 21712690,23122088,24622972,26221280,27923336,29735875,31666069,33721553, + 35910462,38241455,40723756,43367187,46182206,49179951,52372284,55771835, + 59392055,63247269,67352729,71724679,76380419,81338368,81338368,0 + /* TODO Last Buffer Size is reserved [Now set as 0]*/ +}; + /******************************************************************* * * @brief Allocates a crnti for new UE diff --git a/src/5gnrmac/mac_utils.h b/src/5gnrmac/mac_utils.h index 447774e13..3ee51df53 100644 --- a/src/5gnrmac/mac_utils.h +++ b/src/5gnrmac/mac_utils.h @@ -19,6 +19,7 @@ /* Contains common utility definitions to be used at MAC */ #define MAX_SHORT_BSR_TABLE_ENTRIES 32 +#define MAX_LONG_BSR_TABLE_ENTRIES 256 #define MAC_MEM_REGION 4 #define MAC_POOL 1 @@ -146,6 +147,7 @@ /* Function declaration */ uint16_t getNewCrnti(uint8_t *crntiMap); uint32_t shortBsrBytesTable[MAX_SHORT_BSR_TABLE_ENTRIES]; +uint32_t longBsrBytesTable[MAX_LONG_BSR_TABLE_ENTRIES]; /********************************************************************** End of file **********************************************************************/ diff --git a/src/5gnrrlc/rlc_msg_hdl.c b/src/5gnrrlc/rlc_msg_hdl.c index f4debb6de..90cfcd22f 100644 --- a/src/5gnrrlc/rlc_msg_hdl.c +++ b/src/5gnrrlc/rlc_msg_hdl.c @@ -481,13 +481,13 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) if(ulData->pduInfo[idx].commCh) { RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \ - sizeof(RguCDatIndInfo)); - if(!cLchUlDat) - { - DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData"); - ret = RFAILED; - break; - } + sizeof(RguCDatIndInfo)); + if(!cLchUlDat) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData"); + ret = RFAILED; + break; + } memset(cLchUlDat, 0, sizeof(RguCDatIndInfo)); cLchUlDat->cellId = ulData->cellId; @@ -498,13 +498,13 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &cLchUlDat->pdu) != ROK) { DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData"); - RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \ - sizeof(RguCDatIndInfo)); + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \ + sizeof(RguCDatIndInfo)); ret = RFAILED; - break; + break; } oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, cLchUlDat->pdu, \ - ulData->pduInfo[idx].pduLen); + ulData->pduInfo[idx].pduLen); rlcProcCommLcUlData(pst, 0, cLchUlDat); } @@ -513,34 +513,34 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) if(!dLchPduPres) { RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ - sizeof(RguDDatIndInfo)); - if(!dLchUlDat) - { - DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); - ret = RFAILED; - break; - } + sizeof(RguDDatIndInfo)); + if(!dLchUlDat) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); + ret = RFAILED; + break; + } dLchPduPres = TRUE; } - /* Copy fixed buffer to message */ - lcId = ulData->pduInfo[idx].lcId; - if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \ - &dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK) - { - DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); - for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++) - { - ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]); - } - RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ - sizeof(RguDDatIndInfo)); - ret = RFAILED; - break; - } - oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, \ - dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu],\ - ulData->pduInfo[idx].pduLen); + /* Copy fixed buffer to message */ + lcId = ulData->pduInfo[idx].lcId; + if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \ + &dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK) + { + DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData"); + for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++) + { + ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]); + } + RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, dLchUlDat, \ + sizeof(RguDDatIndInfo)); + ret = RFAILED; + break; + } + oduCpyFixBufToMsg(ulData->pduInfo[idx].pduBuf, \ + dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu],\ + ulData->pduInfo[idx].pduLen); dLchData[lcId].pdu.numPdu++; } @@ -552,26 +552,26 @@ uint8_t RlcProcUlData(Pst *pst, RlcData *ulData) { if(dLchPduPres) { - dLchUlDat->cellId = ulData->cellId; - GET_UE_IDX(ulData->rnti, dLchUlDat->rnti); - - for(idx = 0; idx < MAX_NUM_LC; idx++) - { - if(dLchData[idx].pdu.numPdu) - { - memcpy(&dLchUlDat->lchData[numDLch], &dLchData[idx], sizeof(RguLchDatInd)); - numDLch++; - } - } - dLchUlDat->numLch = numDLch; - rlcProcDedLcUlData(pst, 0, dLchUlDat); + dLchUlDat->cellId = ulData->cellId; + GET_UE_IDX(ulData->rnti, dLchUlDat->rnti); + + for(idx = 0; idx < MAX_NUM_LC; idx++) + { + if(dLchData[idx].pdu.numPdu) + { + memcpy(&dLchUlDat->lchData[numDLch], &dLchData[idx], sizeof(RguLchDatInd)); + numDLch++; + } + } + dLchUlDat->numLch = numDLch; + rlcProcDedLcUlData(pst, 0, dLchUlDat); } } for(pduIdx = 0; pduIdx < ulData->numPdu; pduIdx++) { RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData->pduInfo[pduIdx].pduBuf, \ - ulData->pduInfo[pduIdx].pduLen); + ulData->pduInfo[pduIdx].pduLen); } RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcData)); return ROK; diff --git a/src/5gnrrlc/rlc_upr_inf_mgr.c b/src/5gnrrlc/rlc_upr_inf_mgr.c index 2e273ec75..fba7a5614 100755 --- a/src/5gnrrlc/rlc_upr_inf_mgr.c +++ b/src/5gnrrlc/rlc_upr_inf_mgr.c @@ -847,7 +847,7 @@ RlcTptPerSnssai* rlcHandleSnssaiTputlist(RlcCb *gCb, Snssai *snssai, RlcSnssaiAc RLC_ALLOC(gCb, gCb->rlcThpt.snssaiTputInfo.tputPerSnssaiList, sizeof(CmLListCp)); snssaiList = gCb->rlcThpt.snssaiTputInfo.tputPerSnssaiList; cmLListInit(snssaiList); - DU_LOG("\nINFO --> RLC: First SNSSAI to add in this List"); + DU_LOG("\nINFO --> RLC: First SNSSAI to add in this List"); } else { @@ -864,7 +864,7 @@ RlcTptPerSnssai* rlcHandleSnssaiTputlist(RlcCb *gCb, Snssai *snssai, RlcSnssaiAc snssaiNode = (RlcTptPerSnssai *)node->node; if(memcmp(snssaiNode->snssai, snssai, sizeof(Snssai)) == 0) { - DU_LOG("\nINFO --> RLC : SNSSAI found in LL"); + DU_LOG("\nDEBUG --> RLC : SNSSAI found in LL"); found = TRUE; break; } @@ -919,7 +919,7 @@ RlcTptPerSnssai* rlcHandleSnssaiTputlist(RlcCb *gCb, Snssai *snssai, RlcSnssaiAc DU_LOG("\nERROR --> RLC : Allocation of SNSSAI node failed"); return NULLP; } - DU_LOG("\nINFO --> RLC : SNSSAI node added successfully"); + DU_LOG("\nDEBUG --> RLC : SNSSAI node added successfully"); return (snssaiNode); } @@ -930,12 +930,12 @@ RlcTptPerSnssai* rlcHandleSnssaiTputlist(RlcCb *gCb, Snssai *snssai, RlcSnssaiAc node = cmLListDelFrm(snssaiList, node); RLC_FREE(gCb, node, sizeof(CmLList)); RLC_FREE(gCb, snssaiNode, sizeof(RlcTptPerSnssai)); - DU_LOG("\nINFO --> RLC : SNSSAI node found and deletion performed"); + DU_LOG("\nDEBUG --> RLC : SNSSAI node found and deletion performed"); if(snssaiList->count == 0) { RLC_FREE(gCb, snssaiList, sizeof(CmLListCp)); - DU_LOG("\nINFO --> RLC : This SNSSAI was last in the list thus freeing the list also"); + DU_LOG("\nINFO --> RLC : This SNSSAI was last in the list thus freeing the list also"); } } else @@ -988,7 +988,7 @@ void rlcDelTputSnssaiList(RlcCb *gCb) if(snssaiList->count == 0) { RLC_FREE(gCb, snssaiList, sizeof(CmLListCp)); - DU_LOG("\nINFO --> RLC : This SNSSAI was last in the list thus freeing the list also"); + DU_LOG("\nINFO --> RLC : This SNSSAI was last in the list thus freeing the list also"); } } diff --git a/src/5gnrrlc/rlc_utl_dl.c b/src/5gnrrlc/rlc_utl_dl.c index f188d096e..69022fc9e 100755 --- a/src/5gnrrlc/rlc_utl_dl.c +++ b/src/5gnrrlc/rlc_utl_dl.c @@ -97,24 +97,24 @@ Void PrintRLCStats(Void) RlcCb* dlInst = rlcCb[1]; RlcCb* ulInst = rlcCb[0]; - DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)", + DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)", dlInst->genSts.pdusSent, dlInst->genSts.pdusRetx, dlInst->genSts.protTimeOut, dlInst->genSts.numSduDisc); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)", + DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)", ulInst->genSts.pdusRecv, ulInst->genSts.unexpPdusRecv, ulInst->genSts.errorPdusRecv); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " + DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " "StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ", gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " + DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " "DRB:%lu MaxRetx:%lu RetransPdus:%lu", gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx, gRlcStats.amRlcStats.numDLRetransPdus); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: " + DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: " " PdusDiscarded:%lu ReAsmblTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ", gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReAsmblTimerExpires, gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd); @@ -143,24 +143,24 @@ Void PrintRLCStats(Void) RlcCb* ulInst = rlcCb[0]; DU_LOG ("\n ================================ RLC STATS ===========================\n"); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%d), PdusRext = (%d), TimeOut = (%d), SduDiscarded = (%d)", + DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%d), PdusRext = (%d), TimeOut = (%d), SduDiscarded = (%d)", dlInst->genSts.pdusSent, dlInst->genSts.pdusRetx, dlInst->genSts.protTimeOut, dlInst->genSts.numSduDisc); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%d), unexpPdus = (%d), errorPdus = (%d)", + DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%d), unexpPdus = (%d), errorPdus = (%d)", ulInst->genSts.pdusRecv, ulInst->genSts.unexpPdusRecv, ulInst->genSts.errorPdusRecv); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " + DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " "StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u ", gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu, gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " + DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: " "DRB:%u MaxRetx:%u RetransPdus:%u", gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx, gRlcStats.amRlcStats.numDLRetransPdus); - DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: " + DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: " " PdusDiscarded:%u ReAsmblTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u ", gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReAsmblTimerExpires, gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd); @@ -334,7 +334,7 @@ uint8_t rlcSendDedLcDlData(Pst *post, SpId spId, RguDDatReqInfo *datReqInfo) ret = RFAILED; break; } - DU_LOG("\nINFO --> RLC_DL : rlcSendDedLcDlData: BO Status sent successfully for LCID:%d,BO:%d",\ + DU_LOG("\nDEBUG --> RLC_DL : rlcSendDedLcDlData: BO Status sent successfully for LCID:%d,BO:%d",\ boStatus->lcId, boStatus->bo); } RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL, dlData, sizeof(RlcData)); @@ -510,7 +510,7 @@ uint8_t rlcUtlSendToMac(RlcCb *gCb, SuId suId, KwDStaIndInfo *staIndInfo) if(snssaiTputNode != NULLP) { snssaiTputNode->dataVol += staIndTb->lchStaInd[count].totBufSize; - DU_LOG("\nINFO -->SCH: SNSSAI List Grant:%d, lcId:%d, total :%d",\ + DU_LOG("\nINFO -->SCH: SNSSAI List Grant:%d, lcId:%d, total :%d",\ staIndTb->lchStaInd[count].totBufSize, staIndTb->lchStaInd[count].lcId,\ snssaiTputNode->dataVol); } diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index 2f93aaae6..2cb4c544a 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -167,7 +167,7 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) /* Set Config done in TskInit */ schCb[inst].schInit.cfgDone = TRUE; - DU_LOG("\nINFO --> SCH : Scheduler gen config done"); + DU_LOG("\nINFO --> SCH : Scheduler gen config done"); return ret; } @@ -208,7 +208,7 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START); return ROK; } - DU_LOG("\nINFO --> SCH : Received scheduler gen config"); + DU_LOG("\nINFO --> SCH : Received scheduler gen config"); /* Fill the post structure for sending the confirmation */ memset(&cfmPst, 0 , sizeof(Pst)); SchFillCfmPst(pst, &cfmPst, cfg); @@ -1032,15 +1032,31 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) #endif DU_LOG("\nDEBUG --> SCH : Received BSR"); + if(bsrInd == NULLP) + { + DU_LOG("\nERROR --> SCH : BSR Ind is empty"); + return RFAILED; + } cellCb = schCb[schInst].cells[schInst]; + if(cellCb == NULLP) + { + DU_LOG("\nERROR --> SCH : CellCb is empty"); + return RFAILED; + } ueCb = schGetUeCb(cellCb, bsrInd->crnti); + if(ueCb == NULLP) + { + DU_LOG("\nERROR --> SCH : UeCB is empty"); + return RFAILED; + } + ueCb->bsrRcvd = true; /* store dataVolume per lcg in uecb */ for(lcgIdx = 0; lcgIdx < bsrInd->numLcg; lcgIdx++) { - ueCb->bsrInfo[lcgIdx].priority = 1; //TODO: determining LCG priority? - ueCb->bsrInfo[lcgIdx].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol; + ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].priority = 1; //TODO: determining LCG priority? + ueCb->bsrInfo[bsrInd->dataVolInfo[lcgIdx].lcgId].dataVol = bsrInd->dataVolInfo[lcgIdx].dataVol; } /* Adding UE Id to list of pending UEs to be scheduled */ @@ -1413,7 +1429,7 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * * @details * - * Function : searchLargestFreeBlockDL + * Function : searchLargestFreeBlock * * Functionality: * Finds the FreeBlock with MaxNum of FREE PRB considering SSB/SIB1 ocassions. @@ -1421,6 +1437,7 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * @params[in] I/P > prbAlloc table (FreeBlock list) * I/P > Slot timing Info * O/P > Start PRB + * I/P > Direction (UL/DL) * * * @return Max Number of Free PRB @@ -1428,38 +1445,70 @@ uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) * * ********************************************************************************/ -uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb) +uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb, Direction dir) { - uint16_t broadcastPrbStart=0, broadcastPrbEnd=0, maxFreePRB = 0; - PduTxOccsaion ssbOccasion=0, sib1Occasion=0; + uint16_t reservedPrbStart=0, reservedPrbEnd=0, maxFreePRB = 0; FreePrbBlock *freePrbBlock = NULLP; CmLList *freePrbNode = NULLP; + SchPrbAlloc *prbAlloc = NULLP; + bool checkOccasion = FALSE; - SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot]; - SchPrbAlloc *prbAlloc = &schDlSlotInfo->prbAlloc; - - ssbOccasion = schCheckSsbOcc(cell, slotTime); - sib1Occasion = schCheckSib1Occ(cell, slotTime); + *startPrb = 0; /*Initialize the StartPRB to zero*/ - if(ssbOccasion && sib1Occasion) + /*Based on Direction, Reserved Messsages will differi.e. + * DL >> SSB and SIB1 ocassions wheres for UL, PRACH ocassions to be checked + * and reserved before allocation for dedicated DL/UL msg*/ + if(dir == DIR_DL) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + SchDlSlotInfo *schDlSlotInfo = cell->schDlSlotInfo[slotTime.slot]; + PduTxOccsaion ssbOccasion=0, sib1Occasion=0; + + prbAlloc = &schDlSlotInfo->prbAlloc; + + ssbOccasion = schCheckSsbOcc(cell, slotTime); + sib1Occasion = schCheckSib1Occ(cell, slotTime); + + checkOccasion = TRUE; + if(ssbOccasion && sib1Occasion) + { + reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB + \ + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + } + else if(ssbOccasion) + { + reservedPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; + reservedPrbEnd = reservedPrbStart + SCH_SSB_NUM_PRB -1; + } + else if(sib1Occasion) + { + reservedPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; + reservedPrbEnd = reservedPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + } + else + { + checkOccasion = FALSE; + } } - else if(ssbOccasion) + else if(dir == DIR_UL) { - broadcastPrbStart = cell->cellCfg.ssbSchCfg.ssbOffsetPointA; - broadcastPrbEnd = broadcastPrbStart + SCH_SSB_NUM_PRB -1; + prbAlloc = &cell->schUlSlotInfo[slotTime.slot]->prbAlloc; + + /* Check if PRACH is also scheduled in this slot */ + checkOccasion = schCheckPrachOcc(cell, slotTime); + if(checkOccasion) + { + reservedPrbStart = cell->cellCfg.schRachCfg.msg1FreqStart; + reservedPrbEnd = reservedPrbStart + (schCalcPrachNumRb(cell)) -1; + } } - else if(sib1Occasion) + else { - broadcastPrbStart = cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.startPrb; - broadcastPrbEnd = broadcastPrbStart + cell->cellCfg.sib1SchCfg.sib1PdschCfg.pdschFreqAlloc.freqAlloc.numPrb -1; + DU_LOG("\nERROR --> SCH: Invalid Direction!"); + return (maxFreePRB); } - freePrbNode = prbAlloc->freePrbBlockList.first; - *startPrb = 0; /*Initialize the StartPRB to zero*/ while(freePrbNode) { freePrbBlock = (FreePrbBlock *)freePrbNode->node; @@ -1473,27 +1522,27 @@ uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint1 continue; } - /* If broadcast message is scheduled in this slot, then check if its PRBs belong to the current free block. + /* If Broadcast/Prach message is scheduled in this slot, then check if its PRBs belong to the current free block. * Since SSB/SIB1 PRB location is fixed, these PRBs cannot be allocated to other message in same slot */ - if((ssbOccasion || sib1Occasion) && - ((broadcastPrbStart >= freePrbBlock->startPrb) && (broadcastPrbStart <= freePrbBlock->endPrb)) && \ - ((broadcastPrbEnd >= freePrbBlock->startPrb) && (broadcastPrbEnd <= freePrbBlock->endPrb))) + if(checkOccasion && + ((reservedPrbStart >= freePrbBlock->startPrb) && (reservedPrbStart <= freePrbBlock->endPrb)) && \ + ((reservedPrbEnd >= freePrbBlock->startPrb) && (reservedPrbEnd <= freePrbBlock->endPrb))) { /* Implmentation is done such that highest-numbered free-RB is Checked first and freePRB in this block is greater than Max till now */ - if((freePrbBlock->endPrb > broadcastPrbEnd) && ((freePrbBlock->endPrb - broadcastPrbEnd) > maxFreePRB)) + if((freePrbBlock->endPrb > reservedPrbEnd) && ((freePrbBlock->endPrb - reservedPrbEnd) > maxFreePRB)) { - /* If sufficient free PRBs are available above broadcast message*/ - *startPrb = broadcastPrbEnd + 1; - maxFreePRB = (freePrbBlock->endPrb - broadcastPrbEnd); + /* If sufficient free PRBs are available above reserved message*/ + *startPrb = reservedPrbEnd + 1; + maxFreePRB = (freePrbBlock->endPrb - reservedPrbEnd); } - /*Also check the other freeBlock (i.e. Above the broadcast message) for MAX FREE PRB*/ - if((broadcastPrbStart > freePrbBlock->startPrb) && ((broadcastPrbStart - freePrbBlock->startPrb) > maxFreePRB)) + /*Also check the other freeBlock (i.e. Above the reserved message) for MAX FREE PRB*/ + if((reservedPrbStart > freePrbBlock->startPrb) && ((reservedPrbStart - freePrbBlock->startPrb) > maxFreePRB)) { - /* If free PRBs are available below broadcast message*/ + /* If free PRBs are available below reserved message*/ *startPrb = freePrbBlock->startPrb; - maxFreePRB = (broadcastPrbStart - freePrbBlock->startPrb); + maxFreePRB = (reservedPrbStart - freePrbBlock->startPrb); } } else //Best Block @@ -1509,7 +1558,6 @@ uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint1 } return(maxFreePRB); } - /********************************************************************** End of file **********************************************************************/ diff --git a/src/5gnrsch/sch.h b/src/5gnrsch/sch.h index 98a013348..a0d74394e 100644 --- a/src/5gnrsch/sch.h +++ b/src/5gnrsch/sch.h @@ -96,6 +96,13 @@ typedef enum CREATE, DELETE }ActionTypeLcLL; + +typedef enum +{ + DIR_UL, + DIR_DL +}Direction; + /** * @brief * Structure holding LTE MAC's General Configuration information. @@ -372,8 +379,6 @@ uint8_t pdschStartSymbol, uint8_t pdschNumSymbols); uint16_t schAccumalateLcBoSize(SchCellCb *cell, uint16_t ueIdx); uint8_t allocatePrbDl(SchCellCb *cell, SlotTimingInfo slotTime, uint8_t startSymbol, uint8_t symbolLength, \ uint16_t *startPrb, uint16_t numPrb); -uint16_t searchLargestFreeBlockDL(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb); -void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *accumalatedBOSize); void fillDlMsgInfo(DlMsgInfo *dlMsgInfo, uint8_t crnti); bool findValidK0K1Value(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId, bool dedMsg, uint8_t *pdschStartSymbol,\ uint8_t *pdschSymblLen, SlotTimingInfo *pdcchTime, SlotTimingInfo *pdschTime, SlotTimingInfo *pucchTime); @@ -385,15 +390,21 @@ uint8_t schCalcPrachNumRb(SchCellCb *cell); void schPrachResAlloc(SchCellCb *cell, UlSchedInfo *ulSchedInfo, SlotTimingInfo prachOccasionTimingInfo); uint16_t schAllocPucchResource(SchCellCb *cell, SlotTimingInfo pucchTime, uint16_t crnti); uint8_t schFillUlDci(SchUeCb *ueCb, SchPuschInfo *puschInfo, DciInfo *dciInfo); -uint8_t schFillPuschAlloc(SchUeCb *ueCb, SlotTimingInfo puschTime, uint32_t dataVol, uint8_t k2, uint8_t startSymb, uint8_t symbLen); +uint8_t schFillPuschAlloc(SchUeCb *ueCb, SlotTimingInfo puschTime, uint32_t tbsSize, \ + uint8_t startSymb, uint8_t symbLen, uint16_t startPrb); uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, uint8_t startSymbol, uint8_t symbolLength, \ uint16_t *startPrb, uint16_t numPrb); bool schProcessSrOrBsrReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId); +bool schCalculateUlTbs(SchUeCb *ueCb, SlotTimingInfo puschTime, uint8_t symbLen,\ + uint16_t *startPrb, uint32_t *totTBS); /*Generic Functions*/ +void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, BsrInfo *bsrInfo, uint32_t *accumalatedBOSize); +uint16_t searchLargestFreeBlock(SchCellCb *cell, SlotTimingInfo slotTime,uint16_t *startPrb, Direction dir); LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLcLL action); void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool dedicatedPRB, uint16_t mcsIdx,uint8_t numSymbols,\ - uint16_t *sharedPRB, uint16_t *reservedPRB, bool *isTxPayloadLenAdded); + uint16_t *sharedPRB, uint16_t *reservedPRB, bool *isTxPayloadLenAdded, bool *srRcvd); +void updateBsrAndLcList(CmLListCp *lcLL, BsrInfo *bsrInfo, uint8_t status); /********************************************************************** End of file diff --git a/src/5gnrsch/sch_common.c b/src/5gnrsch/sch_common.c index fa396ef11..3cd0ff241 100644 --- a/src/5gnrsch/sch_common.c +++ b/src/5gnrsch/sch_common.c @@ -1365,13 +1365,14 @@ SchK2TimingInfoTbl *msg3K2InfoTbl, SchK2TimingInfoTbl *k2InfoTbl) * I/P > mcsIdx and PDSCH symbols count * I/P & O/P > Shared PRB , reserved PRB Count * I/P & O/P > Total TBS size accumulated - * I/P & O/P > isTxPayloadLenAdded : Decision flag to add the TX_PAYLOAD_HDR_LEN + * I/P & O/P > isTxPayloadLenAdded[For DL] : Decision flag to add the TX_PAYLOAD_HDR_LEN + * I/P & O/P > srRcvd Flag[For UL] : Decision flag to add UL_GRANT_SIZE * * @return void * * *******************************************************************************************/ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsIdx,uint8_t numSymbols,\ - uint16_t *sharedPRB, uint16_t *reservedPRB, bool *isTxPayloadLenAdded) + uint16_t *sharedPRB, uint16_t *reservedPRB, bool *isTxPayloadLenAdded, bool *srRcvd) { CmLList *node = NULLP; LcInfo *lcNode = NULLP; @@ -1415,7 +1416,7 @@ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsId /*[Exit1]: All LCs are allocated(allocBO = 0 for fully unallocated LC)*/ if(lcNode->allocBO != 0) { - DU_LOG("\nWARNING --> SCH: All LC are allocated [SharedPRB:%d]",*sharedPRB); + DU_LOG("\nDEBUG --> SCH: All LC are allocated [SharedPRB:%d]",*sharedPRB); return; } @@ -1425,7 +1426,7 @@ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsId /*Loop Exit: All resources exhausted*/ if(remReservedPRB == 0 && *sharedPRB == 0) { - DU_LOG("\nWARNING --> SCH: Dedicated resources exhausted for LC:%d",lcNode->lcId); + DU_LOG("\nDEBUG --> SCH: Dedicated resources exhausted for LC:%d",lcNode->lcId); return; } } @@ -1434,7 +1435,7 @@ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsId /*Loop Exit: All resources exhausted*/ if(*sharedPRB == 0) { - DU_LOG("\nWARNING --> SCH: Default resources exhausted for LC:%d",lcNode->lcId); + DU_LOG("\nDEBUG --> SCH: Default resources exhausted for LC:%d",lcNode->lcId); return; } } @@ -1443,15 +1444,23 @@ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsId maxPRB = remReservedPRB + *sharedPRB; /*[Step4]*/ - if(!(*isTxPayloadLenAdded)) + if((isTxPayloadLenAdded != NULLP) && (*isTxPayloadLenAdded == FALSE)) { - DU_LOG("\nINFO --> SCH: LC:%d is the First node to be allocated which includes TX_PAYLOAD_HDR_LEN",\ + DU_LOG("\nDEBUG --> SCH: LC:%d is the First node to be allocated which includes TX_PAYLOAD_HDR_LEN",\ lcNode->lcId); *isTxPayloadLenAdded = TRUE; lcNode->allocBO = calculateEstimateTBSize((lcNode->reqBO + TX_PAYLOAD_HDR_LEN),\ mcsIdx, numSymbols, maxPRB, &estPrb); lcNode->allocBO -=TX_PAYLOAD_HDR_LEN; } + else if((srRcvd != NULLP) && (*srRcvd == TRUE)) + { + DU_LOG("\nDEBUG --> SCH: LC:%d is the First node to be allocated which includes UL_GRANT_SIZE",\ + lcNode->lcId); + *srRcvd = FALSE; + lcNode->reqBO += UL_GRANT_SIZE; + lcNode->allocBO = calculateEstimateTBSize(lcNode->reqBO, mcsIdx, numSymbols, maxPRB, &estPrb); + } else { /*[Step4]*/ @@ -1469,7 +1478,7 @@ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsId { if(*sharedPRB <= (estPrb - remReservedPRB)) { - DU_LOG("\nINFO --> SCH: SharedPRB is less"); + DU_LOG("\nDEBUG --> SCH: SharedPRB is less"); *sharedPRB = 0; } else @@ -1506,12 +1515,14 @@ void prbAllocUsingRRMPolicy(CmLListCp *lcLL, bool isDedicatedPRB, uint16_t mcsId * BO Report in dlMsgAlloc Pointer * * @params[in] I/P > lcLinkList pointer (LcInfo list) - * I/P & O/P > dlMsgAlloc(Pending LC to be added in this context) + * I/P & O/P > dlMsgAlloc[for DL](Pending LC to be added in this context) + * I/P & O/P > BsrInfo (applicable for UL) * I/P & O/P > accumalatedBOSize * @return void * * *******************************************************************************************/ -void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t *accumalatedBOSize) +void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc,\ + BsrInfo *bsrInfo, uint32_t *accumalatedBOSize) { CmLList *node = NULLP, *next = NULLP; LcInfo *lcNode = NULLP; @@ -1533,8 +1544,6 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t * return; } - dlMsgSchInfo = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo]; - /*Traverse List*/ while(node) { @@ -1542,25 +1551,35 @@ void updateGrantSizeForBoRpt(CmLListCp *lcLL, DlMsgAlloc *dlMsgAlloc, uint32_t * lcNode = (LcInfo *)node->node; if(lcNode != NULLP) { - DU_LOG("\nINFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\ + DU_LOG("\nINFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\ lcNode->lcId, lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB); + if(dlMsgAlloc != NULLP) + { + dlMsgSchInfo = &dlMsgAlloc->dlMsgSchedInfo[dlMsgAlloc->numSchedInfo]; - /*Add this LC to dlMsgAlloc so that if this LC gets allocated, BO - * report for allocation can be sent to MAC*/ - dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].lcId = lcNode->lcId; - dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].schBytes = lcNode->allocBO; + /*Add this LC to dlMsgAlloc so that if this LC gets allocated, BO + * report for allocation can be sent to MAC*/ + dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].lcId = lcNode->lcId; + dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].schBytes = lcNode->allocBO; - /*Calculate the Total Payload/BO size allocated*/ - *accumalatedBOSize += dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].schBytes; + /*Calculate the Total Payload/BO size allocated*/ + *accumalatedBOSize += dlMsgSchInfo->lcSchInfo[dlMsgSchInfo->numLc].schBytes; - DU_LOG("\nINFO --> SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\ - lcNode->lcId,lcNode->reqBO, dlMsgSchInfo->numLc, *accumalatedBOSize); + DU_LOG("\nINFO --> SCH: Added in MAC BO report: LCID:%d,reqBO:%d,Idx:%d, TotalBO Size:%d",\ + lcNode->lcId,lcNode->reqBO, dlMsgSchInfo->numLc, *accumalatedBOSize); - dlMsgSchInfo->numLc++; - /*The LC has been fully allocated, clean it*/ - if(lcNode->reqBO == 0) + dlMsgSchInfo->numLc++; + /*The LC has been fully allocated, clean it*/ + if(lcNode->reqBO == 0) + { + handleLcLList(lcLL, lcNode->lcId, DELETE); + } + } + else if(bsrInfo != NULLP) { - handleLcLList(lcLL, lcNode->lcId, DELETE); + *accumalatedBOSize += lcNode->allocBO; + DU_LOG("\nINFO --> SCH: UL : LCID:%d,reqBO:%d, TotalBO Size:%d",\ + lcNode->lcId,lcNode->reqBO, *accumalatedBOSize); } } node = next; @@ -1718,6 +1737,141 @@ bool schProcessMsg4Req(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) return true; } +/******************************************************************* + * + * @brief Handler to calculate TBS size for BSR requested + * + * @details + * + * Function : schCalculateUlTbs + * + * Functionality: Function will note the required TBS for each LCGIDX and use + * the Priority LCG List and RRM policy to allocate the TBS size + * + * @params [in] ueCb (Pointer to UE CB) + * [in] puschTime (Time slot where PUSCH will be sent) + * [in] symbLen (No of Symbols used for PUSCH transmission) + * [out] startPrb(Pointer to startPRB which will be calculated while + * finding the best Free Block) + * [out] totTBS(Pointer to total TBS size) + * + * @return bool : true > Scheduling of UL grant is successful + * false > vice versa + * + * ****************************************************************/ +bool schCalculateUlTbs(SchUeCb *ueCb, SlotTimingInfo puschTime, uint8_t symbLen,\ + uint16_t *startPrb, uint32_t *totTBS) +{ + uint16_t mcsIdx = 0; + CmLListCp *lcLL = NULLP; + uint16_t lcgIdx = 0, lcId =0, maxFreePRB = 0; + + *startPrb = 0; + *totTBS = 0; + + /* check for BSR */ + for(lcgIdx=0; lcgIdxbsrInfo[lcgIdx].dataVol == 0) + { + continue; + } + + /*TODO: lcgIdx and LCID has been implemented as one to one mapping. + * Need to check the mapping to figure out the LCID and lcgIdx once L2 + * spec specifies any logic*/ + lcId = lcgIdx; + if(ueCb->ulInfo.ulLcCtxt[lcId].isDedicated) + { + lcLL = &(ueCb->ulLcPrbEst.dedLcInfo->dedLcList); + } + else + { + lcLL = &(ueCb->ulLcPrbEst.defLcList); + } + + /*[Step2]: Update the reqPRB and Payloadsize for this LC in the appropriate List*/ + if(updateLcListReqPRB(lcLL, lcId, ueCb->bsrInfo[lcgIdx].dataVol) != ROK) + { + DU_LOG("\nERROR --> SCH: LcgId:%d updation failed",lcId); + return false; + } + } + + if ((ueCb->ulLcPrbEst.defLcList.count == 0) && \ + ((ueCb->ulLcPrbEst.dedLcInfo == NULL) || (ueCb->ulLcPrbEst.dedLcInfo->dedLcList.count == 0))) + { + if(ueCb->srRcvd) + { + *startPrb = MAX_NUM_RB; + *totTBS = schCalcTbSize(UL_GRANT_SIZE); + } + + /*Returning true when NO Grant is there for UE as this is not scheduling + * error*/ + return (true); + } + + maxFreePRB = searchLargestFreeBlock(ueCb->cellCb, puschTime, startPrb, DIR_UL); + + /*[Step4]: Estimation of PRB and BO which can be allocated to each LC in + * the list based on RRM policy*/ + + /*Either this UE contains no reservedPRB pool fir dedicated S-NSSAI or + * Num of Free PRB available is not enough to reserve Dedicated PRBs*/ + if(maxFreePRB != 0) + { + mcsIdx = ueCb->ueCfg.ulModInfo.mcsIndex; + if((ueCb->ulLcPrbEst.dedLcInfo == NULLP) + || ((maxFreePRB < ueCb->ulLcPrbEst.dedLcInfo->rsvdDedicatedPRB))) + { + ueCb->ulLcPrbEst.sharedNumPrb = maxFreePRB; + DU_LOG("\nDEBUG --> SCH : UL Only Default Slice is scheduled, sharedPRB Count:%d",\ + ueCb->ulLcPrbEst.sharedNumPrb); + + /*PRB Alloc for Default LCs*/ + prbAllocUsingRRMPolicy(&(ueCb->ulLcPrbEst.defLcList), FALSE, mcsIdx, symbLen,\ + &(ueCb->ulLcPrbEst.sharedNumPrb), NULLP, NULLP,&(ueCb->srRcvd)); + } + else + { + ueCb->ulLcPrbEst.sharedNumPrb = maxFreePRB - ueCb->ulLcPrbEst.dedLcInfo->rsvdDedicatedPRB; + + /*PRB Alloc for Dedicated LCs*/ + prbAllocUsingRRMPolicy(&(ueCb->ulLcPrbEst.dedLcInfo->dedLcList), TRUE, mcsIdx, symbLen,\ + &(ueCb->ulLcPrbEst.sharedNumPrb), &(ueCb->ulLcPrbEst.dedLcInfo->rsvdDedicatedPRB),\ + NULLP,&(ueCb->srRcvd)); + + /*PRB Alloc for Default LCs*/ + prbAllocUsingRRMPolicy(&(ueCb->ulLcPrbEst.defLcList), FALSE, mcsIdx, symbLen, \ + &(ueCb->ulLcPrbEst.sharedNumPrb), &(ueCb->ulLcPrbEst.dedLcInfo->rsvdDedicatedPRB),\ + NULLP,&(ueCb->srRcvd)); + } + } + /*[Step5]:Traverse each LCID in LcList to calculate the exact Scheduled Bytes + * using allocated BO per LC and Update dlMsgAlloc(BO report for MAC*/ + if(ueCb->ulLcPrbEst.dedLcInfo != NULLP) + updateGrantSizeForBoRpt(&(ueCb->ulLcPrbEst.dedLcInfo->dedLcList), NULLP, ueCb->bsrInfo, totTBS); + + updateGrantSizeForBoRpt(&(ueCb->ulLcPrbEst.defLcList), NULLP, ueCb->bsrInfo, totTBS); + + /*Below case will hit if NO LC(s) are allocated due to resource crunch*/ + if (*totTBS == 0) + { + if(maxFreePRB == 0) + { + DU_LOG("\nERROR --> SCH : NO FREE PRB!!"); + } + else + { + /*Schedule the LC for next slot*/ + DU_LOG("\nDEBUG --> SCH : No LC has been scheduled"); + } + return (false); + } + return (true); +} + /******************************************************************* * * @brief sch Process pending Sr or Bsr Req @@ -1736,10 +1890,10 @@ bool schProcessMsg4Req(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) *******************************************************************/ bool schProcessSrOrBsrReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId) { - bool k2Found = FALSE; - uint8_t lcgIdx = 0; + bool k2Found = FALSE, ret = FALSE; uint8_t startSymb = 0, symbLen = 0; uint8_t k2TblIdx = 0, k2Index = 0, k2Val = 0; + uint16_t startPrb = 0; uint32_t totDataReq = 0; /* in bytes */ SchUeCb *ueCb; SchPuschInfo *puschInfo; @@ -1747,86 +1901,83 @@ bool schProcessSrOrBsrReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId SchK2TimingInfoTbl *k2InfoTbl=NULLP; SlotTimingInfo dciTime, puschTime; - if(cell == NULL) + if(cell == NULLP) { DU_LOG("\nERROR --> SCH: schDlRsrcAllocMsg4() : Cell is NULL"); return false; } - + ueCb = &cell->ueCb[ueId-1]; - /* check for SR */ - if(ueCb->srRcvd) - { - totDataReq = UL_GRANT_SIZE; /*fixing so that all control msgs can be handled in SR */ - } - /* check for BSR */ - if(ueCb->bsrRcvd == true) + if(ueCb == NULLP) { - for(lcgIdx=0; lcgIdxbsrInfo[lcgIdx].dataVol; - } + DU_LOG("\nERROR --> SCH: schDlRsrcAllocMsg4() : UE is NULL"); + return false; } - - if(totDataReq > 0) - { - /* Calculating time frame to send DCI for SR */ - ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA); + /* Calculating time frame to send DCI for SR */ + ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA); #ifdef NR_TDD - if(schGetSlotSymbFrmt(dciTime.slot, cell->slotFrmtBitMap) == DL_SLOT) + if(schGetSlotSymbFrmt(dciTime.slot, cell->slotFrmtBitMap) == DL_SLOT) #endif - { - if(ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt) - k2InfoTbl = &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2InfoTbl; - else - k2InfoTbl = &cell->cellCfg.schInitialUlBwp.k2InfoTbl; + { + if(ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt) + k2InfoTbl = &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2InfoTbl; + else + k2InfoTbl = &cell->cellCfg.schInitialUlBwp.k2InfoTbl; - for(k2TblIdx = 0; k2TblIdx < k2InfoTbl->k2TimingInfo[dciTime.slot].numK2; k2TblIdx++) - { - k2Index = k2InfoTbl->k2TimingInfo[dciTime.slot].k2Indexes[k2TblIdx]; + for(k2TblIdx = 0; k2TblIdx < k2InfoTbl->k2TimingInfo[dciTime.slot].numK2; k2TblIdx++) + { + k2Index = k2InfoTbl->k2TimingInfo[dciTime.slot].k2Indexes[k2TblIdx]; - if(!ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt) - { - k2Val = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2; - startSymb = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].startSymbol; - symbLen = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].symbolLength; - } - else - { - k2Val = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].k2; - startSymb = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].startSymbol; - symbLen = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].symbolLength; - } + if(!ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.k2TblPrsnt) + { + k2Val = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2; + startSymb = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].startSymbol; + symbLen = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].symbolLength; + } + else + { + k2Val = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].k2; + startSymb = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].startSymbol; + symbLen = ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.puschCfg.timeDomRsrcAllocList[k2Index].symbolLength; + } - /* Calculating time frame to send PUSCH for SR */ - ADD_DELTA_TO_TIME(dciTime, puschTime, k2Val); + /* Calculating time frame to send PUSCH for SR */ + ADD_DELTA_TO_TIME(dciTime, puschTime, k2Val); #ifdef NR_TDD - if(schGetSlotSymbFrmt(puschTime.slot, cell->slotFrmtBitMap) == DL_SLOT) - continue; + if(schGetSlotSymbFrmt(puschTime.slot, cell->slotFrmtBitMap) == DL_SLOT) + continue; #endif - if(cell->schUlSlotInfo[puschTime.slot]->puschUe != 0) - { - continue; - } - k2Found = true; - break; + if(cell->schUlSlotInfo[puschTime.slot]->puschUe != 0) + { + continue; } + k2Found = true; + break; } + } - if(k2Found == true) + if(k2Found == true) + { + ret = schCalculateUlTbs(ueCb, puschTime, symbLen, &startPrb, &totDataReq); + if(totDataReq > 0 && ret == TRUE) { SCH_ALLOC(dciInfo, sizeof(DciInfo)); if(!dciInfo) { DU_LOG("\nERROR --> SCH : Memory Allocation failed for dciInfo alloc"); + + if(ueCb->ulLcPrbEst.dedLcInfo != NULLP) + updateBsrAndLcList(&(ueCb->ulLcPrbEst.dedLcInfo->dedLcList), ueCb->bsrInfo, RFAILED); + + updateBsrAndLcList(&(ueCb->ulLcPrbEst.defLcList), ueCb->bsrInfo, RFAILED); return false; } cell->schDlSlotInfo[dciTime.slot]->ulGrant = dciInfo; memset(dciInfo,0,sizeof(DciInfo)); /* Update PUSCH allocation */ - if(schFillPuschAlloc(ueCb, puschTime, totDataReq, k2Val, startSymb, symbLen) == ROK) + if(schFillPuschAlloc(ueCb, puschTime, totDataReq, startSymb, symbLen, startPrb) == ROK) { if(cell->schUlSlotInfo[puschTime.slot]->schPuschInfo) { @@ -1838,20 +1989,87 @@ bool schProcessSrOrBsrReq(SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId memcpy(&dciInfo->slotIndInfo, &dciTime, sizeof(SlotTimingInfo)); ueCb->srRcvd = false; ueCb->bsrRcvd = false; - for(lcgIdx=0; lcgIdxbsrInfo[lcgIdx].dataVol = 0; - } - cell->schUlSlotInfo[puschTime.slot]->puschUe = ueId; + if(ueCb->ulLcPrbEst.dedLcInfo != NULLP) + updateBsrAndLcList(&(ueCb->ulLcPrbEst.dedLcInfo->dedLcList), ueCb->bsrInfo, ROK); + + updateBsrAndLcList(&(ueCb->ulLcPrbEst.defLcList), ueCb->bsrInfo, ROK); return true; } } } + + if(ueCb->ulLcPrbEst.dedLcInfo != NULLP) + updateBsrAndLcList(&(ueCb->ulLcPrbEst.dedLcInfo->dedLcList), ueCb->bsrInfo, RFAILED); + + updateBsrAndLcList(&(ueCb->ulLcPrbEst.defLcList), ueCb->bsrInfo, RFAILED); } } - return false; + return (ret); } + + +/******************************************************************* + * + * @brief sch Process pending Sr or Bsr Req + * + * @details + * + * Function : updateBsrAndLcList + * + * Functionality: + * Updating the BSRInfo in UECB and Lclist + * + * @params[in] SchCellCb *cell, SlotTimingInfo currTime + * @return ROK - success + * RFAILED - failure + * + *******************************************************************/ +void updateBsrAndLcList(CmLListCp *lcLL, BsrInfo *bsrInfo, uint8_t status) +{ + CmLList *node = NULLP, *next = NULLP; + LcInfo *lcNode = NULLP; + + if(lcLL == NULLP) + { + DU_LOG("\nERROR --> SCH: LcList not present"); + return; + } + + if(lcLL->count) + { + node = lcLL->first; + } + else + { + /*lcLL is empty*/ + return; + } + + while(node) + { + next = node->next; + lcNode = (LcInfo *)node->node; + if(lcNode != NULLP) + { + /*Only when Status is OK then allocation is marked as ZERO and reqBO + * is updated in UE's DB. If Failure, then allocation is added to reqBO + * and same is updated in Ue's DB inside BSR Info structure*/ + if(status == ROK) + { + lcNode->allocBO = 0; + } + + lcNode->reqBO += lcNode->allocBO; + bsrInfo[lcNode->lcId].dataVol = lcNode->reqBO; + if(lcNode->reqBO == 0) + { + handleLcLList(lcLL, lcNode->lcId, DELETE); + } + } + node = next; + } +} /********************************************************************** End of file **********************************************************************/ diff --git a/src/5gnrsch/sch_slot_ind.c b/src/5gnrsch/sch_slot_ind.c index 3193429c3..29a948024 100644 --- a/src/5gnrsch/sch_slot_ind.c +++ b/src/5gnrsch/sch_slot_ind.c @@ -405,14 +405,9 @@ bool schFillBoGrantDlSchedInfo(SchCellCb *cell, SlotTimingInfo currTime, uint8_t if ((ueCb->dlLcPrbEst.defLcList.count == 0) && \ - ((ueCb->dlLcPrbEst.dedLcInfo != NULL) && (ueCb->dlLcPrbEst.dedLcInfo->dedLcList.count == 0))) + ((ueCb->dlLcPrbEst.dedLcInfo == NULL) || (ueCb->dlLcPrbEst.dedLcInfo->dedLcList.count == 0))) { DU_LOG("\nDEBUG --> SCH : No pending BO for any LC id\n"); - if(*(uint8_t *)cell->ueToBeScheduled.first->node == ueId) - { - SCH_FREE(cell->ueToBeScheduled.first->node, sizeof(uint8_t)); - deleteNodeFromLList(&cell->ueToBeScheduled, cell->ueToBeScheduled.first); - } UNSET_ONE_BIT(ueId, cell->boIndBitMap); /* Free the dl ded msg info allocated in macSchDlRlcBoInfo */ @@ -423,11 +418,13 @@ bool schFillBoGrantDlSchedInfo(SchCellCb *cell, SlotTimingInfo currTime, uint8_t } else memset(&dciSlotAlloc->dlMsgSchedInfo[dciSlotAlloc->numSchedInfo], 0, sizeof(DlMsgSchInfo)); - return false; + + /*TRUE because this UE has nothing to be scheduled*/ + return true; } /*[Step3]: Calculate Best FREE BLOCK with MAX PRB count*/ - maxFreePRB = searchLargestFreeBlockDL(cell, pdschTime, &startPrb); + maxFreePRB = searchLargestFreeBlock(cell, pdschTime, &startPrb, DIR_DL); /*[Step4]: Estimation of PRB and BO which can be allocated to each LC in * the list based on RRM policy*/ @@ -441,12 +438,12 @@ bool schFillBoGrantDlSchedInfo(SchCellCb *cell, SlotTimingInfo currTime, uint8_t || ((maxFreePRB < ueCb->dlLcPrbEst.dedLcInfo->rsvdDedicatedPRB))) { ueCb->dlLcPrbEst.sharedNumPrb = maxFreePRB; - DU_LOG("\nWARNING --> SCH : Only Default Slice is scheduled, sharedPRB Count:%d",\ + DU_LOG("\nDEBUG --> SCH : DL Only Default Slice is scheduled, sharedPRB Count:%d",\ ueCb->dlLcPrbEst.sharedNumPrb); /*PRB Alloc for Default LCs*/ prbAllocUsingRRMPolicy(&(ueCb->dlLcPrbEst.defLcList), FALSE, mcsIdx, pdschNumSymbols,\ - &(ueCb->dlLcPrbEst.sharedNumPrb), NULLP, &isTxPayloadLenAdded); + &(ueCb->dlLcPrbEst.sharedNumPrb), NULLP, &isTxPayloadLenAdded, NULLP); } else { @@ -454,20 +451,20 @@ bool schFillBoGrantDlSchedInfo(SchCellCb *cell, SlotTimingInfo currTime, uint8_t /*PRB Alloc for Dedicated LCs*/ prbAllocUsingRRMPolicy(&(ueCb->dlLcPrbEst.dedLcInfo->dedLcList), TRUE, mcsIdx, pdschNumSymbols,\ - &(ueCb->dlLcPrbEst.sharedNumPrb), &(ueCb->dlLcPrbEst.dedLcInfo->rsvdDedicatedPRB), &isTxPayloadLenAdded); + &(ueCb->dlLcPrbEst.sharedNumPrb), &(ueCb->dlLcPrbEst.dedLcInfo->rsvdDedicatedPRB), &isTxPayloadLenAdded, NULLP); /*PRB Alloc for Default LCs*/ prbAllocUsingRRMPolicy(&(ueCb->dlLcPrbEst.defLcList), FALSE, mcsIdx, pdschNumSymbols, \ - &(ueCb->dlLcPrbEst.sharedNumPrb), &(ueCb->dlLcPrbEst.dedLcInfo->rsvdDedicatedPRB), &isTxPayloadLenAdded); + &(ueCb->dlLcPrbEst.sharedNumPrb), &(ueCb->dlLcPrbEst.dedLcInfo->rsvdDedicatedPRB), &isTxPayloadLenAdded, NULLP); } } /*[Step5]:Traverse each LCID in LcList to calculate the exact Scheduled Bytes * using allocated BO per LC and Update dlMsgAlloc(BO report for MAC*/ if(ueCb->dlLcPrbEst.dedLcInfo != NULLP) - updateGrantSizeForBoRpt(&(ueCb->dlLcPrbEst.dedLcInfo->dedLcList), dciSlotAlloc, &(accumalatedSize)); + updateGrantSizeForBoRpt(&(ueCb->dlLcPrbEst.dedLcInfo->dedLcList), dciSlotAlloc, NULLP, &(accumalatedSize)); - updateGrantSizeForBoRpt(&(ueCb->dlLcPrbEst.defLcList), dciSlotAlloc, &(accumalatedSize)); + updateGrantSizeForBoRpt(&(ueCb->dlLcPrbEst.defLcList), dciSlotAlloc, NULLP, &(accumalatedSize)); /*Below case will hit if NO LC(s) are allocated due to resource crunch*/ if (!accumalatedSize) diff --git a/src/5gnrsch/sch_ue_mgr.c b/src/5gnrsch/sch_ue_mgr.c index 310c76195..0c4267505 100644 --- a/src/5gnrsch/sch_ue_mgr.c +++ b/src/5gnrsch/sch_ue_mgr.c @@ -571,25 +571,35 @@ uint8_t MacSchAddUeConfigReq(Pst *pst, SchUeCfg *ueCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t schFillPuschAlloc(SchUeCb *ueCb, SlotTimingInfo puschTime, uint32_t dataVol, uint8_t k2, uint8_t startSymb, uint8_t symbLen) +uint8_t schFillPuschAlloc(SchUeCb *ueCb, SlotTimingInfo puschTime, uint32_t tbSize, + uint8_t startSymb, uint8_t symbLen, uint16_t startPrb) { - uint16_t startRb = 0; uint8_t numRb = 0; - uint16_t tbSize = 0; - uint8_t buffer = 5; - SchCellCb *cellCb = ueCb->cellCb; + SchCellCb *cellCb = NULLP; SchUlSlotInfo *schUlSlotInfo = NULLP; SchPuschInfo puschInfo; - startRb = MAX_NUM_RB; - tbSize = schCalcTbSize(dataVol + buffer); /* 2 bytes header + some buffer */ + if(ueCb == NULLP) + { + DU_LOG("\nERROR --> SCH: UE CB is empty"); + return RFAILED; + } + + cellCb = ueCb->cellCb; + if(cellCb == NULLP) + { + DU_LOG("\nERROR --> SCH: CELL CB is empty"); + return RFAILED; + } + + tbSize += UL_TX_BUFFER_SIZE; /* 2 bytes header + some buffer */ numRb = schCalcNumPrb(tbSize, ueCb->ueCfg.ulModInfo.mcsIndex, symbLen); - allocatePrbUl(cellCb, puschTime, startSymb, symbLen, &startRb, numRb); + allocatePrbUl(cellCb, puschTime, startSymb, symbLen, &startPrb, numRb); puschInfo.crnti = ueCb->crnti; puschInfo.harqProcId = SCH_HARQ_PROC_ID; puschInfo.resAllocType = SCH_ALLOC_TYPE_1; - puschInfo.fdAlloc.startPrb = startRb; + puschInfo.fdAlloc.startPrb = startPrb; puschInfo.fdAlloc.numPrb = numRb; puschInfo.tdAlloc.startSymb = startSymb; puschInfo.tdAlloc.numSymb = symbLen; diff --git a/src/5gnrsch/sch_utils.c b/src/5gnrsch/sch_utils.c index 668d0c298..a53232cd4 100644 --- a/src/5gnrsch/sch_utils.c +++ b/src/5gnrsch/sch_utils.c @@ -1348,7 +1348,7 @@ LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLcLL action) if(lcLL == NULLP) { - DU_LOG("\nERROR -->SCH: LcList doesnt exist"); + DU_LOG("\nERROR --> SCH: LcList doesnt exist"); return NULLP; } node = lcLL->first; @@ -1359,7 +1359,6 @@ LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLcLL action) lcNode = (LcInfo *)node->node; if(lcNode->lcId == lcId) { - DU_LOG("\nINFO --> SCH : LcID:%d found in LL",lcId); found = TRUE; break; } @@ -1387,7 +1386,6 @@ LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLcLL action) /*List is empty; Initialize the LL ControlPointer*/ if(lcLL->count == 0) { - DU_LOG("\nINFO --> SCH: First LC:%d to add in this List",lcId); cmLListInit(lcLL); } @@ -1403,17 +1401,16 @@ LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLcLL action) } else { - DU_LOG("\nERROR --> SCH : Allocation of List failed,lcId:%d",lcId); + DU_LOG("\nERROR --> SCH : Allocation of List failed,lcId:%d",lcId); return NULLP; } if(addNodeToLList(lcLL, lcNode, NULLP) == RFAILED) { - DU_LOG("\nERROR --> SCH : failed to Add Node,lcId:%d",lcId); + DU_LOG("\nERROR --> SCH : failed to Add Node,lcId:%d",lcId); SCH_FREE(lcNode, sizeof(LcInfo)); return NULLP; } - DU_LOG("\nINFO --> SCH : Added new Node in List for lcId:%d\n",lcId); return lcNode; } @@ -1421,20 +1418,20 @@ LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLcLL action) { if(!found || lcNode == NULLP) { - DU_LOG("\nERROR --> SCH: LCID: %d not found; thus Deletion unsuccessful",lcId); + DU_LOG("\nERROR --> SCH: LCID%d not found; thus Deletion unsuccessful",lcId); } else { if(deleteNodeFromLList(lcLL, node) == ROK) SCH_FREE(lcNode, sizeof(LcInfo)); - DU_LOG("\nINFO --> SCH: LCID: %d Deleted successfully",lcId); + DU_LOG("\nDEBUG --> SCH: LCID%d Deleted successfully",lcId); } return NULLP; } default: { - DU_LOG("\nERROR --> SCH: Action type wrong: %d",action); + DU_LOG("\nERROR --> SCH: Action type wrong: %d",action); break; } } @@ -1468,13 +1465,12 @@ uint8_t updateLcListReqPRB(CmLListCp *lcLL, uint8_t lcId, uint32_t payloadSize) if(lcNode == NULLP) { - DU_LOG("\nERROR --> SCH : LC is neither present nor able to create in List lcId:%d",lcId); + DU_LOG("\nERROR --> SCH : LC is neither present nor able to create in List lcId:%d",lcId); return RFAILED; } lcNode->reqBO = payloadSize; lcNode->allocBO = 0; lcNode->allocPRB = 0; /*Re-Initializing the AllocPRB*/ - DU_LOG("\nINFO --> SCH : LCID:%d, reqBO:%d", lcId, lcNode->reqBO); return ROK; } @@ -1501,7 +1497,7 @@ void deleteLcLL(CmLListCp *lcLL) if(lcLL == NULLP) { - DU_LOG("\nINFO --> SCH: LcList doesnt exist"); + DU_LOG("\nERROR --> SCH: LcList doesnt exist"); return; } node = lcLL->first; @@ -1589,7 +1585,7 @@ void printLcLL(CmLListCp *lcLL) if(lcLL == NULLP) { - DU_LOG("\nINFO -->SCH: LcList doesnt exist"); + DU_LOG("\nINFO --> SCH: LcList doesnt exist"); return; } node = lcLL->first; @@ -1598,7 +1594,7 @@ void printLcLL(CmLListCp *lcLL) lcNode = (LcInfo *)node->node; if(lcNode) { - DU_LOG("\nINFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\ + DU_LOG("\nINFO --> SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\ lcNode->lcId,lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB); } diff --git a/src/cm/mac_sch_interface.h b/src/cm/mac_sch_interface.h index 7542bd449..72f172cf5 100644 --- a/src/cm/mac_sch_interface.h +++ b/src/cm/mac_sch_interface.h @@ -35,6 +35,7 @@ #define EVENT_UE_DELETE_RSP_TO_MAC 16 #define EVENT_CELL_DELETE_REQ_TO_SCH 17 #define EVENT_CELL_DELETE_RSP_TO_MAC 18 +#define EVENT_LONG_BSR 19 /*macros*/ @@ -87,6 +88,7 @@ #define RAR_PAYLOAD_SIZE 10 /* As per spec 38.321, sections 6.1.5 and 6.2.3, RAR PDU is 8 bytes long and 2 bytes of padding */ #define TX_PAYLOAD_HDR_LEN 32 /* Intel L1 requires adding a 32 byte header to transmitted payload */ +#define UL_TX_BUFFER_SIZE 5 #define MAX_NUM_CONFIG_SLOTS 160 /*Max number of slots as per the numerology*/ #define MAX_NUM_K0_IDX 16 /* Max number of pdsch time domain downlink allocation */ diff --git a/src/cu_stub/cu_f1ap_msg_hdl.c b/src/cu_stub/cu_f1ap_msg_hdl.c index 95cab1700..009f0a1ec 100644 --- a/src/cu_stub/cu_f1ap_msg_hdl.c +++ b/src/cu_stub/cu_f1ap_msg_hdl.c @@ -1813,7 +1813,7 @@ uint8_t procInitULRRCMsg(F1AP_PDU_t *f1apMsg) uint8_t idx, rrcMsgType, gnbDuUeF1apId; uint8_t ret =ROK; InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP; - DU_LOG("\nINFO --> F1AP : filling the required values in DB in procInitULRRCMsg"); + DU_LOG("\nINFO --> F1AP : filling the required values in DB in procInitULRRCMsg"); initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer; diff --git a/src/phy_stub/phy_stub.h b/src/phy_stub/phy_stub.h index 22d968818..68c30df77 100644 --- a/src/phy_stub/phy_stub.h +++ b/src/phy_stub/phy_stub.h @@ -36,6 +36,15 @@ bool slotIndicationStarted; uint16_t sfnValue; uint16_t slotValue; +/*Mapping between LCG ID and BSR Idx*/ +typedef struct lcgBufferSize +{ + uint8_t lcgId; /*LCG ID for which BSR will be requested*/ + /*BufferStatus Index. This is as per Spec 38.321, BSR will be reported as Index + * Refer table Table 6.1.3.1-1:Short_BSR and Table 6.1.3.1-2:Long_BSR*/ + uint8_t bsIdx; +}LcgBufferSize; + /* UE specific information */ typedef struct ueCb { @@ -80,6 +89,10 @@ void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg); void l1StartConsoleHandler(); void l1HdlSlotIndicaion(bool); void GenerateTicks(); +uint8_t l1SendUlUserData(uint8_t drbId); +uint8_t l1SendStatusPdu(); +uint16_t l1BuildAndSendSlotIndication(); +uint16_t l1BuildAndSendStopInd(); /********************************************************************** End of file diff --git a/src/phy_stub/phy_stub_msg_hdl.c b/src/phy_stub/phy_stub_msg_hdl.c index af6a134e4..1d035730d 100644 --- a/src/phy_stub/phy_stub_msg_hdl.c +++ b/src/phy_stub/phy_stub_msg_hdl.c @@ -1051,7 +1051,6 @@ S16 l1HdlUlTtiReq(uint16_t msgLen, void *msg) l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn); ueDb.numActvUe++; } -#if 0 /* Send RACH Ind to L2 for second UE */ if(ueDb.ueCb[UE_IDX_1].rachIndSent == false && ulTtiReq->sfn == 304 && ulTtiReq->slot == 0) { @@ -1067,7 +1066,6 @@ S16 l1HdlUlTtiReq(uint16_t msgLen, void *msg) l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn); ueDb.numActvUe++; } -#endif MAC_FREE(msg, msgLen); #endif return ROK; @@ -1586,6 +1584,150 @@ void l1ProcessFapiRequest(uint8_t msgType, uint32_t msgLen, void *msg) #endif } } + +#ifdef INTEL_FAPI +/******************************************************************* + * + * @brief Builds and Send the BSR message to MAC + * + * @details + * + * Function : l1BuildAndSendBSR + * + * Functionality: + * -Send the BSR Message to MAC + * + * @params[in] BSR type + * array of LCGID and BSIdx + * @return void + * + *****************************************************************/ +uint16_t l1BuildAndSendBSR(uint8_t ueIdx, BsrType bsrType,\ + LcgBufferSize lcgBsIdx[MAX_NUM_LOGICAL_CHANNEL_GROUPS]) +{ + fapi_rx_data_indication_t *rxDataInd; + fapi_pdu_ind_info_t *pduInfo; + uint8_t *pdu = NULLP; + uint16_t byteIdx = 0; + uint32_t msgLen = 0; + uint8_t pduIdx = 0, lcgIdx = 0, lcgIdxPos = 0; + + MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t)); + if(!rxDataInd) + { + DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication"); + return RFAILED; + } + memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t)); + + msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t); + rxDataInd->sfn = 0; + rxDataInd->slot = 0; + rxDataInd->numPdus = 1; + + pduInfo = &rxDataInd->pdus[pduIdx]; + pduInfo->handle = (ODU_START_CRNTI + ueIdx); + pduInfo->rnti = (ODU_START_CRNTI + ueIdx); + pduInfo->harqId = 1; + + /* Since status pdu size = 3bytes and 2 bytes of MAC header, + * setting tbsize = 24 from Table 5.1.3.2-1 spec 38.214 */ + pduInfo->pdu_length = 24; + pduInfo->ul_cqi = 0; + pduInfo->timingAdvance = 0; + pduInfo->rssi = 0; + + /* Filling pdu with random values for testing */ + pduInfo->pduData = NULL; + MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length); + if(!pduInfo->pduData) + { + DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu"); + MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t)); + return RFAILED; + } + + /* Filling PDU */ + pdu = (uint8_t *)pduInfo->pduData; + + switch(bsrType) + { + case SHORT_BSR: + { + DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU "); + + /* For Short BSR + * MAC subheader format is R/R/LcId (1Byte) + * LCId is 61 + * From 38.321 section 6.1.1 + */ + pdu[byteIdx++] = 61; // LCID + pdu[byteIdx++] = (lcgBsIdx[0].lcgId << 5) | lcgBsIdx[0].bsIdx; + break; + } + + case LONG_BSR: + { + DU_LOG("\nDEBUG --> PHY_STUB: Forming LONG BSR PDU "); + + /* For Long BSR + * MAC subheader format is R/R/LcId (1Byte) + * LCId is 62 + * From 38.321 section 6.1.1 + */ + pdu[byteIdx++] = 62; // LCID + + /*Octet where lcgId bitmap will be present*/ + lcgIdxPos = byteIdx; + byteIdx++; + for(lcgIdx = 0; lcgIdx < MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++) + { + if(lcgBsIdx[lcgIdx].bsIdx > 0) + { + pdu[lcgIdxPos] |= 1 << lcgBsIdx[lcgIdx].lcgId; + pdu[byteIdx++] = lcgBsIdx[lcgIdx].bsIdx; + } + } + + break; + } + + default: + { + DU_LOG("\nERROR --> PHY_STUB: Incorrect BSR type:%d!", bsrType); + if(pduInfo->pdu_length) + MAC_FREE(pduInfo->pduData, pduInfo->pdu_length); + MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t)); + return RFAILED; + } + } + /* Filling MAC SDU for Padding bytes*/ + if(byteIdx < pduInfo->pdu_length) + { + /* For Padding + * MAC subheader format is R/R/LCId (1byte) + * LCId is 63 for padding + * From 38.321 section 6.1.1 + */ + pdu[byteIdx++] = 63; + + for(; byteIdx < pduInfo->pdu_length; byteIdx++) + pdu[byteIdx] = 0; + } + msgLen += pduInfo->pdu_length; + fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen); + + /* Sending Rx data indication to MAC */ + DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC"); + procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd); + + if(pduInfo->pdu_length) + MAC_FREE(pduInfo->pduData, pduInfo->pdu_length); + MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t)); + return ROK; +} +#endif + /********************************************************************** End of file **********************************************************************/ diff --git a/src/phy_stub/phy_stub_thread_hdl.c b/src/phy_stub/phy_stub_thread_hdl.c index 7094f6a5f..a3c37cd61 100644 --- a/src/phy_stub/phy_stub_thread_hdl.c +++ b/src/phy_stub/phy_stub_thread_hdl.c @@ -25,11 +25,10 @@ #include "fapi_vendor_extension.h" #endif #include "phy_stub.h" +#include "mac_sch_interface.h" -uint8_t l1SendUlUserData(); -uint8_t l1SendStatusPdu(); -uint16_t l1BuildAndSendSlotIndication(); -uint16_t l1BuildAndSendStopInd(); +extern uint16_t l1BuildAndSendBSR(uint8_t ueIdx, BsrType bsrType,\ + LcgBufferSize lcgBsIdx[MAX_NUM_LOGICAL_CHANNEL_GROUPS]); pthread_t thread = 0; /******************************************************************* @@ -142,13 +141,15 @@ void l1HdlSlotIndicaion(bool stopSlotInd) * ****************************************************************/ void *l1ConsoleHandler(void *args) { - char ch; - uint8_t drbIdx = 0; + char ch, ch1; + uint8_t drbIdx = 0, lcgIdx = 0, ueIdx = 0; + LcgBufferSize lcgBS[MAX_NUM_LOGICAL_CHANNEL_GROUPS]; while(true) { /* Send UL user data to DU when user enters 'd' on console */ - if((ch = getchar()) == 'd') + ch = getchar(); + if(ch == 'd') { /* Start Pumping data from PHY stub to DU */ for(drbIdx = 0; drbIdx < NUM_DRB_TO_PUMP_DATA; drbIdx++) //Number of DRB times the loop will run @@ -157,11 +158,37 @@ void *l1ConsoleHandler(void *args) l1SendUlUserData(drbIdx); } } - else if((ch = getchar()) == 'c') + else if(ch =='c') { /* Send Control PDU from PHY stub to DU */ - DU_LOG("\nDEBUG --> PHY STUB: Sending Status PDU"); - l1SendStatusPdu(); + DU_LOG("\nDEBUG --> PHY STUB: Sending Status PDU"); + l1SendStatusPdu(); + } + else if(ch == 'b') + { + memset(lcgBS, 0, (MAX_NUM_LOGICAL_CHANNEL_GROUPS * sizeof(LcgBufferSize))); + /* Send Control PDU from PHY stub to DU */ + ch1 = getchar(); + for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) + { + if(ch1 == 'l') + { + for(lcgIdx = 0; lcgIdx < NUM_DRB_TO_PUMP_DATA; lcgIdx++) + { + lcgBS[lcgIdx].lcgId = MIN_DRB_LCID + lcgIdx; + lcgBS[lcgIdx].bsIdx = lcgIdx + 1; + } + l1BuildAndSendBSR(ueIdx, LONG_BSR, lcgBS); + } + else if(ch1 == 's') + { + lcgIdx = 0; + + lcgBS[lcgIdx].lcgId = MIN_DRB_LCID + lcgIdx; + lcgBS[lcgIdx].bsIdx = lcgIdx + 1; + l1BuildAndSendBSR(ueIdx, SHORT_BSR, lcgBS); + } + } } DU_LOG("\n"); continue; -- 2.16.6