From: pborla Date: Thu, 9 Jan 2025 07:05:18 +0000 (+0530) Subject: Changing all p5 and p7 messages X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F53%2F14053%2F8;p=o-du%2Fl2.git Changing all p5 and p7 messages Change-Id: Ic3978349513469bd8769ec3bbbf839aa262632d8 Signed-off-by: pborla --- diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index e69331948..0b6e5937b 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -2005,6 +2005,668 @@ uint8_t lwr_mac_procIqSamplesReqEvt(void *msg) #endif #ifdef OAI_TESTING +#if 0 +void hexdump1(void *data, uint32_t size) +{ + DU_LOG("\nPBORLA size %u\n", size); + const unsigned char *byte = (const unsigned char *)data; + for (size_t i = 0; i < size; i++) { + printf("%02x ", byte[i]); + if ((i + 1) % 16 == 0) { + printf(" "); + } + } + printf("\n"); +} +#endif + +/******************************************************************* + * + * @brief Pack and send DL TTI message to OAI L1 + * + * @details + * + * Function : packDlTtiReq + * + * Functionality: + * -Pack and send DL TTI message to OAI L1 + * + * @params[in] fapi_dl_tti_req_t *dlTtiReq,uint8_t *out , uint32_t *len + * @return Void + * + * ****************************************************************/ + +void packDlTtiReq(fapi_dl_tti_req_t *dlTtiReq,uint8_t *out , uint32_t *len) +{ + uint8_t pduIdx = 0, freqIdx = 0, dciIndex = 0, ueGrpIdx = 0; + uint8_t numBytes = 0, ret = ROK; + uint32_t totalLen=0,lenIdx=0, lenDifference=0; + uint8_t *mBuf = out; + + //header + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->header.numMsg, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->header.opaque, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16,dlTtiReq->header.msg_id, &mBuf, &totalLen); + dlTtiReq->header.length = totalLen; // Update header length with the total length + + CMCHKPKLEN(oduPackPostUInt32,dlTtiReq->header.length, &mBuf, &totalLen); + + + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->sfn, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->slot, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->nPdus, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->nGroup, &mBuf, &totalLen); + for(pduIdx = 0; pduIdx < dlTtiReq->nPdus; pduIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pduType, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pduSize, &mBuf, &totalLen); + lenIdx=totalLen; + switch(reverseBytes16(dlTtiReq->pdus[pduIdx].pduType)) + { + case FAPI_PDCCH_PDU_TYPE: + { + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.bwpSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.bwpStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.subCarrierSpacing, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.cyclicPrefix, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.startSymbolIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.durationSymbols, &mBuf, &totalLen); + for(freqIdx = 0; freqIdx < 6; freqIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.freqDomainResource[freqIdx], &mBuf, &totalLen); + } + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.cceRegMappingType, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.regBundleSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.interleaverSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.coreSetType, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.shiftIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.precoderGranularity, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.numDlDci, &mBuf, &totalLen); + // Extract the pdcch_pdu fields for the given pduIdx + + for(dciIndex = 0; dciIndex < reverseBytes16(dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.numDlDci); dciIndex++) + { + dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].scramblingId =0; + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].rnti, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].scramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].scramblingRnti, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].cceIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].aggregationLevel, &mBuf, &totalLen); + + fapi_precoding_bmform_t *preCodingAndBeamforming= &dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].pc_and_bform; + + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(preCodingAndBeamforming->numPrgs), &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(preCodingAndBeamforming->prgSize), &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, preCodingAndBeamforming->digBfInterfaces, &mBuf, &totalLen); + + for(uint16_t prgIdx = 0; prgIdx < preCodingAndBeamforming->numPrgs; prgIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->pmi_bfi[prgIdx].pmIdx, &mBuf, &totalLen); + for(uint8_t digBfIdx = 0; digBfIdx < preCodingAndBeamforming->digBfInterfaces; digBfIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->pmi_bfi[prgIdx].beamIdx[digBfIdx].beamidx, &mBuf, &totalLen); + } + } + + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].beta_pdcch_1_0, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].powerControlOffsetSS, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].payloadSizeBits, &mBuf, &totalLen); + numBytes = reverseBytes16(dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].payloadSizeBits) / 8; + if(reverseBytes16(dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].payloadSizeBits) % 8) + numBytes += 1; + for(uint8_t payloadIdx = 0; payloadIdx < numBytes; payloadIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdcch_pdu.dlDci[dciIndex].payload[payloadIdx], &mBuf, &totalLen); + } + } + lenDifference=totalLen- lenIdx; + *((uint16_t *)(out + lenIdx-2)) = reverseBytes16(lenDifference); + break; + } + + case FAPI_PDSCH_PDU_TYPE: + { + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.pduBitMap, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.rnti, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.pdu_index, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.bwpSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.bwpStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.subCarrierSpacing, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cyclicPrefix, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.nrOfCodeWords, &mBuf, &totalLen); + + for(uint8_t cwIdx = 0; cwIdx < dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.nrOfCodeWords; cwIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cwInfo[cwIdx].targetCodeRate, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cwInfo[cwIdx].qamModOrder, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cwInfo[cwIdx].mcsIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cwInfo[cwIdx].mcsTable, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cwInfo[cwIdx].rvIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.cwInfo[cwIdx].tbSize, &mBuf, &totalLen); + } + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.dataScramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.nrOfLayers, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.transmissionScheme, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.refPoint, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.dlDmrsSymbPos, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.dmrsConfigType, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.dlDmrsScramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.scid, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.numDmrsCdmGrpsNoData, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.dmrsPorts, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.resourceAlloc, &mBuf, &totalLen); + for(uint8_t rbBitMapIdx = 0; rbBitMapIdx < 36; rbBitMapIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.rbBitmap[rbBitMapIdx], &mBuf, &totalLen); + } + + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.rbStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.rbSize, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.vrbToPrbMapping, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.startSymbIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.nrOfSymbols, &mBuf, &totalLen); + if (reverseBytes16(dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.pduBitMap) & 0b1) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.ptrsPortIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.ptrsTimeDensity, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.ptrsFreqDensity, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.ptrsReOffset, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.nEpreRatioOfPdschToPtrs, &mBuf, &totalLen); + } + + fapi_precoding_bmform_t *preCodingAndBeamforming= &dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.preCodingAndBeamforming; + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(preCodingAndBeamforming->numPrgs), &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(preCodingAndBeamforming->prgSize), &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, preCodingAndBeamforming->digBfInterfaces, &mBuf, &totalLen); + + for(uint16_t prgIdx = 0; prgIdx < (preCodingAndBeamforming->numPrgs); prgIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->pmi_bfi[prgIdx].pmIdx, &mBuf, &totalLen); + for(uint8_t digBfIdx = 0; digBfIdx < (preCodingAndBeamforming->digBfInterfaces); digBfIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->pmi_bfi[prgIdx].beamIdx[digBfIdx].beamidx, &mBuf, &totalLen); + } + } + + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.powerControlOffset, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.powerControlOffsetSS, &mBuf, &totalLen); + if (reverseBytes16(dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.pduBitMap) & 0b10) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.isLastCbPresent, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.isInlineTbCrc, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.dlTbCrc, &mBuf, &totalLen); + } + dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.maintParamV3.ldpcBaseGraph=1; + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.maintParamV3.ldpcBaseGraph, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, dlTtiReq->pdus[pduIdx].pdu.pdsch_pdu.maintParamV3.tbSizeLbrmBytes, &mBuf, &totalLen); + lenDifference=totalLen- lenIdx; + *((uint16_t *)(out + lenIdx-2)) = reverseBytes16(lenDifference); + break; + } + + case FAPI_PBCH_PDU_TYPE: + { + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.physCellId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.betaPss, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.ssbBlockIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.ssbSubCarrierOffset, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.ssbOffsetPointA, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.bchPayloadFlag, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt32, dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.bchPayload.bchPayload, &mBuf, &totalLen); + fapi_precoding_bmform_t *preCodingAndBeamforming= &dlTtiReq->pdus[pduIdx].pdu.ssb_pdu.preCodingAndBeamforming; + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->numPrgs, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->prgSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, preCodingAndBeamforming->digBfInterfaces, &mBuf, &totalLen); + + for(uint16_t prgIdx = 0; prgIdx < reverseBytes16(preCodingAndBeamforming->numPrgs); prgIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->pmi_bfi[prgIdx].pmIdx, &mBuf, &totalLen); + for(uint8_t digBfIdx = 0; digBfIdx < (preCodingAndBeamforming->digBfInterfaces); digBfIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, preCodingAndBeamforming->pmi_bfi[prgIdx].beamIdx[digBfIdx].beamidx, &mBuf, &totalLen); + } + } + lenDifference=totalLen- lenIdx; + *((uint16_t *)(out + lenIdx-2)) = reverseBytes16(lenDifference); + + break; + } + default: + { + return NULLP; + } + } + } + for(ueGrpIdx = 0; ueGrpIdx < dlTtiReq->nGroup; ueGrpIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->ue_grp_info[ueGrpIdx].nUe, &mBuf, &totalLen); + + for(uint8_t ueIdx = 0; ueIdx < dlTtiReq->ue_grp_info[ueGrpIdx].nUe; ueIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, dlTtiReq->ue_grp_info[ueGrpIdx].pduIdx[ueIdx], &mBuf, &totalLen); + } + } + if(totalLen !=sizeof(fapi_dl_tti_req_t)) + { + *((uint32_t *)(out + 4)) = reverseBytes32(totalLen); + } + + *len=totalLen; + +} + +/******************************************************************* + * + * @brief Pack and send UL TTI message to OAI L1 + * + * @details + * + * Function : packUlTtiReq + * + * Functionality: + * -Pack and send UL TTI message to OAI L1 + * + * @params[in] fapi_ul_tti_req_t *ulTti,uint8_t *out, uint32_t *len + * @return Void + * + * ****************************************************************/ + +void packUlTtiReq(fapi_ul_tti_req_t *ulTtiReq,uint8_t *out, uint32_t *len) +{ + uint8_t pduIdx = 0, ueGrpIdx = 0, ret = ROK; + uint32_t lenIdx=0, lenDifference=0, totalLen=0; + + + uint8_t *mBuf = out; + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->header.numMsg, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->header.opaque, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16,ulTtiReq->header.msg_id, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt32,ulTtiReq->header.length, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->sfn, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->slot, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->nPdus, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->rachPresent, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->nUlsch, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->nUlcch, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->nGroup, &mBuf, &totalLen); + + for(pduIdx = 0; pduIdx < ulTtiReq->nPdus; pduIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pduType, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pduSize, &mBuf, &totalLen); + lenIdx=totalLen; + switch(reverseBytes16(ulTtiReq->pdus[pduIdx].pduType)) + { + case FAPI_PRACH_PDU_TYPE: + { + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.prach_pdu.physCellId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.prach_pdu.numPrachOcas, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.prach_pdu.prachFormat, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.prach_pdu.numRa, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.prach_pdu.prachStartSymbol, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.prach_pdu.numCs, &mBuf, &totalLen); + fapi_ul_rx_bmform_pdu_t *ulBmform=&ulTtiReq->pdus[pduIdx].pdu.prach_pdu.beamforming; + CMCHKPKLEN(oduPackPostUInt8, ulBmform->trp_scheme, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulBmform->numPrgs, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulBmform->prgSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulBmform->digBfInterface, &mBuf, &totalLen); + + for(uint8_t prgIdx = 0; prgIdx < reverseBytes16(ulBmform->numPrgs); prgIdx++) + { + for(uint8_t digBfIdx = 0; digBfIdx < ulBmform->digBfInterface; digBfIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, ulBmform->rx_bfi[prgIdx].beamIdx[digBfIdx].beamidx, &mBuf, &totalLen); + } + } + lenDifference=totalLen- lenIdx; + *((uint16_t *)(out + lenIdx-2)) = reverseBytes16(lenDifference); + break; + } + case FAPI_PUSCH_PDU_TYPE: + { + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.pduBitMap, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.rnti, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.handle, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.bwpSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.bwpStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.subCarrierSpacing, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.cyclicPrefix, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.targetCodeRate, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.qamModOrder, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.mcsIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.mcsTable, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.transformPrecoding, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dataScramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.nrOfLayers, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.ulDmrsSymbPos, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dmrsConfigType, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.ulDmrsScramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschIdentity, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.scid, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.numDmrsCdmGrpsNoData, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dmrsPorts, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.resourceAlloc, &mBuf, &totalLen); + for(uint8_t rbBitMapIdx = 0; rbBitMapIdx < 36; rbBitMapIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.rbBitmap[rbBitMapIdx], &mBuf, &totalLen); + } + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.rbStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.rbSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.vrbToPrbMapping, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.frequencyHopping, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.txDirectCurrentLocation, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.uplinkFrequencyShift7p5khz, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.startSymbIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.nrOfSymbols, &mBuf, &totalLen); + + //Fill fapi_pusch_data_t + if(reverseBytes16(ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.pduBitMap &0x01)) + { + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschData.rvIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschData.harqProcessId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschData.newDataIndicator, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt32, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschData.tbSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschData.numCb, &mBuf, &totalLen); + for(int i=0;ipdus[pduIdx].pdu.pusch_pdu.puschData.numCb);i++) + { + //TODO - Above loop length must be cb length= (numCB+7)/8; + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschData.cbPresentAndPosition[i], &mBuf, &totalLen); + } + } + //Fill fapi_pusch_uci_t + if(reverseBytes16(ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.pduBitMap &0x02)) + { + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.harqAckBitLength, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.csiPart1BitLength, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.csiPart2BitLength, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.alphaScaling, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.betaOffsetHarqAck, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.betaOffsetCsi1, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschUci.betaOffsetCsi2, &mBuf, &totalLen); + } + + //Fill fapi_pusch_ptrs_t + if(reverseBytes16(ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.pduBitMap &0x04)) + { + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.numPtrsPorts, &mBuf, &totalLen); + for(uint8_t portIdx = 0; portIdx < ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.numPtrsPorts; portIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.ptrsInfo[portIdx].ptrsPortIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.ptrsInfo[portIdx].ptrsDmrsPort, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.ptrsInfo[portIdx].ptrsReOffset, &mBuf, &totalLen); + } + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.ptrsTimeDensity, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.ptrsFreqDensity, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.puschPtrs.ulPtrsPower, &mBuf, &totalLen); + } + //Fill fapi_dfts_ofdm_t + if(reverseBytes16(ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.pduBitMap &0x08)) + { + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dftsOfdm.lowPaprGroupNumber, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dftsOfdm.lowPaprSequenceNumber, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dftsOfdm.ulPtrsSampleDensity, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.dftsOfdm.ulPtrsTimeDensityTransformPrecoding, &mBuf, &totalLen); + } + + //Fill fapi_ul_rx_bmform_pdu_t + fapi_ul_rx_bmform_pdu_t *ulBmform=&ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.beamforming; + CMCHKPKLEN(oduPackPostUInt8, ulBmform->trp_scheme, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulBmform->numPrgs, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulBmform->prgSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulBmform->digBfInterface, &mBuf, &totalLen); + + for(uint8_t prgIdx = 0; prgIdx < reverseBytes16(ulBmform->numPrgs); prgIdx++) + { + for(uint8_t digBfIdx = 0; digBfIdx < ulBmform->digBfInterface; digBfIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, ulBmform->rx_bfi[prgIdx].beamIdx[digBfIdx].beamidx, &mBuf, &totalLen); + } + } + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.maintParamV3.ldpcBaseGraph, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, ulTtiReq->pdus[pduIdx].pdu.pusch_pdu.maintParamV3.tbSizeLbrmBytes, &mBuf, &totalLen); + lenDifference=totalLen- lenIdx; + *((uint16_t *)(out + lenIdx-2)) = reverseBytes16(lenDifference); + break; + } + case FAPI_PUCCH_PDU_TYPE: + { + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.rnti, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt32, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.handle, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.bwpSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.bwpStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.subCarrierSpacing, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.cyclicPrefix, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.formatType, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.multiSlotTxIndicator, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.pi2Bpsk, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.prbStart, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.prbSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.startSymbolIndex, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.nrOfSymbols, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.freqHopFlag, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.secondHopPrb, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.groupHopFlag, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.sequenceHopFlag, &mBuf, &totalLen); + + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.hoppingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.initialCyclicShift, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.dataScramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.timeDomainOccIdx, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.preDftOccIdx, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.preDftOccLen, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.addDmrsFlag, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.dmrsScramblingId, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.dmrsCyclicShift, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.srFlag, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.bitLenHarq, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.bitLenCsiPart1, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.bitLenCsiPart2, &mBuf, &totalLen); + + //Fill fapi_ul_rx_bmform_pdu_t + fapi_ul_rx_bmform_pdu_t *ulBmform=&ulTtiReq->pdus[pduIdx].pdu.pucch_pdu.beamforming; + CMCHKPKLEN(oduPackPostUInt8, ulBmform->trp_scheme, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulBmform->numPrgs, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, ulBmform->prgSize, &mBuf, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, ulBmform->digBfInterface, &mBuf, &totalLen); + + for(uint8_t prgIdx = 0; prgIdx < reverseBytes16(ulBmform->numPrgs); prgIdx++) + { + for(uint8_t digBfIdx = 0; digBfIdx < ulBmform->digBfInterface; digBfIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, ulBmform->rx_bfi[prgIdx].beamIdx[digBfIdx].beamidx, &mBuf, &totalLen); + } + } + lenDifference=totalLen- lenIdx; + *((uint16_t *)(out + lenIdx-2)) = reverseBytes16(lenDifference); + break; + } + default: + { + return RFAILED; + } + } + } + + for(ueGrpIdx = 0; ueGrpIdx < ulTtiReq->nGroup; ueGrpIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->ueGrpInfo[ueGrpIdx].nUe, &mBuf, &totalLen); + for(uint8_t ueIdx = 0; ueIdx < ulTtiReq->ueGrpInfo[ueGrpIdx].nUe; ueIdx++) + { + CMCHKPKLEN(oduPackPostUInt8, ulTtiReq->ueGrpInfo[ueGrpIdx].pduIdx[ueIdx], &mBuf, &totalLen); + } + } + + *len=totalLen; + if(totalLen != sizeof(fapi_ul_tti_req_t)) + { + *((uint32_t *)(out + 4)) = reverseBytes32(totalLen); + } + +} + +/******************************************************************* + * + * @brief Pack and send TX Data Req message to OAI L1 + * + * @details + * + * Function : packTxDataReqBuffer + * + * Functionality: + * -Pack and send TX Data Req message to OAI L1 + * + * @params[in] fapi_tx_data_req_t *txdata, uint8_t *mBuf ,uint32_t *len + * @return Void + * + * ****************************************************************/ + +void packTxDataReqBuffer(fapi_tx_data_req_t *txDataReq, uint8_t *mBuf ,uint32_t *len) +{ + uint16_t pduIdx = 0; + uint8_t ret = ROK; + uint16_t payloadSize = 0; + uint32_t totalLen = 0; + + uint8_t *out = mBuf; + + CMCHKPKLEN(oduPackPostUInt8, txDataReq->header.numMsg, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, txDataReq->header.opaque, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, txDataReq->header.msg_id, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, txDataReq->header.length, &out, &totalLen); + + CMCHKPKLEN(oduPackPostUInt16, txDataReq->sfn, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, txDataReq->slot, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, txDataReq->num_pdus, &out, &totalLen); + + for (pduIdx = 0; pduIdx num_pdus); pduIdx++) + { + + CMCHKPKLEN(oduPackPostUInt32, txDataReq->pdu_desc[pduIdx].pdu_length, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt16, txDataReq->pdu_desc[pduIdx].pdu_index, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, txDataReq->pdu_desc[pduIdx].num_tlvs, &out, &totalLen); + + for (uint32_t tlvIdx = 0; tlvIdx < reverseBytes32(txDataReq->pdu_desc[pduIdx].num_tlvs); tlvIdx++) + { + + CMCHKPKLEN(oduPackPostUInt16, txDataReq->pdu_desc[pduIdx].tlvs[tlvIdx].tag, &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt32, txDataReq->pdu_desc[pduIdx].tlvs[tlvIdx].length, &out, &totalLen); + + payloadSize = reverseBytes32(txDataReq->pdu_desc[pduIdx].tlvs[tlvIdx].length); + for (uint32_t payloadByte = 0; payloadByte < payloadSize; payloadByte++) + { + //TODO- CHeck + //CMCHKPKLEN(oduPackPostUInt32, txDataReq->pdu_desc[pduIdx].tlvs[tlvIdx].value.direct[payloadByte], &out, &totalLen); + CMCHKPKLEN(oduPackPostUInt8, txDataReq->pdu_desc[pduIdx].tlvs[tlvIdx].value.direct[payloadByte], &out, &totalLen); + } + } + } + + *len = totalLen; + if(totalLen != sizeof(fapi_tx_data_req_t)) + { + *((uint32_t *)(mBuf + 4)) = reverseBytes32(totalLen); + } +} + +/******************************************************************* + * + * @brief Pack and send Config Req message to OAI L1 + * + * @details + * + * Function : packConfigReq + * + * Functionality: + * -Pack and send Config Req message to OAI L1 + * + * @params[in] fapi_config_req_t *configReq,uint8_t *mBuf,uint32_t *len + * @return Void + * + * ****************************************************************/ + +void packConfigReq(fapi_config_req_t *configReq, uint8_t *mBuf, uint32_t *len) +{ + uint8_t *out = mBuf; + uint32_t msgLen = 0; + uint16_t totalTlv = 0; + uint16_t tlvSize=10;//uint16_t [5] + uint16_t value[5] = {0,273,0,0,0}; + + CMCHKPKLEN(oduPackPostUInt8, configReq->header.numMsg, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt8, configReq->header.opaque, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt16, configReq->header.msg_id, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt32, configReq->header.length, &out, &msgLen); + + totalTlv = configReq->number_of_tlvs; + uint8_t randmTlvCnt= 25; //This value is randomly assigned + CMCHKPKLEN(oduPackPostUInt8, randmTlvCnt, &out, &msgLen); + + for(uint16_t idx=0;idxtlvs[idx]; + + CMCHKPKLEN(oduPackPostUInt16, tlv.tl.tag, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt16, tlv.tl.length, &out, &msgLen); + switch(reverseBytes16(tlv.tl.length)) + { + case 1: + { + uint8_t val=tlv.value; + CMCHKPKLEN(oduPackPostUInt8, val, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt8, 0, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt8, 0, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt8, 0, &out, &msgLen); + break; + } + case 2: + { + uint16_t val=tlv.value; + CMCHKPKLEN(oduPackPostUInt16, val, &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt16, 0, &out, &msgLen); + break; + } + case 4: + { + uint32_t val=tlv.value; + CMCHKPKLEN(oduPackPostUInt32, val, &out, &msgLen); + break; + } + + + } + } + // adding dlGridSize and ulGridSize tlv + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(FAPI_DL_GRIDSIZE_TAG), &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(tlvSize), &out, &msgLen); + for(uint8_t arrIdx=0;arrIdx<5;arrIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(value[arrIdx]), &out, &msgLen); + } + CMCHKPKLEN(oduPackPostUInt16, 0, &out, &msgLen); + + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(FAPI_UL_GRID_SIZE_TAG), &out, &msgLen); + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(tlvSize), &out, &msgLen); + for(uint8_t arrIdx=0;arrIdx<5;arrIdx++) + { + CMCHKPKLEN(oduPackPostUInt16, reverseBytes16(value[arrIdx]), &out, &msgLen); + } + CMCHKPKLEN(oduPackPostUInt16, 0, &out, &msgLen); + + *len = msgLen; + if(msgLen != sizeof(configReq->header.length)) + { + *((uint32_t *)(mBuf + 4)) = reverseBytes32(msgLen); + } +} + #define TLV_ALIGN(_tlv_size) (32-_tlv_size) /******************************************************************* * @@ -2083,15 +2745,7 @@ uint8_t buildAndSendOAIConfigReqToL1(void *msg) totalCfgReqMsgLen += sizeof(configReq->header) + sizeof( configReq->number_of_tlvs) + totalTlv*sizeof(fapi_uint32_tlv_t); /* Fill FAPI config req */ - LWR_MAC_ALLOC(cfgReqQElem,(sizeof(fapi_api_queue_elem_t)+totalCfgReqMsgLen)); - - if(!cfgReqQElem) - { - DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req"); - return RFAILED; - } - FILL_FAPI_LIST_ELEM(cfgReqQElem, NULLP, FAPI_CONFIG_REQUEST, 1, totalCfgReqMsgLen); - configReq = (fapi_config_req_t *)(cfgReqQElem + 1); + LWR_MAC_ALLOC(configReq, sizeof(fapi_config_req_t)); memset(configReq, 0, sizeof(fapi_config_req_t)); fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, totalCfgReqMsgLen); configReq->number_of_tlvs = totalTlv; @@ -2246,6 +2900,19 @@ uint8_t buildAndSendOAIConfigReqToL1(void *msg) /* fill DMRS Type A Pos */ // fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \ sizeof(uint8_t), macCfgParams.ssbCfg.dmrsTypeAPos, &msgLen); + uint32_t bufferLen=0; + uint8_t mBuf[2500]; + packConfigReq(configReq, mBuf, &bufferLen); + //hexdump1(mBuf, bufferLen); + LWR_MAC_ALLOC(cfgReqQElem,(sizeof(fapi_api_queue_elem_t)+bufferLen)); + + if(!cfgReqQElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(cfgReqQElem, NULLP, FAPI_CONFIG_REQUEST, 1, bufferLen); + memcpy((uint8_t *)(cfgReqQElem +1), mBuf, bufferLen); /* Fill message header */ LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); @@ -2263,6 +2930,7 @@ uint8_t buildAndSendOAIConfigReqToL1(void *msg) DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy"); LwrMacSendToL1(headerElem); + LWR_MAC_FREE(configReq, sizeof(fapi_config_req_t)); return ROK; #endif } @@ -2813,15 +3481,19 @@ uint8_t fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn); #ifdef OAI_TESTING dlTtiReqPdu->pdu.ssb_pdu.bchPayload.bchPayload = reverseBytes32(mibPayload); + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.numPrgs = reverseBytes16(1); + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.prgSize = reverseBytes16(275); + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 1; + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = reverseBytes16(0); + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].beamIdx[0].beamidx = reverseBytes16(macCellCfg->ssbCfg.beamId[0]); #else dlTtiReqPdu->pdu.ssb_pdu.bchPayload.bchPayload = (mibPayload); -#endif dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.numPrgs = 0; dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.prgSize = 0; dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0; dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0; - dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming. \ - pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0]; + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0]; +#endif return ROK; } return RFAILED; @@ -2877,10 +3549,12 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) dlDciPtr[0].rnti = reverseBytes16(sib1PdcchInfo->dci[0].rnti); dlDciPtr[0].scramblingId = reverseBytes16(sib1PdcchInfo->dci[0].scramblingId); dlDciPtr[0].scramblingRnti = reverseBytes16(sib1PdcchInfo->dci[0].scramblingRnti); - dlDciPtr[0].pc_and_bform.numPrgs = reverseBytes16(sib1PdcchInfo->dci[0].beamPdcchInfo.numPrgs); - dlDciPtr[0].pc_and_bform.prgSize = reverseBytes16(sib1PdcchInfo->dci[0].beamPdcchInfo.prgSize); + dlDciPtr[0].pc_and_bform.numPrgs = reverseBytes16(0); + dlDciPtr[0].pc_and_bform.prgSize = reverseBytes16(0); + dlDciPtr[0].pc_and_bform.digBfInterfaces = 1; dlDciPtr[0].pc_and_bform.pmi_bfi[0].pmIdx = reverseBytes16(sib1PdcchInfo->dci[0].beamPdcchInfo.prg[0].pmIdx); dlDciPtr[0].pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = reverseBytes16(sib1PdcchInfo->dci[0].beamPdcchInfo.prg[0].beamIdx[0]); + dlDciPtr[0].powerControlOffsetSS = 1; #else dlDciPtr[0].rnti = sib1PdcchInfo->dci[0].rnti; dlDciPtr[0].scramblingId = sib1PdcchInfo->dci[0].scramblingId; @@ -2889,12 +3563,12 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) dlDciPtr[0].pc_and_bform.prgSize = sib1PdcchInfo->dci[0].beamPdcchInfo.prgSize; dlDciPtr[0].pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci[0].beamPdcchInfo.prg[0].pmIdx; dlDciPtr[0].pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci[0].beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr[0].pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci[0].beamPdcchInfo.digBfInterfaces; + dlDciPtr[0].powerControlOffsetSS = sib1PdcchInfo->dci[0].txPdcchPower.powerControlOffsetSS; #endif dlDciPtr[0].cceIndex = sib1PdcchInfo->dci[0].cceIndex; dlDciPtr[0].aggregationLevel = sib1PdcchInfo->dci[0].aggregLevel; - dlDciPtr[0].pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci[0].beamPdcchInfo.digBfInterfaces; dlDciPtr[0].beta_pdcch_1_0 = sib1PdcchInfo->dci[0].txPdcchPower.beta_pdcch_1_0; - dlDciPtr[0].powerControlOffsetSS = sib1PdcchInfo->dci[0].txPdcchPower.powerControlOffsetSS; /* Calculating freq domain resource allocation field value and size * coreset0Size = Size of coreset 0 @@ -3850,15 +4524,16 @@ void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, fapi_vendor_dl_tti_req_pdu dlTtiReqPdu->pdu.pdsch_pdu.vrbToPrbMapping = pdschInfo->pdschFreqAlloc.vrbPrbMapping; dlTtiReqPdu->pdu.pdsch_pdu.startSymbIndex = pdschInfo->pdschTimeAlloc.startSymb; dlTtiReqPdu->pdu.pdsch_pdu.nrOfSymbols = pdschInfo->pdschTimeAlloc.numSymb; - dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces; dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset; dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS; #ifdef OAI_TESTING - dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.numPrgs = reverseBytes16(pdschInfo->beamPdschInfo.numPrgs); - dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = reverseBytes16(pdschInfo->beamPdschInfo.prgSize); + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = 1; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.numPrgs = reverseBytes16(0); + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = reverseBytes16(0); dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = reverseBytes16(pdschInfo->beamPdschInfo.prg[0].pmIdx); dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0].beamIdx[0].beamidx = reverseBytes16(pdschInfo->beamPdschInfo.prg[0].beamIdx[0]); #else + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces; dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs; dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize; dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx; @@ -4064,7 +4739,7 @@ uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, MacCel void * wlsHdlr = NULLP; #endif uint8_t tlvPaddingLen =get_tlv_padding(macCellCfg->cellCfg.sib1Cfg.sib1PduLen); - uint16_t totalLen= macCellCfg->cellCfg.sib1Cfg.sib1PduLen+tlvPaddingLen; + uint16_t totalLen= macCellCfg->cellCfg.sib1Cfg.sib1PduLen+tlvPaddingLen+4; pduDesc[pduIndex].pdu_length = totalLen; #ifdef OAI_TESTING @@ -4664,16 +5339,12 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pr * {numPdus, nGroup} = 2 * sizeof(uint8_t), total number of pdu supproted = numPdus*sizeof(fapi_dl_tti_req_pdu_t) * and number of Group supported = ngroup * sizeof(fapi_ue_info_t) */ - msgLen=sizeof(fapi_msg_t)+ (2*sizeof(uint16_t)) + (2*sizeof(uint8_t)) + (nPdus*sizeof(fapi_dl_tti_req_pdu_t)) + (nGroup * sizeof(fapi_ue_info_t)); +// msgLen=sizeof(fapi_msg_t)+ (2*sizeof(uint16_t)) + (2*sizeof(uint8_t)) + (nPdus*sizeof(fapi_dl_tti_req_pdu_t)) + (nGroup * sizeof(fapi_ue_info_t)); - LWR_MAC_ALLOC(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + msgLen)); - if(dlTtiElem) + LWR_MAC_ALLOC(dlTtiReq, (sizeof(fapi_dl_tti_req_t))); + if(dlTtiReq) { - FILL_FAPI_LIST_ELEM(dlTtiElem, NULLP, FAPI_DL_TTI_REQUEST, 1, msgLen); - - /* Fill Dl TTI Request */ - dlTtiReq = (fapi_dl_tti_req_t *)(dlTtiElem +1); - memset(dlTtiReq, 0, msgLen); + memset(dlTtiReq, 0, sizeof(fapi_dl_tti_req_t)); fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); dlTtiReq->sfn = reverseBytes16(dlTtiReqTimingInfo.sfn); dlTtiReq->slot = reverseBytes16(dlTtiReqTimingInfo.slot); @@ -4811,8 +5482,22 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pr #ifdef ODU_SLOT_IND_DEBUG_LOG DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request"); #endif + uint32_t bufferLen=0; + uint8_t mBuf[2500]; + packDlTtiReq(dlTtiReq, mBuf, &bufferLen); + LWR_MAC_ALLOC(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + bufferLen)); + if(dlTtiElem==NULLP) + { + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(dlTtiElem, NULLP, FAPI_DL_TTI_REQUEST, 1, bufferLen); + + memcpy((uint8_t *)( dlTtiElem +1), mBuf, bufferLen); prevElemt->p_next = dlTtiElem; - } + LWR_MAC_FREE(dlTtiReq, (sizeof(fapi_dl_tti_req_t))); + //LWR_MAC_FREE(mBuf, sizeof(fapi_dl_tti_req_t)); + } if(macCb.macCell[cellIdx]->state == CELL_TO_BE_STOPPED) { /* Intel L1 expects UL_DCI.request following DL_TTI.request */ @@ -4979,6 +5664,9 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_ MsgLen = sizeof(fapi_msg_t)+ (3*sizeof(uint16_t)) + (nPdu*sizeof(fapi_tx_pdu_desc_t)); if(nPdu > 0) { + LWR_MAC_ALLOC(txDataReq, (sizeof(fapi_tx_data_req_t))); + memset(txDataReq, 0, MsgLen); +#if 0 LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + MsgLen)); if(txDataElem == NULLP) { @@ -4988,8 +5676,8 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_ FILL_FAPI_LIST_ELEM(txDataElem, NULLP, FAPI_TX_DATA_REQUEST, 1, MsgLen); txDataReq = (fapi_tx_data_req_t *)(txDataElem +1); - memset(txDataReq, 0, MsgLen); - fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, MsgLen); +#endif + fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, sizeof(fapi_tx_data_req_t)); txDataReq->sfn = reverseBytes16(currTimingInfo.sfn); txDataReq->slot = reverseBytes16(currTimingInfo.slot); @@ -5048,8 +5736,24 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_ DU_LOG("\nDEBUG --> LWR_MAC: After reversing total number pdu %u = ", txDataReq->num_pdus); /* Fill message header */ + uint32_t bufferLen=0; + uint8_t mBuf[2500]; + packTxDataReqBuffer(txDataReq, mBuf, &bufferLen); + LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + bufferLen)); + if(txDataElem == NULLP) + { + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for TX data Request"); + return RFAILED; + } + + FILL_FAPI_LIST_ELEM(txDataElem, NULLP, FAPI_TX_DATA_REQUEST, 1, bufferLen); + memcpy((uint8_t *)( txDataElem +1), mBuf, bufferLen); + + DU_LOG("\nDEBUG --> LWR_MAC: Sending TX DATA Request\n"); prevElem->p_next = txDataElem; + LWR_MAC_FREE(txDataReq, (sizeof(fapi_tx_data_req_t))); + // LWR_MAC_FREE(mBuf, (sizeof(fapi_tx_data_req_t))); } #endif #endif @@ -5450,12 +6154,9 @@ uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pre ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,gConfigInfo.gPhyDeltaUl, macCb.macCell[cellIdx]->numOfSlots); currUlSlot = &macCb.macCell[cellIdx]->ulSlot[ulTtiReqTimingInfo.slot % macCb.macCell[cellIdx]->numOfSlots]; - LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_tti_req_t))); - if(ulTtiElem) + LWR_MAC_ALLOC(ulTtiReq, (sizeof(fapi_ul_tti_req_t))); + if(ulTtiReq) { - FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, \ - sizeof(fapi_ul_tti_req_t)); - ulTtiReq = (fapi_ul_tti_req_t *)(ulTtiElem +1); memset(ulTtiReq, 0, sizeof(fapi_ul_tti_req_t)); fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, sizeof(fapi_ul_tti_req_t)); ulTtiReq->sfn = ulTtiReqTimingInfo.sfn; @@ -5505,12 +6206,26 @@ uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pre ulTtiReq->ueGrpInfo[ulTtiReq->nGroup].nUe = MAX_NUM_UE_PER_TTI; ulTtiReq->nGroup++; } + + uint32_t bufferLen=0; + uint8_t mBuf[2500]; + packUlTtiReq(ulTtiElem, mBuf, &bufferLen); + LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + bufferLen)); + if(ulTtiElem==NULLP) + { + + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, bufferLen); + memcpy((uint8_t *)( ulTtiElem +1), mBuf, bufferLen); #ifdef ODU_SLOT_IND_DEBUG_LOG DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request"); #endif prevElem->p_next = ulTtiElem; + LWR_MAC_FREE(ulTtiReq, (sizeof(fapi_ul_tti_req_t))); memset(currUlSlot, 0, sizeof(MacUlSlot)); return ROK; } @@ -5562,14 +6277,12 @@ uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pre * sizeof(fapi_ue_info_t) */ msgLen=sizeof(fapi_msg_t)+ (2*sizeof(uint16_t)) + (5*sizeof(uint8_t)) + (nPdus*sizeof(fapi_ul_tti_req_pdu_t)) + sizeof(fapi_ue_info_t); - - LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + msgLen)); - if(ulTtiElem) + + LWR_MAC_ALLOC(ulTtiReq, (sizeof(fapi_ul_tti_req_t))); + if(ulTtiReq) { - FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, msgLen); - - ulTtiReq = (fapi_ul_tti_req_t *)(ulTtiElem +1); - memset(ulTtiReq, 0, msgLen); + memset(ulTtiReq, 0, sizeof(fapi_ul_tti_req_t)); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); ulTtiReq->sfn = reverseBytes16(ulTtiReqTimingInfo.sfn); ulTtiReq->slot = reverseBytes16(ulTtiReqTimingInfo.slot); @@ -5617,12 +6330,28 @@ uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pre ulTtiReq->ueGrpInfo[ulTtiReq->nGroup].nUe = MAX_NUM_UE_PER_TTI; ulTtiReq->nGroup++; } + uint32_t bufferLen=0; + uint8_t mBuf[2500]; + packUlTtiReq(ulTtiReq, mBuf, &bufferLen); + LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + bufferLen)); + if(ulTtiElem==NULLP) + { + + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, bufferLen); + + memcpy((uint8_t *)( ulTtiElem +1), mBuf, bufferLen); #ifdef ODU_SLOT_IND_DEBUG_LOG - DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request"); + DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request"); #endif - prevElem->p_next = ulTtiElem; - memset(currUlSlot, 0, sizeof(MacUlSlot)); - return ROK; + prevElem->p_next = ulTtiElem; + + LWR_MAC_FREE(ulTtiReq, (sizeof(fapi_ul_tti_req_t))); + memset(currUlSlot, 0, sizeof(MacUlSlot)); + return ROK; + } else { diff --git a/src/5gnrmac/lwr_mac_phy.c b/src/5gnrmac/lwr_mac_phy.c index 8fdc85f02..337b032bf 100644 --- a/src/5gnrmac/lwr_mac_phy.c +++ b/src/5gnrmac/lwr_mac_phy.c @@ -279,7 +279,7 @@ uint8_t LwrMacSendToL1(void *msg) uint32_t msgLen =0; p_fapi_api_queue_elem_t currMsg = NULLP; -#ifdef CALL_FLOW_DEBUG_LOG +#ifndef CALL_FLOW_DEBUG_LOG char message[100]; currMsg = (p_fapi_api_queue_elem_t)msg; diff --git a/src/cm/common_def.h b/src/cm/common_def.h index 6846dec02..1d6ba6b95 100644 --- a/src/cm/common_def.h +++ b/src/cm/common_def.h @@ -60,7 +60,11 @@ #define MAX_NUM_CELL 2 /* Changed to 2 to support cell Id 2 even if there is only one cell in DU */ #define MAX_NUM_MU 4 #define MAX_NUM_UE 3 +#ifdef OAI_TESTING +#define MAX_NUM_UE_PER_TTI 1 +#else #define MAX_NUM_UE_PER_TTI 2 +#endif #define MAX_NUM_LC MAX_DRB_LCID + 1 /*Spec 38.331: Sec 6.4: maxLC-ID Keyword*/ #define MAX_NUM_SRB 3 /* Max. no of Srbs */ #define MAX_NUM_DRB 29 /* spec 38.331, maxDRB */ diff --git a/src/cm/mac_sch_interface.h b/src/cm/mac_sch_interface.h index 63fc020a3..46ed5b101 100644 --- a/src/cm/mac_sch_interface.h +++ b/src/cm/mac_sch_interface.h @@ -102,7 +102,11 @@ #define QPSK_MODULATION 2 #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 */ +#ifdef OAI_TESTING +#define TX_PAYLOAD_HDR_LEN 0 /* OAI L1 requires */ +#else #define TX_PAYLOAD_HDR_LEN 32 /* Intel L1 requires adding a 32 byte header to transmitted payload */ +#endif #define UL_TX_BUFFER_SIZE 5 #define MAX_NUM_CONFIG_SLOTS 160 /*Max number of slots as per the numerology*/ diff --git a/src/cm/ssi.h b/src/cm/ssi.h index 3379caeab..2a1581b93 100755 --- a/src/cm/ssi.h +++ b/src/cm/ssi.h @@ -847,6 +847,15 @@ return (ret); \ } +#ifdef OAI_TESTING +#define CMCHKPKLEN(func, val, mBuf, len) \ + { \ + uint8_t ret; \ + if ((ret = func(val, mBuf, len)) != ROK) \ + return (ret); \ + } +#endif + #define CMCHKPKLOG(func, val, mBuf, errCode, pst) \ { \ S16 ret; \ @@ -878,6 +887,15 @@ #define CMCHKPK(func, val, mBuf) \ func(val, mBuf); +#ifdef OAI_TESTING +#define CMCHKPKLEN(func, val, mBuf, len) \ + { \ + uint8_t ret; \ + if ((ret = func(val, mBuf, len)) != ROK) \ + return (ret); \ + } +#endif + #define CMCHKPKLOG(func, val, mBuf, errCode, pst) \ func(val, mBuf); diff --git a/src/intel_fapi/fapi_interface.h b/src/intel_fapi/fapi_interface.h index 3f9e227e9..3444fceea 100644 --- a/src/intel_fapi/fapi_interface.h +++ b/src/intel_fapi/fapi_interface.h @@ -214,7 +214,11 @@ extern "C" { #define FAPI_MAX_NUMBER_OF_CODEWORDS_PER_PDU 2 // Based on MAX_DL_CODEWORD // Based on (MAX_NUM_PDSCH*MAX_DL_CODEWORD + MAX_NUM_PDCCH + MAX_NUM_SRS + // 1 PBCH/SLOT) +#ifdef OAI_TESTING +#define FAPI_MAX_NUMBER_DL_PDUS_PER_TTI 15 +#else #define FAPI_MAX_NUMBER_DL_PDUS_PER_TTI 129 +#endif #define FAPI_MAX_NUMBER_OF_UES_PER_TTI 16 // Per common_ran_parameters.h // Based on Max Tb size of 1376264 bits + 24 crc over (8848-24) and O/H @@ -336,7 +340,7 @@ typedef struct { union { uint32_t *ptr; // TLV with unsigned 32 bit value - uint32_t direct[380]; // TLV with unsigned 32 bit value + uint32_t direct[1000]; // TLV with unsigned 32 bit value }value; #ifdef OAI_TESTING } __attribute__((packed)) fapi_uint32_ptr_tlv_t; @@ -756,10 +760,11 @@ typedef struct { // Updated per 5G FAPI typedef struct { fapi_msg_t header; - uint8_t number_of_tlvs; #ifndef OAI_TESTING + uint8_t number_of_tlvs; uint8_t pad[3]; #endif + uint16_t number_of_tlvs; fapi_uint32_tlv_t tlvs[FAPI_MAX_NUM_TLVS_CONFIG]; // 5G FAPI Table 3-17 #ifdef OAI_TESTING } __attribute__((packed)) fapi_config_req_t; @@ -942,6 +947,14 @@ typedef struct { } fapi_codeword_pdu_t; #endif +#ifdef OAI_TESTING +typedef struct +{ + uint8_t ldpcBaseGraph; + uint32_t tbSizeLbrmBytes; +} __attribute__((packed))fapi_pdsch_maintenance_param_v3; +#endif + // Updated per 5G FAPI typedef struct { uint16_t pduBitMap; @@ -992,6 +1005,8 @@ typedef struct { uint8_t nrOfDmrsSymbols; uint8_t dmrsAddPos; uint8_t pad2; +#else + fapi_pdsch_maintenance_param_v3 maintParamV3; #endif #ifdef OAI_TESTING } __attribute__((packed)) fapi_dl_pdsch_pdu_t; @@ -1195,6 +1210,10 @@ typedef struct { // Updated per 5G FAPI typedef struct { +#ifdef OAI_TESTING + uint8_t trp_scheme; +#endif + uint16_t numPrgs; uint16_t prgSize; uint8_t digBfInterface; @@ -1271,6 +1290,7 @@ typedef struct { fapi_dfts_ofdm_t dftsOfdm; fapi_ul_rx_bmform_pdu_t beamforming; // 5G FAPI Table 3-46 #ifdef OAI_TESTING + fapi_pdsch_maintenance_param_v3 maintParamV3; } __attribute__((packed)) fapi_ul_pusch_pdu_t; #else } fapi_ul_pusch_pdu_t; diff --git a/src/mt/ss_pack.c b/src/mt/ss_pack.c index d02f6900b..a27ed04d2 100644 --- a/src/mt/ss_pack.c +++ b/src/mt/ss_pack.c @@ -859,6 +859,98 @@ Buffer *mBuf /* message buffer */ } /* end of SUnpkF64 */ #endif /* SS_FLOAT */ +#ifdef OAI_TESTING +/* +* +* Fun: oduPackPostUInt8 +* +* Desc: This function packs an unsigned 8 bit value into a message. +* +* Ret: ROK - ok +* RFAILED - failed, general (optional) +* ROUTRES - failed, out of resources (optional) +* +* Notes: None +* +* File: ss_pack.c +* +*/ +uint8_t oduPackPostUInt8 +( + uint8_t in, uint8_t **out, uint16_t *total_length +) +{ + uint8_t *pOut = *out; + pOut[0] = in; + (*out) += 1; + (*total_length) += 1; // Increment the total length by 1 + return ROK; +} /* end of oduPackPostUInt8 */ + +/* +* +* Fun: oduPackPostUInt16 +* +* Desc: This function packs an unsigned 16 bit value into a message. +* +* Ret: ROK - ok +* RFAILED - failed, general (optional) +* ROUTRES - failed, out of resources (optional) +* +* Notes: None +* +* File: ss_pack.c +* +*/ + +uint8_t oduPackPostUInt16 +( + uint16_t in, uint8_t **out, uint16_t *total_length +) +{ + uint8_t *pOut = *out; + + pOut[1] = (in & 0xFF00) >> 8; + pOut[0] = (in & 0xFF); + (*out) += 2; + (*total_length) += 2; // Increment the total length by 2i + return ROK; +} /* end of oduPackPostUInt16 */ + +/* +* +* Fun: oduPackPostUInt32 +* +* Desc: This function packs an unsigned 32 bit value into a message. +* +* Ret: ROK - ok +* RFAILED - failed, general (optional) +* ROUTRES - failed, out of resources (optional) +* +* Notes: None +* +* File: ss_pack.c +* +*/ + +uint8_t oduPackPostUInt32( uint32_t in, uint8_t **out, uint16_t *total_length) +{ + uint8_t *pOut = *out; + + pOut[3] = (in & 0xFF000000) >> 24; + pOut[2] = (in & 0xFF0000) >> 16; + pOut[1] = (in & 0xFF00) >> 8; + pOut[0] = (in & 0xFF); + (*out) += 4; + + (*total_length) += 4; // Increment the total length by 4 + return ROK; + +} /* end of oduPackPostUInt32 */ + + +#endif + /********************************************************************** End of file **********************************************************************/