#define PDSCH_PDU_TYPE 1
#define SSB_PDU_TYPE 3
#define PRACH_PDU_TYPE 0
+#define PUSCH_PDU_TYPE 1
#define PDU_PRESENT 1
#define SET_MSG_LEN(x, size) x += size
extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
/* Global variables */
-SlotIndInfo slotIndInfo;
uint8_t slotIndIdx;
-
uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo);
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
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;
+ }
}
/*******************************************************************
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 */
/*******************************************************************
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);
/* 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;
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;
if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
{
printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
- RETVALUE(RFAILED);
+ RETVALUE(RFAILED);
}
break;
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;
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;
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:
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:
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;
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));
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);
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, \
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);
{
#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);
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);
* pointer to modified value
******************************************************************/
-PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val)
+PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
{
- *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK);
+ *mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK);
*val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
}
******************************************************************/
S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
- MacDlSlot *currDlSlot,
- uint32_t *msgLen, uint8_t ssbIdxCount)
+ MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn)
{
uint32_t mibPayload = 0;
if(dlTtiReqPdu != NULL)
dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
/* Bit manipulation for SFN */
- setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload);
+ setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn);
dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
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;
* 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;
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);
+ if(dlDciPtr != NULLP)
+ {
+ uint8_t numBytes;
+ uint8_t bytePos;
+ uint8_t bitPos;
- freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2));
- }
+ 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;
- /* 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;
- }
+ /* 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;
- /* 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);
- }
+ 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
*
******************************************************************/
-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;
{
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++)
count += 2;
}
}
- if(dlInfo->isRarPres)
- {
- count += 2;
- }
+ if(dlInfo->isRarPres)
+ {
+ count += 2;
+ }
+ if(dlInfo->msg4Alloc)
+ {
+ count += 2;
+ }
+
return count;
}
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;
}
/***********************************************************************
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;
}
/***********************************************************************
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
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
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)
{
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);
- 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");
else
{
lwr_mac_handleInvalidEvt(currTimingInfo);
- return RFAILED;
+ return RFAILED;
}
#endif
return ROK;
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++;
- }
+ 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 *)));
- 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(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;
}
/***********************************************************************
#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)
+ ulTtiReq->rachPresent = PDU_PRESENT;
+ }
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)
{
pduCount++;
if(ulTtiReq)
- ulTtiReq->nUlsch = PDU_PRESENT;
+ ulTtiReq->nUlsch++;
}
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI)
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
{
pduCount++;
if(ulTtiReq)
- ulTtiReq->nUlcch = PDU_PRESENT;
- }
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS)
- {
- 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++;
+ }
}
- return pduCount;
-}
-#endif
+ return pduCount;
+}
+#endif
/***********************************************************************
*
{
#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
}
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;
sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t)));
}
}
+
+void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
+{
+ if(ulTtiReqPdu != NULLP)
+ {
+ ulTtiReqPdu->pduType = PUSCH_PDU_TYPE;
+ ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1;
+ ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulCellInfo.crnti;
+ /* TODO : Fill handle in raCb when scheduling pusch and access here */
+ ulTtiReqPdu->u.pusch_pdu.handle = 100;
+ ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
+ ulTtiReqPdu->u.pusch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb;
+ ulTtiReqPdu->u.pusch_pdu.subCarrierSpacing = \
+ macCellCfg->initialUlBwp.bwp.scs;
+ ulTtiReqPdu->u.pusch_pdu.cyclicPrefix = \
+ macCellCfg->initialUlBwp.bwp.cyclicPrefix;
+ ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308;
+ ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2;
+ ulTtiReqPdu->u.pusch_pdu.mcsIndex = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.mcs;
+ ulTtiReqPdu->u.pusch_pdu.mcsTable = 0;
+ ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1;
+ ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulCellInfo.cellId;
+ ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1;
+ ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4;
+ ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0;
+ ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulCellInfo.cellId;
+ ulTtiReqPdu->u.pusch_pdu.scid = 0;
+ ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1;
+ ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0;
+ ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \
+ currUlSlot->ulCellInfo.schPuschInfo.resAllocType;
+ ulTtiReqPdu->u.pusch_pdu.rbStart = \
+ currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.startPrb;
+ ulTtiReqPdu->u.pusch_pdu.rbSize = \
+ currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.numPrb;
+ ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0;
+ ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0;
+ ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0;
+ ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0;
+ ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \
+ currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.startSymb;
+ ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \
+ currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.numSymb;
+ ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.rv;
+ ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \
+ currUlSlot->ulCellInfo.schPuschInfo.harqProcId;
+ ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.ndi;
+ ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \
+ currUlSlot->ulCellInfo.schPuschInfo.tbInfo.tbSize;
+ /* numCb is 0 for new transmission */
+ ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0;
+
+ ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t);
+
+ SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
+ sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t)));
+ }
+}
#endif
/*******************************************************************
if(ulTtiReq != NULLP)
{
+ memset(ulTtiReq, 0, msgSize);
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)
{
ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
(sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
/* Fill Prach Pdu */
- if(ulTtiReq->rachPresent)
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH)
{
pduIdx++;
fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+
+ /* Fill PUSCH PDU */
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)
+ {
+ pduIdx++;
+ fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+ if((currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) || \
+ (currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH))
+ {
msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
DU_LOG("\nLWR_MAC: Sending UL TTI Request");
LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
- }
+ }
}
else
{
- msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
- fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
+ 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;
+ memset(&currUlSlot, 0, sizeof(MacUlSlot));
+ 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");
+ memset(&currUlSlot, 0, sizeof(MacUlSlot));
return RFAILED;
}
}
Code Review / o-du / l2.git / blobdiff