From b8044fce6d8a277254f235d128c8729ed0b5e7b0 Mon Sep 17 00:00:00 2001 From: balajihands Date: Wed, 27 May 2020 09:55:14 +0530 Subject: [PATCH] Muxing mac pdu and lower mac changes for Msg4 Change-Id: I06ecaf3081e2187b9fb5fd0526845859adb7faa8 Signed-off-by: Balaji Shankaran --- src/5gnrmac/lwr_mac_fsm.c | 1238 +++++++++++++++++++++++++++----------------- src/5gnrmac/lwr_mac_fsm.h | 6 + src/5gnrmac/mac.h | 57 +- src/5gnrmac/mac_demux.c | 3 + src/5gnrmac/mac_msg_hdl.c | 53 +- src/5gnrmac/mac_mux.c | 179 +++++++ src/5gnrmac/mac_rach.c | 29 +- src/5gnrmac/mac_slot_ind.c | 45 +- 8 files changed, 1083 insertions(+), 527 deletions(-) diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index c01734a37..88e8a656c 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -111,8 +111,8 @@ void lwrMacInit() * ****************************************************************/ S16 lwr_mac_handleInvalidEvt(void *msg) { - printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); - RETVALUE(ROK); + printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); + RETVALUE(ROK); } #ifdef FAPI @@ -645,18 +645,18 @@ PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr) PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr) { - if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) - { - (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1; - } - else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) - { - (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2; - } - else - { - (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE; - } + if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) + { + (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1; + } + else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) + { + (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2; + } + else + { + (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE; + } } /******************************************************************* @@ -1270,32 +1270,32 @@ PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr) uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type) { - //uint16_t valueLen; - void *posPtr; - //valueLen = tlv->tl.length; - posPtr = &tlv->tl.tag; - posPtr += sizeof(tlv->tl.tag); - posPtr += sizeof(tlv->tl.length); - /*TO DO: malloc to SSI memory */ - if(type == FAPI_UINT_8) - { - //temp = (uint8_t *)malloc(valueLen * sizeof(U8)); - //memcpy(temp, posPtr, valueLen); - return(*(uint8_t *)posPtr); - } - else if(type == FAPI_UINT_16) - { - return(*(uint16_t *)posPtr); - } - else if(type == FAPI_UINT_32) - { - return(*(uint32_t *)posPtr); - } - else - { - DU_LOG("\nLWR_MAC: Value Extraction failed" ); - return RFAILED; - } + //uint16_t valueLen; + void *posPtr; + //valueLen = tlv->tl.length; + posPtr = &tlv->tl.tag; + posPtr += sizeof(tlv->tl.tag); + posPtr += sizeof(tlv->tl.length); + /*TO DO: malloc to SSI memory */ + if(type == FAPI_UINT_8) + { + //temp = (uint8_t *)malloc(valueLen * sizeof(U8)); + //memcpy(temp, posPtr, valueLen); + return(*(uint8_t *)posPtr); + } + else if(type == FAPI_UINT_16) + { + return(*(uint16_t *)posPtr); + } + else if(type == FAPI_UINT_32) + { + return(*(uint32_t *)posPtr); + } + else + { + DU_LOG("\nLWR_MAC: Value Extraction failed" ); + return RFAILED; + } } #endif /* FAPI */ /******************************************************************* @@ -1322,7 +1322,7 @@ S16 lwr_mac_handleParamReqEvt(void *msg) uint32_t msgLen = 0; //Length of message Body fapi_param_req_t *paramReq = NULL; - LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); + LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); if(paramReq != NULL) { fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen); @@ -1363,7 +1363,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) /* stopGuardTimer(); */ uint8_t index; uint32_t encodedVal; - fapi_param_resp_t *paramRsp; + fapi_param_resp_t *paramRsp; ClCellParam *cellParam = NULLP; paramRsp = (fapi_param_resp_t *)msg; @@ -1385,7 +1385,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15) { - cellParam->releaseCapability = RELEASE_15; + cellParam->releaseCapability = RELEASE_15; } break; @@ -1394,7 +1394,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState) { printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event); - RETVALUE(RFAILED); + RETVALUE(RFAILED); } break; @@ -1402,11 +1402,11 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); if(encodedVal != RFAILED && encodedVal != 0) { - cellParam->skipBlankDlConfig = SUPPORTED; + cellParam->skipBlankDlConfig = SUPPORTED; } else { - cellParam->skipBlankDlConfig = NOT_SUPPORTED; + cellParam->skipBlankDlConfig = NOT_SUPPORTED; } break; @@ -1414,11 +1414,11 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); if(encodedVal != RFAILED && encodedVal != 0) { - cellParam->skipBlankUlConfig = SUPPORTED; + cellParam->skipBlankUlConfig = SUPPORTED; } else { - cellParam->skipBlankUlConfig = NOT_SUPPORTED; + cellParam->skipBlankUlConfig = NOT_SUPPORTED; } break; @@ -1535,7 +1535,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) break; case FAPI_MAX_PUCCHS_PER_SLOT_TAG: - cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); break; case FAPI_PDSCH_MAPPING_TYPE_TAG: @@ -1619,7 +1619,8 @@ S16 lwr_mac_handleParamRspEvt(void *msg) break; case FAPI_MAX_MU_MIMO_USERS_DL_TAG: - cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + cellParam->maxMuMimoUsersDl = \ + getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); break; case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG: @@ -1758,7 +1759,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB) { - cellParam->puschMaxPtrsPorts = encodedVal; + cellParam->puschMaxPtrsPorts = encodedVal; } break; @@ -1847,7 +1848,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) break; default: //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index); - break; + break; } } MAC_FREE(cellParam, sizeof(ClCellParam)); @@ -1912,7 +1913,7 @@ S16 lwr_mac_handleConfigReqEvt(void *msg) macCfgParams = cellParams->macCellCfg; configReqSize = sizeof(fapi_config_req_t); - LWR_MAC_ALLOC(configReq, configReqSize); + LWR_MAC_ALLOC(configReq, configReqSize); if(configReq != NULL) { msgLen = sizeof(macCfgParams.numTlv); @@ -1969,7 +1970,7 @@ S16 lwr_mac_handleConfigReqEvt(void *msg) fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, \ sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen); fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG, - sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen); + sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen); fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, \ sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen); fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, \ @@ -1980,17 +1981,17 @@ S16 lwr_mac_handleConfigReqEvt(void *msg) sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen); fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, \ sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen); - if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq) - { + if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq) + { for(idx = 0; idx < macCfgParams.prachCfg.fdm[0].numUnusedRootSeq; idx++) - fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, \ - sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].unsuedRootSeq[idx], \ + fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, \ + sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].unsuedRootSeq[idx], \ &msgLen); - } - else - { - macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL; - } + } + else + { + macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL; + } fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, \ sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen); @@ -2063,7 +2064,7 @@ S16 lwr_mac_handleConfigRspEvt(void *msg) { #ifdef FAPI fapi_config_resp_t *configRsp; - configRsp = (fapi_config_resp_t *)msg; + configRsp = (fapi_config_resp_t *)msg; DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, \ clGlobalCp.phyState); @@ -2118,7 +2119,7 @@ S16 lwr_mac_handleStartReqEvt(void *msg) uint32_t msgLen = 0; fapi_start_req_t *startReq; - LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t)); + LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t)); if(startReq != NULL) { fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen); @@ -2218,7 +2219,7 @@ PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn) ******************************************************************/ S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, - MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn) + MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn) { uint32_t mibPayload = 0; if(dlTtiReqPdu != NULL) @@ -2288,7 +2289,7 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) uint32_t reserved; /* Size(in bits) of each field in DCI format 0_1 - * as mentioned in spec 38.214 */ + * as mentioned in spec 38.214 */ uint8_t freqDomResAssignSize; uint8_t timeDomResAssignSize = 4; uint8_t VRB2PRBMapSize = 1; @@ -2317,7 +2318,7 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) * Spec 38.214 Sec 5.1.2.2.2 */ coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size; - rbStart = 0; /* For SIB1 */ + rbStart = 0; /* For SIB1 */ //rbStart = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbStart; rbLen = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbSize; @@ -2410,118 +2411,290 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo) { - if(dlDciPtr != NULLP) - { - uint8_t numBytes; - uint8_t bytePos; - uint8_t bitPos; - - uint16_t coreset0Size; - uint16_t rbStart; - uint16_t rbLen; - uint32_t freqDomResAssign; - uint8_t timeDomResAssign; - uint8_t VRB2PRBMap; - uint8_t modNCodScheme; - uint8_t tbScaling; - uint32_t reserved; - - /* Size(in bits) of each field in DCI format 1_0 */ - uint8_t freqDomResAssignSize; - uint8_t timeDomResAssignSize = 4; - uint8_t VRB2PRBMapSize = 1; - uint8_t modNCodSchemeSize = 5; - uint8_t tbScalingSize = 2; - uint8_t reservedSize = 16; - - dlDciPtr->rnti = rarPdcchInfo->dci.rnti; - dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId; - dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti; - dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex; - dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel; - dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs; - dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize; - dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces; - dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; - dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; - dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue; - dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS; - - /* Calculating freq domain resource allocation field value and size - * coreset0Size = Size of coreset 0 - * RBStart = Starting Virtual Rsource block - * RBLen = length of contiguously allocted RBs - * Spec 38.214 Sec 5.1.2.2.2 - */ - - /* TODO: Fill values of coreset0Size, rbStart and rbLen */ - coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size; - rbStart = 0; /* For SIB1 */ - //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart; - rbLen = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbSize; - - if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) - { - if((rbLen - 1) <= floor(coreset0Size / 2)) - freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; - else - freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ - + (coreset0Size - 1 - rbStart); - - freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); - } - - /* Fetching DCI field values */ - timeDomResAssign = rarPdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1; - VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping; - modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; - tbScaling = 0; /* configured to 0 scaling */ - reserved = 0; - - /* Reversing bits in each DCI field */ - freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); - timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); - VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); - modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); - tbScaling = reverseBits(tbScaling, tbScalingSize); - - /* Calulating total number of bytes in buffer */ - dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ - + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize; - - numBytes = dlDciPtr->payloadSizeBits / 8; - if(dlDciPtr->payloadSizeBits % 8) - numBytes += 1; - - if(numBytes > DCI_PAYLOAD_BYTE_LEN) - { - DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected"); - return; - } - - /* Initialize buffer */ - for(bytePos = 0; bytePos < numBytes; bytePos++) - dlDciPtr->payload[bytePos] = 0; - - bytePos = numBytes - 1; - bitPos = 0; - - /* Packing DCI format fields */ - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - freqDomResAssign, freqDomResAssignSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - timeDomResAssign, timeDomResAssignSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - VRB2PRBMap, VRB2PRBMapSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - modNCodScheme, modNCodSchemeSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - tbScaling, tbScalingSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - reserved, reservedSize); - } + if(dlDciPtr != NULLP) + { + uint8_t numBytes; + uint8_t bytePos; + uint8_t bitPos; + + uint16_t coreset0Size; + uint16_t rbStart; + uint16_t rbLen; + uint32_t freqDomResAssign; + uint8_t timeDomResAssign; + uint8_t VRB2PRBMap; + uint8_t modNCodScheme; + uint8_t tbScaling; + uint32_t reserved; + + /* Size(in bits) of each field in DCI format 1_0 */ + uint8_t freqDomResAssignSize; + uint8_t timeDomResAssignSize = 4; + uint8_t VRB2PRBMapSize = 1; + uint8_t modNCodSchemeSize = 5; + uint8_t tbScalingSize = 2; + uint8_t reservedSize = 16; + + dlDciPtr->rnti = rarPdcchInfo->dci.rnti; + dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize; + dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue; + dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS; + + /* Calculating freq domain resource allocation field value and size + * coreset0Size = Size of coreset 0 + * RBStart = Starting Virtual Rsource block + * RBLen = length of contiguously allocted RBs + * Spec 38.214 Sec 5.1.2.2.2 + */ + + /* TODO: Fill values of coreset0Size, rbStart and rbLen */ + coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size; + rbStart = 0; /* For SIB1 */ + //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart; + rbLen = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbSize; + + if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) + { + if((rbLen - 1) <= floor(coreset0Size / 2)) + freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; + else + freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ + + (coreset0Size - 1 - rbStart); + + freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); + } + + /* Fetching DCI field values */ + timeDomResAssign = rarPdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1; + VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping; + modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; + tbScaling = 0; /* configured to 0 scaling */ + reserved = 0; + + /* Reversing bits in each DCI field */ + freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); + modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); + tbScaling = reverseBits(tbScaling, tbScalingSize); + + /* Calulating total number of bytes in buffer */ + dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ + + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize; + + numBytes = dlDciPtr->payloadSizeBits / 8; + if(dlDciPtr->payloadSizeBits % 8) + numBytes += 1; + + if(numBytes > DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + dlDciPtr->payload[bytePos] = 0; + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + VRB2PRBMap, VRB2PRBMapSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + tbScaling, tbScalingSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + reserved, reservedSize); + } } /* fillRarDlDciPdu */ +/******************************************************************* + * + * @brief fills msg4 Dl DCI PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillMsg4DlDciPdu + * + * Functionality: + * -Fills the Msg4 Dl DCI PDU + * + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ +void fillMsg4DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *msg4PdcchInfo,\ +Msg4Info *msg4Info) +{ + if(dlDciPtr != NULLP) + { + uint8_t numBytes; + uint8_t bytePos; + uint8_t bitPos; + + uint16_t coreset0Size = 0; + uint16_t rbStart = 0; + uint16_t rbLen = 0; + uint8_t dciFormatId; + uint32_t freqDomResAssign; + uint8_t timeDomResAssign; + uint8_t VRB2PRBMap; + uint8_t modNCodScheme; + uint8_t ndi = 0; + uint8_t redundancyVer = 0; + uint8_t harqProcessNum = 0; + uint8_t dlAssignmentIdx = 0; + uint8_t pucchTpc = 0; + uint8_t pucchResoInd = 0; + uint8_t harqFeedbackInd = 0; + + /* Size(in bits) of each field in DCI format 1_0 */ + uint8_t dciFormatIdSize = 1; + uint8_t freqDomResAssignSize; + uint8_t timeDomResAssignSize = 4; + uint8_t VRB2PRBMapSize = 1; + uint8_t modNCodSchemeSize = 5; + uint8_t ndiSize = 1; + uint8_t redundancyVerSize = 2; + uint8_t harqProcessNumSize = 4; + uint8_t dlAssignmentIdxSize = 2; + uint8_t pucchTpcSize = 2; + uint8_t pucchResoIndSize = 3; + uint8_t harqFeedbackIndSize = 3; + + dlDciPtr->rnti = msg4PdcchInfo->dci.rnti; + dlDciPtr->scramblingId = msg4PdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = msg4PdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = msg4PdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = msg4PdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = msg4PdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = msg4PdcchInfo->dci.beamPdcchInfo.prgSize; + dlDciPtr->pc_and_bform.digBfInterfaces = msg4PdcchInfo->dci.beamPdcchInfo.digBfInterfaces; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr->beta_pdcch_1_0 = msg4PdcchInfo->dci.txPdcchPower.powerValue; + dlDciPtr->powerControlOfssetSS = msg4PdcchInfo->dci.txPdcchPower.powerControlOffsetSS; + + /* Calculating freq domain resource allocation field value and size + * coreset0Size = Size of coreset 0 + * RBStart = Starting Virtual Rsource block + * RBLen = length of contiguously allocted RBs + * Spec 38.214 Sec 5.1.2.2.2 + */ + + /* TODO: Fill values of coreset0Size, rbStart and rbLen */ + coreset0Size = msg4PdcchInfo->coreset0Cfg.coreSet0Size; + //rbStart = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbStart; + rbLen = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbSize; + + if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) + { + if((rbLen - 1) <= floor(coreset0Size / 2)) + freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; + else + freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ + + (coreset0Size - 1 - rbStart); + + freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); + } + + /* Fetching DCI field values */ + dciFormatId = msg4Info->dciFormatId; /* DCI indentifier for DL */ + timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1; + VRB2PRBMap = msg4PdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping; + modNCodScheme = msg4PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; + ndi = msg4Info->ndi; + redundancyVer = msg4PdcchInfo->dci.pdschCfg->codeword[0].rvIndex; + harqProcessNum = msg4Info->harqProcNum; + dlAssignmentIdx = msg4Info->dlAssignIdx; + pucchTpc = msg4Info->pucchTpc; + pucchResoInd = msg4Info->pucchResInd; + harqFeedbackInd = msg4Info->harqFeedbackInd; + + /* Reversing bits in each DCI field */ + dciFormatId = reverseBits(dciFormatId, dciFormatIdSize); + freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); + modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); + ndi = reverseBits(ndi, ndiSize); + redundancyVer = reverseBits(redundancyVer, redundancyVerSize); + harqProcessNum = reverseBits(harqProcessNum, harqProcessNumSize); + dlAssignmentIdx = reverseBits(dlAssignmentIdx , dlAssignmentIdxSize); + pucchTpc = reverseBits(pucchTpc, pucchTpcSize); + pucchResoInd = reverseBits(pucchResoInd, pucchResoIndSize); + harqFeedbackInd = reverseBits(harqFeedbackInd, harqFeedbackIndSize); + + + /* Calulating total number of bytes in buffer */ + dlDciPtr->payloadSizeBits = (dciFormatIdSize + freqDomResAssignSize\ + + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\ + + ndiSize + redundancyVerSize + harqProcessNumSize + dlAssignmentIdxSize\ + + pucchTpcSize + pucchResoIndSize + harqFeedbackIndSize); + + numBytes = dlDciPtr->payloadSizeBits / 8; + if(dlDciPtr->payloadSizeBits % 8) + numBytes += 1; + + if(numBytes > DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + dlDciPtr->payload[bytePos] = 0; + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + dciFormatId, dciFormatIdSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + VRB2PRBMap, VRB2PRBMapSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + ndi, ndiSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + redundancyVer, redundancyVerSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + redundancyVer, redundancyVerSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + harqProcessNum, harqProcessNumSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + dlAssignmentIdx, dlAssignmentIdxSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + pucchTpc, pucchTpcSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + pucchResoInd, pucchResoIndSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + harqFeedbackInd, harqFeedbackIndSize); + } +} /* fillMsg4DlDciPdu */ + /******************************************************************* * * @brief fills PDCCH PDU required for DL TTI info in MAC @@ -2541,43 +2714,55 @@ void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo) * ******************************************************************/ -S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdcchCfg *pdcchInfo, -uint32_t *msgLen) +S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t *msgLen, RntiType rntiType) { - if(dlTtiReqPdu != NULLP) - { - 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.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex; - dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols; - memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6); - dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType; - dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize; - dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize; - dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType; - 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*))); - - if(pdcchInfo->dci.rnti == SI_RNTI) - { - fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); - } - else - { - fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); - } - - /* Calculating PDU length. Considering only one dl dci pdu for now */ - dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t); - SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \ - sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize)); + if(dlTtiReqPdu != NULLP) + { + PdcchCfg *pdcchInfo = NULLP; + if(rntiType == SI_RNTI_TYPE) + { + pdcchInfo = &dlAlloc->brdcstAlloc.sib1Alloc.sib1PdcchCfg; + fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); + } + else if(rntiType == RA_RNTI_TYPE) + { + pdcchInfo = &dlAlloc->rarAlloc.rarPdcchCfg; + fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); + } + else if(rntiType == TC_RNTI_TYPE) + { + pdcchInfo = &dlAlloc->msg4Alloc->msg4PdcchCfg; + fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\ + &dlAlloc->msg4Alloc->msg4Info); + } + else + { + DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu"); + 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.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex; + dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols; + memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6); + dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType; + dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize; + dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize; + dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType; + 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); + SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \ + sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize)); } return ROK; @@ -2682,8 +2867,9 @@ uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo) { uint8_t count = 0; uint8_t idx = 0; - if(dlInfo->isBroadcastPres) - { + + if(dlInfo->isBroadcastPres) + { if(dlInfo->brdcstAlloc.ssbTrans) { for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++) @@ -2696,10 +2882,15 @@ uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo) count += 2; } } - if(dlInfo->isRarPres) - { - count += 2; - } + if(dlInfo->isRarPres) + { + count += 2; + } + if(dlInfo->msg4Alloc) + { + count += 2; + } + return count; } @@ -2721,14 +2912,20 @@ uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo) uint8_t calcTxDataReqPduCount(DlAlloc *dlInfo) { uint8_t count = 0; - if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans) - { - count++; - } - if(dlInfo->isRarPres) - { - count++; - } + + if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans) + { + count++; + } + if(dlInfo->isRarPres) + { + count++; + } + if(dlInfo->msg4Alloc) + { + count++; + } + return count; } /*********************************************************************** @@ -2753,36 +2950,35 @@ uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg, uint32_t *msgLen, uint16_t pduIndex) { uint32_t pduLen = 0; - uint32_t *sib1TxdataValue = NULLP; - - pduDesc[pduIndex].pduIndex = pduIndex; - pduDesc[pduIndex].numTlvs = 1; - - /* fill the TLV */ - /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ - pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */ - pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen; - LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); - if(sib1TxdataValue == NULLP) - { - return RFAILED; - } - memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu, - macCellCfg->sib1Cfg.sib1PduLen); - pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue; - - /* The total length of the PDU description and PDU data */ - pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ - pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ + uint32_t *sib1TxdataValue = NULLP; + + pduDesc[pduIndex].pduIndex = pduIndex; + pduDesc[pduIndex].numTlvs = 1; + + /* fill the TLV */ + /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ + pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */ + pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen; + LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); + if(sib1TxdataValue == NULLP) + { + return RFAILED; + } + memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu, + macCellCfg->sib1Cfg.sib1PduLen); + pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue; + + /* The total length of the PDU description and PDU data */ + pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ + pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ pduDesc[pduIndex].pduLength = pduLen; - msgLen += pduLen; + msgLen += pduLen; #ifndef INTEL_WLS MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); #endif - - return ROK; + return ROK; } /*********************************************************************** @@ -2807,28 +3003,28 @@ uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo, uint32_t *msgLen, uint16_t pduIndex) { uint32_t pduLen = 0; - uint32_t *rarTxdataValue = NULLP; - - pduDesc[pduIndex].pduIndex = pduIndex; - pduDesc[pduIndex].numTlvs = 1; - - /* fill the TLV */ - /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ - pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */ - pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen; - LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen); - if(rarTxdataValue == NULLP) - { - return RFAILED; - } - memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen); - pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue; - - /* The total length of the PDU description and PDU data */ - pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ - pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ + uint32_t *rarTxdataValue = NULLP; + + pduDesc[pduIndex].pduIndex = pduIndex; + pduDesc[pduIndex].numTlvs = 1; + + /* fill the TLV */ + /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ + pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */ + pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen; + LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen); + if(rarTxdataValue == NULLP) + { + return RFAILED; + } + memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen); + pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue; + + /* The total length of the PDU description and PDU data */ + pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ + pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ pduDesc[pduIndex].pduLength = pduLen; - msgLen += pduLen; + msgLen += pduLen; /* TODO: The pointer value which was stored, needs to be free-ed at PHY * * But since we did not implement WLS, this has to be done here @@ -2837,11 +3033,65 @@ uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo, MAC_FREE(rarTxdataValue,rarInfo->rarPduLen); #endif - return ROK; + return ROK; } -#endif +/*********************************************************************** + * + * @brief fills the Msg4 TX-DATA request message + * + * @details + * + * Function : fillMsg4TxDataReq + * + * Functionality: + * - fills the Msg4 TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] Msg4Info *msg4Info + * @params[in] uint32_t *msgLen + * @params[in] uint16_t pduIndex + * @return ROK + * + * ********************************************************************/ +uint8_t fillMsg4TxDataReq(fapi_tx_pdu_desc_t *pduDesc, Msg4Info *msg4Info, + uint32_t *msgLen, uint16_t pduIndex) +{ + uint32_t pduLen = 0; + uint32_t *msg4TxDataValue = NULLP; + + pduDesc[pduIndex].pduIndex = pduIndex; + pduDesc[pduIndex].numTlvs = 1; + + /* fill the TLV */ + /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ + pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */ + pduDesc[pduIndex].tlvs[0].tl.length = msg4Info->msg4PduLen; + LWR_MAC_ALLOC(msg4TxDataValue, msg4Info->msg4PduLen); + if(msg4TxDataValue == NULLP) + { + return RFAILED; + } + memcpy(msg4TxDataValue, msg4Info->msg4Pdu, msg4Info->msg4PduLen); + pduDesc[pduIndex].tlvs[0].value = (uint32_t)msg4TxDataValue; + + /* The total length of the PDU description and PDU data */ + pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ + pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ + pduDesc[pduIndex].pduLength = pduLen; + msgLen += pduLen; + + /* TODO: The pointer value which was stored, needs to be free-ed at PHY * + * But since we did not implement WLS, this has to be done here + */ + #ifndef INTEL_WLS + MAC_FREE(msg4TxDataValue, msg4Info->msg4PduLen); + #endif + + return ROK; +} +#endif /* FAPI */ /******************************************************************* * * @brief Sends DL TTI Request to PHY @@ -2861,30 +3111,31 @@ uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo, uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) { #ifdef FAPI - uint8_t idx; - uint8_t nPdu = 0; - uint8_t numPduEncoded = 0; - uint16_t pduIndex = 0; - uint32_t msgLen = 0; - uint32_t dlTtiReqMsgSize = 0; - fapi_dl_tti_req_t *dlTtiReq = NULLP; - RgCellCb *cellCbParams = NULLP; - MacDlSlot *currDlSlot = NULLP; - MacCellCfg macCellCfg; - memset(&macCellCfg, 0, sizeof(MacCellCfg)); - Inst inst = 0; - - if(clGlobalCp.phyState == PHY_STATE_RUNNING) - { - cellCbParams = rgCb[inst].cell; - macCellCfg = cellCbParams->macCellCfg; - - if(currTimingInfo != NULLP) - { + uint8_t idx; + uint8_t nPdu = 0; + uint8_t numPduEncoded = 0; + uint16_t pduIndex = 0; + uint32_t msgLen = 0; + uint32_t dlTtiReqMsgSize = 0; + fapi_dl_tti_req_t *dlTtiReq = NULLP; + RgCellCb *cellCbParams = NULLP; + MacDlSlot *currDlSlot = NULLP; + MacCellCfg macCellCfg; + memset(&macCellCfg, 0, sizeof(MacCellCfg)); + Inst inst = 0; + RntiType rntiType; + + if(clGlobalCp.phyState == PHY_STATE_RUNNING) + { + 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)); + sizeof(fapi_dl_tti_req_pdu_t)); if(nPdu > 0) { if(currDlSlot->dlInfo.isBroadcastPres) @@ -2893,107 +3144,128 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) { 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) - { + 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*))); + (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) - { - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\ - sib1Alloc.sib1PdcchCfg, &msgLen); - 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 */ - fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo); - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdcchCfg, &msgLen); - 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"); - } - - 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; - } - } + + 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"); @@ -3003,7 +3275,7 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) else { lwr_mac_handleInvalidEvt(currTimingInfo); - return RFAILED; + return RFAILED; } #endif return ROK; @@ -3028,65 +3300,73 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo) uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo) { #ifdef FAPI - uint8_t nPdu = 0; - uint32_t msgLen = 0; + uint8_t nPdu = 0; + uint32_t msgLen = 0; uint16_t pduIndex = 0; - uint32_t txDataReqMsgSize = 0; - fapi_tx_data_req_t *txDataReq = NULLP; - Inst inst = 0; - - /* send TX_Data request message */ - nPdu = calcTxDataReqPduCount(dlInfo); - if(nPdu > 0) - { - txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \ - (nPdu * sizeof(fapi_tx_pdu_desc_t)); + uint32_t txDataReqMsgSize = 0; + fapi_tx_data_req_t *txDataReq = NULLP; + Inst inst = 0; + + /* send TX_Data request message */ + nPdu = calcTxDataReqPduCount(dlInfo); + if(nPdu > 0) + { + txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \ + (nPdu * sizeof(fapi_tx_pdu_desc_t)); if(dlInfo->brdcstAlloc.sib1Trans) - { - txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen; - } - if(dlInfo->isRarPres) - { - txDataReqMsgSize += dlInfo->rarAlloc.rarInfo.rarPduLen; + { + txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen; + } + if(dlInfo->isRarPres) + { + txDataReqMsgSize += dlInfo->rarAlloc.rarInfo.rarPduLen; + } + if(dlInfo->msg4Alloc) + { + txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen; } LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize); - if(txDataReq == NULLP) - { - DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request"); - return RFAILED; - } - - memset(txDataReq, 0, txDataReqMsgSize); - 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 *))); - - if(dlInfo->brdcstAlloc.sib1Trans) - { - fillSib1TxDataReq(txDataReq->pduDesc, - &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex); - pduIndex++; - txDataReq->numPdus++; - } - if(dlInfo->isRarPres) - { - /* mux and form RAR pdu */ - //fillRarPdu(&dlInfo->rarAlloc.rarInfo); - fillRarTxDataReq(txDataReq->pduDesc, - &dlInfo->rarAlloc.rarInfo, &msgLen, pduIndex); - pduIndex++; - txDataReq->numPdus++; - } - - msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen); - LwrMacSendToPhy(txDataReq->header.message_type_id, txDataReqMsgSize, \ - (void *)txDataReq); - } + if(txDataReq == NULLP) + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request"); + return RFAILED; + } + + memset(txDataReq, 0, txDataReqMsgSize); + 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 *))); + + if(dlInfo->brdcstAlloc.sib1Trans) + { + fillSib1TxDataReq(txDataReq->pduDesc, + &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex); + pduIndex++; + txDataReq->numPdus++; + } + if(dlInfo->isRarPres) + { + fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc.\ + rarInfo, &msgLen, pduIndex); + pduIndex++; + txDataReq->numPdus++; + } + if(dlInfo->msg4Alloc) + { + fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\ + msg4Info, &msgLen, pduIndex); + pduIndex++; + txDataReq->numPdus++; + } + msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen); + LwrMacSendToPhy(txDataReq->header.message_type_id, txDataReqMsgSize, \ + (void *)txDataReq); + } #endif - return ROK; + return ROK; } /*********************************************************************** @@ -3107,36 +3387,36 @@ uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo) #ifdef FAPI uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot) { - uint8_t pduCount = 0; + uint8_t pduCount = 0; - if(currUlSlot != NULLP) + if(currUlSlot != NULLP) { - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) - { - pduCount++; + if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) + { + pduCount++; if(ulTtiReq) - ulTtiReq->rachPresent = PDU_PRESENT; - } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI) - { - pduCount++; + ulTtiReq->rachPresent = PDU_PRESENT; + } + if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI) + { + pduCount++; if(ulTtiReq) - ulTtiReq->nUlsch = PDU_PRESENT; - } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI) - { - pduCount++; + ulTtiReq->nUlsch = PDU_PRESENT; + } + if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI) + { + pduCount++; if(ulTtiReq) - ulTtiReq->nUlcch = PDU_PRESENT; - } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS) - { - pduCount++; - } + ulTtiReq->nUlcch = PDU_PRESENT; + } + if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS) + { + pduCount++; + } } - return pduCount; -} -#endif + return pduCount; +} +#endif /*********************************************************************** * @@ -3157,11 +3437,11 @@ void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg) { #ifdef FAPI uint8_t idx; - if(macCellCfg != NULLP) - { - idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg; - *numCs = UnrestrictedSetNcsTable[idx]; - } + if(macCellCfg != NULLP) + { + idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg; + *numCs = UnrestrictedSetNcsTable[idx]; + } #endif } @@ -3191,10 +3471,10 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId; ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulCellInfo.prachSchInfo.numPrachOcas; ulTtiReqPdu->u.prach_pdu.prachFormat = \ - currUlSlot->ulCellInfo.prachSchInfo.prachFormat; + currUlSlot->ulCellInfo.prachSchInfo.prachFormat; ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa; ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \ - currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb; + currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb; setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg); ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0; ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0; @@ -3256,7 +3536,7 @@ uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo) { ulTtiReq->sfn = currTimingInfo->sfn; ulTtiReq->slot = currTimingInfo->slot; - ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); + ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); ulTtiReq->nGroup = 0; if(ulTtiReq->nPdus > 0) { @@ -3277,17 +3557,17 @@ uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo) } else { - msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); + 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); + DU_LOG("\nLWR_MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); } - return ROK; + return ROK; } - else - { - DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request"); + else + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request"); return RFAILED; } } diff --git a/src/5gnrmac/lwr_mac_fsm.h b/src/5gnrmac/lwr_mac_fsm.h index d1f625dad..43f3c950a 100644 --- a/src/5gnrmac/lwr_mac_fsm.h +++ b/src/5gnrmac/lwr_mac_fsm.h @@ -30,6 +30,12 @@ #include "fapi.h" #endif +typedef enum{ + SI_RNTI_TYPE, + RA_RNTI_TYPE, + TC_RNTI_TYPE +}RntiType; + S16 lwr_mac_handleInvalidEvt(void *msg); S16 lwr_mac_handleParamReqEvt(void *msg); S16 lwr_mac_handleParamRspEvt(void *msg); diff --git a/src/5gnrmac/mac.h b/src/5gnrmac/mac.h index 2b104dfa1..5729e3460 100644 --- a/src/5gnrmac/mac.h +++ b/src/5gnrmac/mac.h @@ -31,7 +31,8 @@ #include "cm_hash.h" /* Common Hash List Defines */ #include "cm_lte.h" /* Common LTE Defines */ #include "cm_mblk.h" /* Common LTE Defines */ -#include "tfu.h" /* RGU Interface defines */ +#include "rgu.h" /* RGU interface includes*/ +#include "tfu.h" /* TFU Interface defines */ #include "lrg.h" #include "du_app_mac_inf.h" #include "mac_sch_interface.h" @@ -45,6 +46,7 @@ #include "cm_hash.x" /* Common Hash List Definitions */ #include "cm_lte.x" /* Common LTE Defines */ #include "cm_mblk.x" /* Common LTE Defines */ +#include "rgu.x" #include "tfu.x" /* RGU Interface includes */ #include "lrg.x" @@ -52,6 +54,10 @@ #define MAX_ZERO_CORR_CFG_IDX 16 /* max zero correlation config index */ #define SI_RNTI 0xFFFF #define P_RNTI 0xFFFE +#define MAX_MAC_CE 6 +#define MAX_UE 1 +#define MAX_CRI_SIZE 6 +#define MAX_MAC_DL_PDU 10 #define MAC_LCID_CCCH 0 #define MAC_DEDLC_MIN_LCID 1 @@ -69,6 +75,7 @@ #define MAC_LCID_LONG_TRUNC_BSR 60 #define MAC_LCID_SHORT_BSR 61 #define MAC_LCID_LONG_BSR 62 +#define MAC_LCID_CRI 62 #define MAC_LCID_PADDING 63 typedef struct macDlSlot @@ -81,12 +88,48 @@ typedef struct macUlSlot UlSchInfo ulCellInfo; }MacUlSlot; +typedef struct macCbInfo +{ + uint16_t cellId; + uint16_t crnti; + uint8_t msg3Pdu[6]; /* used as CRI value during muxing */ + uint8_t *msg4Pdu; /* storing DL-CCCH Ind Pdu */ + uint16_t msg4PduLen; /* storing DL-CCCH Ind Pdu Len */ + uint8_t *msg4TxPdu; /* muxed Pdu used for re-transmission */ + uint16_t msg4TbSize; /* size required for msg4TxPdu */ +}MacRaCbInfo; + +typedef struct macCe +{ + uint16_t macCeLcid; + uint8_t macCeValue[6]; +}MacCe; + +typedef struct macCeInfo +{ + uint16_t numCes; + MacCe macCe[MAX_MAC_CE]; +}MacCeInfo; + +typedef struct macDlInfo +{ + uint16_t lcId; + uint16_t pduLen; + uint8_t *dlPdu; +}MacDlInfo; + +typedef struct macDlData +{ + uint16_t numPdu; + MacDlInfo pduInfo[MAX_MAC_DL_PDU]; +}MacDlData; + typedef struct macCellCb { - uint16_t cellId; - RachIndInfo raCb; - MacDlSlot dlSlot[MAX_SLOT_SUPPORTED]; - MacUlSlot ulSlot[MAX_SLOT_SUPPORTED]; + uint16_t cellId; + MacRaCbInfo macRaCb[MAX_UE]; + MacDlSlot dlSlot[MAX_SLOT_SUPPORTED]; + MacUlSlot ulSlot[MAX_SLOT_SUPPORTED]; }MacCellCb; typedef struct macCb @@ -99,6 +142,10 @@ typedef struct macCb MacCb macCb; void fillMacToSchPst(Pst *pst); void fillRarPdu(RarInfo *rarInfo); +void createMacRaCb(uint16_t cellId, uint16_t crnti); +void fillMsg4DlData(MacDlData *dlData); +void fillMacCe(MacCeInfo *macCeData); +void macMuxPdu(MacDlData *dlData, MacCeInfo *macCeData, uint16_t tbSize); int unpackRxData(SlotIndInfo timingInfo, RxDataIndPdu *rxDataIndPdu); #endif diff --git a/src/5gnrmac/mac_demux.c b/src/5gnrmac/mac_demux.c index e960c8b3a..562afaefc 100644 --- a/src/5gnrmac/mac_demux.c +++ b/src/5gnrmac/mac_demux.c @@ -116,6 +116,9 @@ int unpackRxData(SlotIndInfo timingInfo, RxDataIndPdu *rxDataIndPdu) pduLen -= length; idx = idx + length; + /* store msg3 pdu in macRaCb for CRI value */ + memcpy(&macCb.macCell->macRaCb[0].msg3Pdu, pdu, length); + /* TODO: * Fill and send UL-CCCH Indication to DU APP */ diff --git a/src/5gnrmac/mac_msg_hdl.c b/src/5gnrmac/mac_msg_hdl.c index 62d8f9c5c..01f798995 100644 --- a/src/5gnrmac/mac_msg_hdl.c +++ b/src/5gnrmac/mac_msg_hdl.c @@ -65,6 +65,7 @@ extern MacCb macCb; extern void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg); +uint16_t buildMacPdu(RlcMacData *dlData); /* Function pointer for sending crc ind from MAC to SCH */ MacSchCrcIndFunc macSchCrcIndOpts[]= @@ -322,28 +323,38 @@ uint16_t MacHdlDlCcchInd(Pst *pst, DlCcchIndInfo *dlCcchIndInfo) DlRlcBOInfo dlBoInfo; DU_LOG("\nMAC : Handling DL CCCH IND"); - - /* TODO : Fill DL RLC Buffer status info */ - dlBoInfo.cellId = dlCcchIndInfo->cellId; - dlBoInfo.crnti = dlCcchIndInfo->crnti; - dlBoInfo.numLc = 0; - - if(dlCcchIndInfo->msgType == RRC_SETUP) - { - dlBoInfo.numLc++; - dlBoInfo.boInfo[dlBoInfo.numLc].lcId = 0; // SRB 0 for msg4 - dlBoInfo.boInfo[dlBoInfo.numLc].dataVolume = \ - strlen((const char*)dlCcchIndInfo->dlCcchMsg); + + /* TODO : Fill DL RLC Buffer status info */ + dlBoInfo.cellId = dlCcchIndInfo->cellId; + dlBoInfo.crnti = dlCcchIndInfo->crnti; + dlBoInfo.numLc = 0; + + if(dlCcchIndInfo->msgType == RRC_SETUP) + { + dlBoInfo.numLc++; + dlBoInfo.boInfo[dlBoInfo.numLc].lcId = 0; // SRB 0 for msg4 + dlBoInfo.boInfo[dlBoInfo.numLc].dataVolume = \ + strlen((const char*)dlCcchIndInfo->dlCcchMsg); + + /* storing Msg4 Pdu in raCb */ + if(macCb.macCell->macRaCb[0].crnti == dlCcchIndInfo->crnti) + { + macCb.macCell->macRaCb[0].msg4PduLen = strlen((const char*)dlCcchIndInfo\ + ->dlCcchMsg); + MAC_ALLOC(macCb.macCell->macRaCb[0].msg4Pdu, macCb.macCell->macRaCb[0]\ + .msg4PduLen); + if(macCb.macCell->macRaCb[0].msg4Pdu) + { + memcpy(macCb.macCell->macRaCb[0].msg4Pdu, dlCcchIndInfo->dlCcchMsg,\ + macCb.macCell->macRaCb[0].msg4PduLen); + } + } } - - /* TODO: Store dlCcchMsg in raCb */ - - sendDlRlcBoInfoMacToSch(&dlBoInfo); - - - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlCcchIndInfo->dlCcchMsg, \ - strlen((const char*)dlCcchIndInfo->dlCcchMsg)); - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlCcchIndInfo, sizeof(DlCcchIndInfo)); + sendDlRlcBoInfoMacToSch(&dlBoInfo); + + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlCcchIndInfo->dlCcchMsg, \ + strlen((const char*)dlCcchIndInfo->dlCcchMsg)); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlCcchIndInfo, sizeof(DlCcchIndInfo)); return ROK; } diff --git a/src/5gnrmac/mac_mux.c b/src/5gnrmac/mac_mux.c index 668de939d..e5dda1464 100644 --- a/src/5gnrmac/mac_mux.c +++ b/src/5gnrmac/mac_mux.c @@ -209,6 +209,185 @@ void fillRarPdu(RarInfo *rarInfo) } +/******************************************************************* + * + * @brief Database required to form MAC PDU + * + * @details + * + * Function : createMacRaCb + * + * Functionality: + * stores the required params for muxing + * + * @params[in] Pointer to cellId, + * crnti + * @return void + * + * ****************************************************************/ +void createMacRaCb(uint16_t cellId, uint16_t crnti) +{ + uint8_t idx = 0; /* supporting 1 UE */ + macCb.macCell->macRaCb[idx].cellId = cellId; + macCb.macCell->macRaCb[idx].crnti = crnti; +} + +/************************************************* + * @brief fill RLC DL Data + * + * @details + * + * Function : fillMsg4DlData + * This function is a stub which sends Dl Data + * to form MAC SDUs + * + * @param[in] MacDlData *dlData + ************************************************/ + +void fillMsg4DlData(MacDlData *dlData) +{ + uint8_t idx = 0; + dlData->numPdu = 1; + dlData->pduInfo[idx].lcId = MAC_LCID_CCCH; + dlData->pduInfo[idx].pduLen = macCb.macCell->macRaCb[0].msg4PduLen; + memcpy(dlData->pduInfo[idx].dlPdu, macCb.macCell->macRaCb[0].msg4Pdu,\ + macCb.macCell->macRaCb[0].msg4PduLen); +} + +/************************************************* + * @brief fill Mac Ce Info + * + * @details + * + * Function : fillMacCe + * This function fills Mac ce identities + * + * @param[in] RlcMacData *dlData + ************************************************/ + +void fillMacCe(MacCeInfo *macCeInfo) +{ + uint8_t idx; + macCeInfo->numCes = 1; + for(idx = 0; idx < macCeInfo->numCes; idx++) + { + macCeInfo->macCe[idx].macCeLcid = MAC_LCID_CRI; + memcpy(&macCeInfo->macCe[idx].macCeValue, \ + &macCb.macCell->macRaCb[idx].msg3Pdu, MAX_CRI_SIZE); + } +} + +/******************************************************************* + * + * @brief Forms MAC PDU + * + * @details + * + * Function : buildMacPdu + * + * Functionality: + * The MAC PDU will be MUXed and formed + * + * @params[in] MacDlData *, MacCeInfo *, tbSize + * @return void + * + * ****************************************************************/ + +void macMuxPdu(MacDlData *dlData, MacCeInfo *macCeData, uint16_t tbSize) +{ + uint8_t bytePos = 0; + uint8_t bitPos = 7; + uint8_t idx = 0; + uint8_t macPdu[tbSize]; + memset(macPdu, 0, (tbSize * sizeof(uint8_t))); + + /* subheader fields */ + uint8_t RBit = 0; /* Reserved bit */ + uint8_t FBit; /* Format Indicator */ + uint8_t lcid; /* LCID */ + uint8_t lenField = 0; /* Length field */ + + /* subheader field size (in bits) */ + uint8_t RBitSize = 1; + uint8_t FBitSize = 1; + uint8_t lcidSize = 6; + uint8_t lenFieldSize = 0; /* 8-bit or 16-bit L field */ + uint8_t criSize = 8; + + /* PACK ALL MAC CE */ + for(idx = 0; idx < macCeData->numCes; idx++) + { + lcid = macCeData->macCe[idx].macCeLcid; + switch(lcid) + { + case MAC_LCID_CRI: + { + /* Packing fields into MAC PDU R/R/LCID */ + packBytes(macPdu, &bytePos, &bitPos, RBit, RBitSize); + packBytes(macPdu, &bytePos, &bitPos, RBit, RBitSize); + packBytes(macPdu, &bytePos, &bitPos, lcid, lcidSize); + memcpy(&macPdu[bytePos], macCeData->macCe[idx].macCeValue,\ + MAX_CRI_SIZE); + break; + } + default: + DU_LOG("\n MAC: Invalid LCID %d in mac pdu",lcid); + break; + } + } + + /* PACK ALL MAC SDUs */ + for(idx = 0; idx < dlData->numPdu; idx++) + { + lcid = dlData->pduInfo[idx].lcId; + lenField = dlData->pduInfo[idx].pduLen; + switch(lcid) + { + case MAC_LCID_CCCH: + { + if(dlData->pduInfo[idx].pduLen > 255) + { + FBit = 1; + lenFieldSize = 16; + + } + else + { + FBit = 0; + lenFieldSize = 8; + } + /* Packing fields into MAC PDU R/F/LCID/L */ + packBytes(macPdu, &bytePos, &bitPos, RBit, RBitSize); + packBytes(macPdu, &bytePos, &bitPos, FBit, FBitSize); + packBytes(macPdu, &bytePos, &bitPos, lcid, lcidSize); + packBytes(macPdu, &bytePos, &bitPos, lenField, lenFieldSize); + memcpy(&macPdu[bytePos], dlData->pduInfo[idx].dlPdu, lenField); + break; + } + + default: + DU_LOG("\n MAC: Invalid LCID %d in mac pdu",lcid); + break; + } + + } + if(bytePos < tbSize && (tbSize-bytePos >= 1)) + { + /* padding remaining bytes */ + RBitSize = 2; + lcid = MAC_LCID_PADDING; + packBytes(macPdu, &bytePos, &bitPos, RBit, RBitSize); + packBytes(macPdu, &bytePos, &bitPos, lcid, lcidSize); + } + + MAC_ALLOC(macCb.macCell->macRaCb[0].msg4TxPdu, macCb.macCell->macRaCb[0].msg4TbSize); + if(macCb.macCell->macRaCb[0].msg4TxPdu != NULLP) + { + memcpy(macCb.macCell->macRaCb[0].msg4TxPdu, macPdu,\ + macCb.macCell->macRaCb[0].msg4TbSize); + } +} + /********************************************************************** End of file **********************************************************************/ diff --git a/src/5gnrmac/mac_rach.c b/src/5gnrmac/mac_rach.c index 246e02ba4..4520aab89 100644 --- a/src/5gnrmac/mac_rach.c +++ b/src/5gnrmac/mac_rach.c @@ -99,29 +99,30 @@ uint16_t fapiMacRachInd(Pst *pst, RachInd *rachInd) { uint8_t pduIdx; uint8_t preambleIdx; - RachIndInfo *rachIndInfo; + RachIndInfo rachIndInfo; DU_LOG("\nMAC : Received RACH indication"); /* Considering one pdu and one preamble */ pduIdx = 0; preambleIdx = 0; - rachIndInfo = &macCb.macCell->raCb; - - rachIndInfo->cellId = rachInd->rachPdu[pduIdx].pci; - /* TODO : Allocate unique crnti for each ue */ - rachIndInfo->crnti = 100; - rachIndInfo->timingInfo.sfn = rachInd->timingInfo.sfn; - rachIndInfo->timingInfo.slot = rachInd->timingInfo.slot; - rachIndInfo->slotIdx = rachInd->rachPdu[pduIdx].slotIdx; - rachIndInfo->symbolIdx = rachInd->rachPdu[pduIdx].symbolIdx; - rachIndInfo->freqIdx = rachInd->rachPdu[pduIdx].freqIdx; - rachIndInfo->preambleIdx = \ + rachIndInfo.cellId = rachInd->rachPdu[pduIdx].pci; + /* TODO : A.ocate unique crnti for each ue */ + rachIndInfo.crnti = 100; + rachIndInfo.timingInfo.sfn = rachInd->timingInfo.sfn; + rachIndInfo.timingInfo.slot = rachInd->timingInfo.slot; + rachIndInfo.slotIdx = rachInd->rachPdu[pduIdx].slotIdx; + rachIndInfo.symbolIdx = rachInd->rachPdu[pduIdx].symbolIdx; + rachIndInfo.freqIdx = rachInd->rachPdu[pduIdx].freqIdx; + rachIndInfo.preambleIdx = \ rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].preamIdx; - rachIndInfo->timingAdv = \ + rachIndInfo.timingAdv = \ rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].timingAdv; - return(sendRachIndMacToSch(rachIndInfo)); + /* storing the value in macRaCb */ + createMacRaCb(rachIndInfo.cellId, rachIndInfo.crnti); + + return(sendRachIndMacToSch(&rachIndInfo)); } /* spec-38.211 Table 6.3.3.1-7 */ diff --git a/src/5gnrmac/mac_slot_ind.c b/src/5gnrmac/mac_slot_ind.c index 7ddafb72d..cece12953 100644 --- a/src/5gnrmac/mac_slot_ind.c +++ b/src/5gnrmac/mac_slot_ind.c @@ -82,17 +82,46 @@ int MacProcDlAlloc(Pst *pst, DlAlloc *dlAlloc) { if(dlAlloc != NULLP) { - MacDlSlot *currDlSlot = - &macCb.macCell->dlSlot[dlAlloc->slotIndInfo.slot % MAX_SLOT_SUPPORTED]; + MacDlSlot *currDlSlot = + &macCb.macCell->dlSlot[dlAlloc->slotIndInfo.slot % MAX_SLOT_SUPPORTED]; memcpy(&currDlSlot->dlInfo, dlAlloc, sizeof(DlAlloc)); - + if(currDlSlot->dlInfo.msg4Alloc) { - /* TODO: - * Step1 : Fetch msg4 from raCb that was filled in MacHdlDlCcchInd() - * Step2 : Mux msg4 - * Step3 : Store the pdu in raCb - */ + MacDlData msg4DlData; + MacCeInfo macCeData; + memset(&msg4DlData, 0, sizeof(MacDlData)); + memset(&macCeData, 0, sizeof(MacCeInfo)); + + macCb.macCell->macRaCb[0].msg4TbSize = \ + dlAlloc->msg4Alloc->msg4PdschCfg.codeword[0].tbSize; + + if(macCb.macCell->macRaCb[0].msg4Pdu != NULLP) + { + MAC_ALLOC(msg4DlData.pduInfo[0].dlPdu, \ + macCb.macCell->macRaCb[0].msg4PduLen); + if(msg4DlData.pduInfo[0].dlPdu != NULLP) + { + fillMsg4DlData(&msg4DlData); + } + } + 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) + { + dlAlloc->msg4Alloc->msg4Info.msg4Pdu = macCb.macCell->macRaCb[0].msg4Pdu; + dlAlloc->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,\ + 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); */ } } return ROK; -- 2.16.6