#include "mac.h"
#include "lwr_mac.h"
#ifdef INTEL_FAPI
-#include "fapi.h"
+#include "nr5g_fapi_internal.h"
#include "fapi_vendor_extension.h"
#endif
#ifdef INTEL_WLS_MEM
uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
void fapiMacConfigRsp(uint16_t cellId);
-uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t headerElem);
-uint16_t fillUlTtiReq(SlotIndInfo currTimingInfo, p_fapi_api_queue_elem_t headerElem);
+uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem);
+uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem);
+uint16_t fillUlDciReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem);
+uint8_t lwr_mac_procStopReqEvt(SlotTimingInfo slotInfo, p_fapi_api_queue_elem_t prevElem);
void lwrMacLayerInit(Region region, Pool pool)
{
* ****************************************************************/
uint8_t lwr_mac_procInvalidEvt(void *msg)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : INVALID_EVENT\n");
+#endif
DU_LOG("\nERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
return ROK;
}
uint8_t lwr_mac_procParamReqEvt(void *msg)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : PARAM_REQ\n");
+#endif
+
/* startGuardTimer(); */
fapi_param_req_t *paramReq = NULL;
fapi_msg_header_t *msgHeader;
uint8_t lwr_mac_procConfigReqEvt(void *msg)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n");
+#endif
#ifdef NR_TDD
uint8_t slotIdx = 0;
uint8_t symbolIdx =0;
uint8_t lwr_mac_procStartReqEvt(void *msg)
{
#ifdef INTEL_FAPI
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : START_REQ\n");
+#endif
fapi_msg_header_t *msgHeader;
fapi_start_req_t *startReq;
fapi_vendor_msg_t *vendorMsg;
*
********************************************************************/
-uint8_t lwr_mac_procStopReqEvt(void *msg)
+uint8_t lwr_mac_procStopReqEvt(SlotTimingInfo slotInfo, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
- SlotIndInfo *slotInfo;
- fapi_msg_header_t *msgHeader;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : STOP_REQ\n");
+#endif
+
fapi_stop_req_t *stopReq;
fapi_vendor_msg_t *vendorMsg;
- p_fapi_api_queue_elem_t headerElem;
p_fapi_api_queue_elem_t stopReqElem;
p_fapi_api_queue_elem_t vendorMsgElem;
- slotInfo = (SlotIndInfo *)msg;
-
/* Allocte And fill Vendor msg */
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgElem)
FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
vendorMsg = (fapi_vendor_msg_t *)(vendorMsgElem + 1);
fillMsgHeader(&vendorMsg->header, FAPI_VENDOR_MESSAGE, sizeof(fapi_vendor_msg_t));
- vendorMsg->stop_req_vendor.sfn = slotInfo->sfn;
- vendorMsg->stop_req_vendor.slot = slotInfo->slot;
+ vendorMsg->stop_req_vendor.sfn = slotInfo.sfn;
+ vendorMsg->stop_req_vendor.slot = slotInfo.slot;
/* Fill FAPI stop req */
LWR_MAC_ALLOC(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
memset(stopReq, 0, sizeof(fapi_stop_req_t));
fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, sizeof(fapi_stop_req_t));
- /* Fill message header */
- LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
- if(!headerElem)
- {
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in stop req");
- LWR_MAC_FREE(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
- LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
- return RFAILED;
- }
- FILL_FAPI_LIST_ELEM(headerElem, stopReqElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
- sizeof(fapi_msg_header_t));
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg = 2; /* Stop req msg and vendor specific msg */
- msgHeader->handle = 0;
-
/* Send to PHY */
DU_LOG("\nINFO --> LWR_MAC: Sending Stop Request to Phy");
- LwrMacSendToL1(headerElem);
+ prevElem->p_next = stopReqElem;
#endif
return ROK;
* Spec 38.214 Sec 5.1.2.2.2
*/
coreset0Size= sib1PdcchInfo->coresetCfg.coreSetSize;
- rbStart = 0; /* For SIB1 */
- //rbStart = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
+ rbStart = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
rbLen = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
}
/* Fetching DCI field values */
- timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->pdschTimeAlloc.
- rowIndex -1;
- VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.\
- vrbPrbMapping;
+ timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
+ VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
modNCodScheme = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
redundancyVer = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */
}
} /* fillSib1DlDciPdu */
+
+/*******************************************************************
+ *
+ * @brief fills Dl DCI PDU for Paging required for DL TTI info in MAC
+ *
+ * @details
+ *
+ * Function : fillPageDlDciPdu
+ *
+ * Functionality:
+ * -Fills the Dl DCI PDU for Paging
+ *
+ * @params[in] Pointer to fapi_dl_dci_t
+ * Pointer to dlPageAlloc
+ * @return ROK
+ *
+ ******************************************************************/
+
+void fillPageDlDciPdu(fapi_dl_dci_t *dlDciPtr, DlPageAlloc *dlPageAlloc)
+{
+ if(dlDciPtr != NULLP)
+ {
+ uint8_t numBytes=0;
+ uint8_t bytePos=0;
+ uint8_t bitPos=0;
+
+ uint16_t coreset0Size = 0;
+ uint16_t rbStart = 0;
+ uint16_t rbLen = 0;
+ uint8_t shortMsgInd = 0;
+ uint8_t shortMsg = 0;
+ uint32_t freqDomResAssign = 0;
+ uint32_t timeDomResAssign = 0;
+ uint8_t VRB2PRBMap = 0;
+ uint32_t modNCodScheme = 0;
+ uint8_t tbScaling = 0;
+ uint32_t reserved = 0;
+
+ /* Size(in bits) of each field in DCI format 1_0
+ * as mentioned in spec 38.214 */
+ uint8_t shortMsgIndSize = 2;
+ uint8_t shortMsgSize = 8;
+ uint8_t freqDomResAssignSize = 0;
+ uint8_t timeDomResAssignSize = 4;
+ uint8_t VRB2PRBMapSize = 1;
+ uint8_t modNCodSchemeSize = 5;
+ uint8_t tbScalingSize = 2;
+ uint8_t reservedSize = 6;
+
+ dlDciPtr->rnti = dlPageAlloc->pagePdcchCfg.dci.rnti;
+ dlDciPtr->scramblingId = dlPageAlloc->pagePdcchCfg.dci.scramblingId;
+ dlDciPtr->scramblingRnti = dlPageAlloc->pagePdcchCfg.dci.scramblingRnti;
+ dlDciPtr->cceIndex = dlPageAlloc->pagePdcchCfg.dci.cceIndex;
+ dlDciPtr->aggregationLevel = dlPageAlloc->pagePdcchCfg.dci.aggregLevel;
+ dlDciPtr->pc_and_bform.numPrgs = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.numPrgs;
+ dlDciPtr->pc_and_bform.prgSize = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.prgSize;
+ dlDciPtr->pc_and_bform.digBfInterfaces = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.digBfInterfaces;
+ dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.prg[0].pmIdx;
+ dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = dlPageAlloc->pagePdcchCfg.dci.beamPdcchInfo.prg[0].beamIdx[0];
+ dlDciPtr->beta_pdcch_1_0 = dlPageAlloc->pagePdcchCfg.dci.txPdcchPower.powerValue;
+ dlDciPtr->powerControlOffsetSS = dlPageAlloc->pagePdcchCfg.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
+ */
+ coreset0Size = dlPageAlloc->pagePdcchCfg.coresetCfg.coreSetSize;
+ rbStart = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
+ rbLen = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
+
+ 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 */
+
+ /*Refer:38.212 - Table 7.3.1.2.1-1: Short Message indicator >*/
+ if(dlPageAlloc->shortMsgInd != TRUE)
+ {
+ /*When Short Msg is absent*/
+ shortMsgInd = 1;
+ shortMsg = 0;
+ }
+ else
+ {
+ /*Short Msg is Present*/
+ if(dlPageAlloc->dlPagePduLen == 0 || dlPageAlloc->dlPagePdu == NULLP)
+ {
+ /*When Paging Msg is absent*/
+ shortMsgInd = 2;
+ }
+ else
+ {
+ /*Both Short and Paging is present*/
+ shortMsgInd = 3;
+ }
+ shortMsg = dlPageAlloc->shortMsg;
+ }
+
+ timeDomResAssign = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
+ VRB2PRBMap = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
+ modNCodScheme = dlPageAlloc->pagePdcchCfg.dci.pdschCfg->codeword[0].mcsIndex;
+ tbScaling = 0;
+ reserved = 0;
+
+ /* Reversing bits in each DCI field */
+ shortMsgInd = reverseBits(shortMsgInd, shortMsgIndSize);
+ shortMsg = reverseBits(shortMsg, shortMsgSize);
+ timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
+ 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 = shortMsgIndSize + shortMsgSize + freqDomResAssignSize\
+ + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\
+ + tbScaling + reservedSize;
+
+ numBytes = dlDciPtr->payloadSizeBits / 8;
+ if(dlDciPtr->payloadSizeBits % 8)
+ {
+ numBytes += 1;
+ }
+
+ if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
+ {
+ DU_LOG("\nERROR --> LWR_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,\
+ shortMsgInd, shortMsgIndSize);
+ fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+ shortMsg, shortMsgSize);
+ 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);
+ }
+} /* fillPageDlDciPdu */
+
/*******************************************************************
*
* @brief fills Dl DCI PDU required for DL TTI info in MAC
/* TODO: Fill values of coreset0Size, rbStart and rbLen */
coreset0Size= rarPdcchInfo->coresetCfg.coreSetSize;
- rbStart = 0; /* For SIB1 */
- //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
+ rbStart = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb;
rbLen = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
}
/* Fetching DCI field values */
- timeDomResAssign = rarPdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
+ timeDomResAssign = rarPdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex;
VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
tbScaling = 0; /* configured to 0 scaling */
* @return ROK
*
******************************************************************/
-uint8_t fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, \
- RntiType rntiType, uint8_t coreSetType)
+uint8_t fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacDlSlot *dlSlot, int8_t dlMsgSchInfoIdx, \
+ RntiType rntiType, uint8_t coreSetType, uint8_t ueIdx)
{
if(dlTtiReqPdu != NULLP)
{
memset(&dlTtiReqPdu->pdu.pdcch_pdu, 0, sizeof(fapi_dl_pdcch_pdu_t));
if(rntiType == SI_RNTI_TYPE)
{
- pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
- bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp;
- fillSib1DlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo);
+ pdcchInfo = &dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg;
+ bwp = &dlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp;
+ fillSib1DlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo);
+ }
+ else if(rntiType == P_RNTI_TYPE)
+ {
+ pdcchInfo = &dlSlot->pageAllocInfo->pagePdcchCfg;
+ bwp = &dlSlot->pageAllocInfo->bwp;
+ fillPageDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, dlSlot->pageAllocInfo);
}
else if(rntiType == RA_RNTI_TYPE)
{
- pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg;
- bwp = &dlInfo->rarAlloc->bwp;
- fillRarDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo);
+ pdcchInfo = &dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdcchCfg;
+ bwp = &dlSlot->dlInfo.rarAlloc[ueIdx]->bwp;
+ fillRarDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo);
}
else if(rntiType == TC_RNTI_TYPE || rntiType == C_RNTI_TYPE)
{
- pdcchInfo = &dlInfo->dlMsgAlloc->dlMsgPdcchCfg;
- bwp = &dlInfo->dlMsgAlloc->bwp;
+ pdcchInfo = &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].dlMsgPdcchCfg;
+ bwp = &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].bwp;
fillDlMsgDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo,\
- &dlInfo->dlMsgAlloc->dlMsgInfo);
+ &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[dlMsgSchInfoIdx].dlMsgInfo);
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed filling PDCCH Pdu");
- return RFAILED;
+ DU_LOG("\nERROR --> LWR_MAC: Failed filling PDCCH Pdu");
+ return RFAILED;
}
dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
dlTtiReqPdu->pdu.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb;
dlTtiReqPdu->pdu.pdcch_pdu.precoderGranularity = pdcchInfo->coresetCfg.precoderGranularity;
dlTtiReqPdu->pdu.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
dlTtiReqPdu->pdu.pdcch_pdu.coreSetType = coreSetType;
-
+
/* Calculating PDU length. Considering only one dl dci pdu for now */
dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t);
}
dlTtiReqPdu->pdu.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
for(idx = 0; idx < MAX_CODEWORDS ; idx++)
{
- dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
- dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
- dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
- dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
- dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
- dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
+ dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate;
+ dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder;
+ dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex;
+ dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable;
+ dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex;
+ dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize;
}
dlTtiReqPdu->pdu.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId;
dlTtiReqPdu->pdu.pdsch_pdu.nrOfLayers = pdschInfo->numLayers;
dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize;
dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces;
dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
- pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
+ pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx;
dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \
- beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
+ beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0];
dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;
dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
dlTtiReqPdu->pdu.pdsch_pdu.mappingType = pdschInfo->dmrs.mappingType;
* Functionality:
* -calculates the total pdu count to be allocated for DL TTI Req
*
- * @params[in] DlBrdcstAlloc *cellBroadcastInfo
+ * @params[in] MacDlSlot *dlSlot
* @return count
*
* ********************************************************************/
-uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
+uint8_t calcDlTtiReqPduCount(MacDlSlot *dlSlot)
{
uint8_t count = 0;
- uint8_t idx = 0;
+ uint8_t idx = 0, ueIdx=0;
- if(dlInfo->isBroadcastPres)
+ if(dlSlot->dlInfo.isBroadcastPres)
{
- if(dlInfo->brdcstAlloc.ssbTrans)
+ if(dlSlot->dlInfo.brdcstAlloc.ssbTrans)
{
- for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
- {
- /* SSB PDU is filled */
- count++;
- }
+ for(idx = 0; idx < dlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
+ {
+ /* SSB PDU is filled */
+ count++;
+ }
}
- if(dlInfo->brdcstAlloc.sib1Trans)
+ if(dlSlot->dlInfo.brdcstAlloc.sib1Trans)
{
- /* PDCCH and PDSCH PDU is filled */
- count += 2;
+ /* PDCCH and PDSCH PDU is filled */
+ count += 2;
}
}
- if(dlInfo->rarAlloc != NULLP)
+
+ if(dlSlot->pageAllocInfo)
{
/* PDCCH and PDSCH PDU is filled */
count += 2;
}
- if(dlInfo->dlMsgAlloc != NULLP)
+
+ for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
{
- /* PDCCH and PDSCH PDU is filled */
- count += 2;
+ if(dlSlot->dlInfo.rarAlloc[ueIdx] != NULLP)
+ {
+ /* PDCCH and PDSCH PDU is filled */
+ if(dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH)
+ count += 2;
+ else
+ count += 1;
+ }
+
+ if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
+ {
+ for(idx=0; idx<dlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
+ {
+ /* PDCCH and PDSCH PDU is filled */
+ if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH)
+ count += 2;
+ else if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres != NONE)
+ count += 1;
+ }
+ }
}
return count;
}
* @return count
*
* ********************************************************************/
-uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo)
+uint8_t calcTxDataReqPduCount(MacDlSlot *dlSlot)
{
- uint8_t count = 0;
+ uint8_t idx = 0, count = 0, ueIdx=0;
- if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
+ if(dlSlot->dlInfo.isBroadcastPres && dlSlot->dlInfo.brdcstAlloc.sib1Trans)
{
count++;
}
- if(dlInfo->rarAlloc != NULLP)
+ if(dlSlot->pageAllocInfo)
{
count++;
}
- if(dlInfo->dlMsgAlloc != NULLP)
+
+ for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
{
- count++;
+ if((dlSlot->dlInfo.rarAlloc[ueIdx] != NULLP) && \
+ ((dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || (dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDSCH_PDU)))
+ count++;
+
+ if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
+ {
+ for(idx=0; idx<dlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
+ {
+ if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH || \
+ dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == PDSCH_PDU)
+ count++;
+ }
+ }
}
return count;
}
+
/***********************************************************************
*
* @brief fills the SIB1 TX-DATA request message
* @return ROK
*
* ********************************************************************/
-uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg,
- uint16_t pduIndex)
+uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, MacCellCfg *macCellCfg,
+ PdschCfg pdschCfg)
{
- uint32_t pduLen = 0;
- uint8_t *sib1TxdataValue = NULLP;
+ uint32_t payloadSize = 0;
+ uint8_t *sib1Payload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
pduDesc[pduIndex].pdu_index = pduIndex;
pduDesc[pduIndex].num_tlvs = 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 = FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
- pduDesc[pduIndex].tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen;
- LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
- if(sib1TxdataValue == NULLP)
+ payloadSize = pdschCfg.codeword[0].tbSize;
+ pduDesc[pduIndex].tlvs[0].tl.tag = ((payloadSize & 0xff0000) >> 8) | FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
+ pduDesc[pduIndex].tlvs[0].tl.length = (payloadSize & 0x0000ffff);
+ LWR_MAC_ALLOC(sib1Payload, payloadSize);
+ if(sib1Payload == NULLP)
+ {
+ return RFAILED;
+ }
+ payloadElem = (fapi_api_queue_elem_t *)sib1Payload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, \
+ macCellCfg->sib1Cfg.sib1PduLen);
+ memcpy(sib1Payload + TX_PAYLOAD_HDR_LEN, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen);
+
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, sib1Payload));
+#else
+ pduDesc[pduIndex].tlvs[0].value = sib1Payload;
+#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
+
+#ifdef INTEL_WLS_MEM
+ addWlsBlockToFree(sib1Payload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
+#else
+ LWR_MAC_FREE(sib1Payload, payloadSize);
+#endif
+
+ return ROK;
+}
+
+/***********************************************************************
+ *
+ * @brief fills the PAGE TX-DATA request message
+ *
+ * @details
+ *
+ * Function : fillPageTxDataReq
+ *
+ * Functionality:
+ * - fills the Page TX-DATA request message
+ *
+ * @params[in] fapi_tx_pdu_desc_t *pduDesc
+ * @params[in] macCellCfg consist of SIB1 pdu
+ * @params[in] uint32_t *msgLen
+ * @params[in] uint16_t pduIndex
+ * @return ROK
+ *
+ * ********************************************************************/
+uint8_t fillPageTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, DlPageAlloc *pageAllocInfo,
+ PdschCfg pdschCfg)
+{
+ uint32_t payloadSize = 0;
+ uint8_t *pagePayload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
+
+ pduDesc[pduIndex].pdu_index = pduIndex;
+ pduDesc[pduIndex].num_tlvs = 1;
+
+ /* fill the TLV */
+ payloadSize = pdschCfg.codeword[0].tbSize;
+ pduDesc[pduIndex].tlvs[0].tl.tag = ((payloadSize & 0xff0000) >> 8) | FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
+ pduDesc[pduIndex].tlvs[0].tl.length = (payloadSize & 0x0000ffff);
+ LWR_MAC_ALLOC(pagePayload, payloadSize);
+ if(pagePayload == NULLP)
{
return RFAILED;
}
- memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu,
- macCellCfg->sib1Cfg.sib1PduLen);
- pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue;
+ payloadElem = (fapi_api_queue_elem_t *)pagePayload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, \
+ pageAllocInfo->dlPagePduLen);
+ memcpy(pagePayload + TX_PAYLOAD_HDR_LEN, pageAllocInfo->dlPagePdu, pageAllocInfo->dlPagePduLen);
- /* 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_uint8_ptr_tlv_t); /* only 1 TLV is present */
- pduDesc[pduIndex].pdu_length = pduLen;
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, pagePayload));
+#else
+ pduDesc[pduIndex].tlvs[0].value = pagePayload;
+#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
#ifdef INTEL_WLS_MEM
- addWlsBlockToFree(sib1TxdataValue, macCellCfg->sib1Cfg.sib1PduLen, (lwrMacCb.phySlotIndCntr-1));
+ addWlsBlockToFree(pagePayload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
#else
- LWR_MAC_FREE(sib1TxdataValue, macCellCfg->sib1Cfg.sib1PduLen);
+ LWR_MAC_FREE(pagePayload, payloadSize);
#endif
return ROK;
* @return ROK
*
* ********************************************************************/
-uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
- uint16_t pduIndex)
+uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, RarInfo *rarInfo, PdschCfg pdschCfg)
{
- uint32_t pduLen = 0;
- uint8_t *rarTxdataValue = NULLP;
+ uint16_t payloadSize;
+ uint8_t *rarPayload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
pduDesc[pduIndex].pdu_index = pduIndex;
pduDesc[pduIndex].num_tlvs = 1;
/* fill the TLV */
- /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
+ payloadSize = pdschCfg.codeword[0].tbSize;
pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
- pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen;
- LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen);
- if(rarTxdataValue == NULLP)
+ pduDesc[pduIndex].tlvs[0].tl.length = payloadSize;
+ LWR_MAC_ALLOC(rarPayload, payloadSize);
+ if(rarPayload == NULLP)
{
return RFAILED;
}
- memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen);
- pduDesc[pduIndex].tlvs[0].value = 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_uint8_ptr_tlv_t); /* only 1 TLV is present */
- pduDesc[pduIndex].pdu_length = pduLen;
+ payloadElem = (fapi_api_queue_elem_t *)rarPayload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, rarInfo->rarPduLen);
+ memcpy(rarPayload + TX_PAYLOAD_HDR_LEN, rarInfo->rarPdu, rarInfo->rarPduLen);
- /* 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
- */
-#ifdef INTEL_WLS_MEM
- addWlsBlockToFree(rarTxdataValue, rarInfo->rarPduLen, (lwrMacCb.phySlotIndCntr-1));
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, rarPayload));
#else
- LWR_MAC_FREE(rarTxdataValue, rarInfo->rarPduLen);
+ pduDesc[pduIndex].tlvs[0].value = rarPayload;
#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
+#ifdef INTEL_WLS_MEM
+ addWlsBlockToFree(rarPayload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
+#else
+ LWR_MAC_FREE(rarPayload, payloadSize);
+#endif
return ROK;
}
* @return ROK
*
* ********************************************************************/
-uint8_t fillDlMsgTxDataReq(fapi_tx_pdu_desc_t *pduDesc, DlMsgInfo *dlMsgInfo,
- uint16_t pduIndex)
+uint8_t fillDlMsgTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, DlMsgInfo *dlMsgInfo, PdschCfg pdschCfg)
{
- uint32_t pduLen = 0;
- uint8_t *dedMsgTxDataValue = NULLP;
+ uint16_t payloadSize;
+ uint8_t *dlMsgPayload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
pduDesc[pduIndex].pdu_index = pduIndex;
pduDesc[pduIndex].num_tlvs = 1;
/* fill the TLV */
- /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */
+ payloadSize = pdschCfg.codeword[0].tbSize;
pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
- pduDesc[pduIndex].tlvs[0].tl.length = dlMsgInfo->dlMsgPduLen;
- LWR_MAC_ALLOC(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen);
- if(dedMsgTxDataValue == NULLP)
+ pduDesc[pduIndex].tlvs[0].tl.length = payloadSize;
+ LWR_MAC_ALLOC(dlMsgPayload, payloadSize);
+ if(dlMsgPayload == NULLP)
{
return RFAILED;
}
- memcpy(dedMsgTxDataValue, dlMsgInfo->dlMsgPdu, dlMsgInfo->dlMsgPduLen);
- pduDesc[pduIndex].tlvs[0].value = dedMsgTxDataValue;
-
- /* 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_uint8_ptr_tlv_t); /* only 1 TLV is present */
- pduDesc[pduIndex].pdu_length = pduLen;
+ payloadElem = (fapi_api_queue_elem_t *)dlMsgPayload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, dlMsgInfo->dlMsgPduLen);
+ memcpy(dlMsgPayload + TX_PAYLOAD_HDR_LEN, dlMsgInfo->dlMsgPdu, dlMsgInfo->dlMsgPduLen);
- /* 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
- */
-#ifdef INTEL_WLS_MEM
- addWlsBlockToFree(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen, (lwrMacCb.phySlotIndCntr-1));
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, dlMsgPayload));
#else
- LWR_MAC_FREE(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen);
+ pduDesc[pduIndex].tlvs[0].value = dlMsgPayload;
#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
+#ifdef INTEL_WLS_MEM
+ addWlsBlockToFree(dlMsgPayload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
+#else
+ LWR_MAC_FREE(dlMsgPayload, payloadSize);
+#endif
return ROK;
}
-
#endif /* FAPI */
+
/*******************************************************************
*
* @brief Sends DL TTI Request to PHY
* RFAILED - failure
*
* ****************************************************************/
-uint16_t fillDlTtiReq(SlotIndInfo currTimingInfo)
+uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : DL_TTI_REQUEST\n");
+#endif
+
#ifdef INTEL_FAPI
uint8_t idx =0;
uint8_t nPdu = 0;
uint8_t numPduEncoded = 0;
+ uint8_t ueIdx;
uint16_t cellIdx =0;
uint16_t pduIndex = 0;
- SlotIndInfo dlTtiReqTimingInfo;
+ SlotTimingInfo dlTtiReqTimingInfo;
MacDlSlot *currDlSlot = NULLP;
MacCellCfg macCellCfg;
RntiType rntiType;
fapi_msg_header_t *msgHeader = NULLP;
p_fapi_api_queue_elem_t dlTtiElem;
p_fapi_api_queue_elem_t headerElem;
+ p_fapi_api_queue_elem_t prevElem;
if(lwrMacCb.phyState == PHY_STATE_RUNNING)
{
if(dlTtiElem)
{
FILL_FAPI_LIST_ELEM(dlTtiElem, NULLP, FAPI_DL_TTI_REQUEST, 1, \
- sizeof(fapi_dl_tti_req_t));
+ sizeof(fapi_dl_tti_req_t));
- /* Fill message header */
- LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
- if(!headerElem)
- {
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req");
- LWR_MAC_FREE(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t)));
- return RFAILED;
- }
- FILL_FAPI_LIST_ELEM(headerElem, dlTtiElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
- sizeof(fapi_msg_header_t));
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg = 1;
- msgHeader->handle = 0;
+ /* Fill message header */
+ LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
+ if(!headerElem)
+ {
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req");
+ LWR_MAC_FREE(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t)));
+ return RFAILED;
+ }
+ FILL_FAPI_LIST_ELEM(headerElem, dlTtiElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
+ sizeof(fapi_msg_header_t));
+ msgHeader = (fapi_msg_header_t *)(headerElem + 1);
+ msgHeader->num_msg = 1;
+ msgHeader->handle = 0;
/* Fill Dl TTI Request */
- dlTtiReq = (fapi_dl_tti_req_t *)(dlTtiElem +1);
- memset(dlTtiReq, 0, sizeof(fapi_dl_tti_req_t));
- fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, sizeof(fapi_dl_tti_req_t));
-
- dlTtiReq->sfn = dlTtiReqTimingInfo.sfn;
- dlTtiReq->slot = dlTtiReqTimingInfo.slot;
- dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */
- nPdu = dlTtiReq->nPdus;
- dlTtiReq->nGroup = 0;
- if(dlTtiReq->nPdus > 0)
- {
- 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, idx, dlTtiReq->sfn);
- numPduEncoded++;
- }
- }
- DU_LOG("\033[1;31m");
- DU_LOG("\nDEBUG --> LWR_MAC: MIB sent..");
- DU_LOG("\033[0m");
- }
- if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
- {
- /* Filling SIB1 param */
- if(numPduEncoded != nPdu)
- {
- rntiType = SI_RNTI_TYPE;
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\
- rntiType, CORESET_TYPE0);
- numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
- &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg,
- currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp,
- pduIndex);
- pduIndex++;
- numPduEncoded++;
- }
- DU_LOG("\033[1;34m");
+ dlTtiReq = (fapi_dl_tti_req_t *)(dlTtiElem +1);
+ memset(dlTtiReq, 0, sizeof(fapi_dl_tti_req_t));
+ fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, sizeof(fapi_dl_tti_req_t));
+
+ dlTtiReq->sfn = dlTtiReqTimingInfo.sfn;
+ dlTtiReq->slot = dlTtiReqTimingInfo.slot;
+ dlTtiReq->nPdus = calcDlTtiReqPduCount(currDlSlot); /* get total Pdus */
+ nPdu = dlTtiReq->nPdus;
+ dlTtiReq->nGroup = 0;
+ if(dlTtiReq->nPdus > 0)
+ {
+ 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, idx, dlTtiReq->sfn);
+ numPduEncoded++;
+ }
+ }
+ DU_LOG("\033[1;31m");
+ DU_LOG("\nDEBUG --> LWR_MAC: MIB sent..");
+ DU_LOG("\033[0m");
+ }
+
+ if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
+ {
+ /* Filling SIB1 param */
+ if(numPduEncoded != nPdu)
+ {
+ rntiType = SI_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], currDlSlot, -1, \
+ rntiType, CORESET_TYPE0, MAX_NUM_UE);
+ numPduEncoded++;
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+ &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg,
+ currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp,
+ pduIndex);
+ dlTtiReq->ue_grp_info[dlTtiReq->nGroup].pduIdx[pduIndex] = pduIndex;
+ pduIndex++;
+ numPduEncoded++;
+ }
+ DU_LOG("\033[1;34m");
DU_LOG("\nDEBUG --> LWR_MAC: SIB1 sent...");
- DU_LOG("\033[0m");
- }
- }
- if(currDlSlot->dlInfo.rarAlloc != NULLP)
- {
- /* Filling RAR param */
- rntiType = RA_RNTI_TYPE;
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo, rntiType, CORESET_TYPE0);
- numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
- &currDlSlot->dlInfo.rarAlloc->rarPdschCfg,
- currDlSlot->dlInfo.rarAlloc->bwp,
- pduIndex);
- numPduEncoded++;
- pduIndex++;
-
- DU_LOG("\033[1;32m");
- DU_LOG("\nDEBUG --> LWR_MAC: RAR sent...");
- DU_LOG("\033[0m");
- }
- if(currDlSlot->dlInfo.dlMsgAlloc != NULLP)
- {
- if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu != NULLP)
- {
- /* Filling Msg4 param */
- DU_LOG("\033[1;32m");
- if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.isMsg4Pdu)
- {
- rntiType = TC_RNTI_TYPE;
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo, rntiType, CORESET_TYPE0);
- DU_LOG("\nDEBUG --> LWR_MAC: MSG4 sent...");
- }
- else
- {
- /* Filling other DL msg params */
- rntiType = C_RNTI_TYPE;
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo, rntiType, CORESET_TYPE1);
- DU_LOG("\nDEBUG --> LWR_MAC: DL MSG sent...");
+ DU_LOG("\033[0m");
+ }
+ }
+
+ if(currDlSlot->pageAllocInfo != NULLP)
+ {
+ /* Filling DL Paging Alloc param */
+ if(numPduEncoded != nPdu)
+ {
+ rntiType = P_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], currDlSlot, -1, \
+ rntiType, CORESET_TYPE0, MAX_NUM_UE);
+ numPduEncoded++;
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+ &currDlSlot->pageAllocInfo->pagePdschCfg,
+ currDlSlot->pageAllocInfo->bwp,
+ pduIndex);
+ dlTtiReq->ue_grp_info[dlTtiReq->nGroup].pduIdx[pduIndex] = pduIndex;
+ pduIndex++;
+ numPduEncoded++;
+ }
+ DU_LOG("\033[1;34m");
+ DU_LOG("\nDEBUG --> LWR_MAC: PAGE sent...");
+ DU_LOG("\033[0m");
+ }
+
+ for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
+ {
+ if(currDlSlot->dlInfo.rarAlloc[ueIdx] != NULLP)
+ {
+ /* Filling RAR param */
+ rntiType = RA_RNTI_TYPE;
+ if((currDlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || \
+ (currDlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDCCH_PDU))
+ {
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
+ currDlSlot, -1, rntiType, CORESET_TYPE0, ueIdx);
+ numPduEncoded++;
}
- DU_LOG("\033[0m");
-
- numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
- &currDlSlot->dlInfo.dlMsgAlloc->dlMsgPdschCfg,
- currDlSlot->dlInfo.dlMsgAlloc->bwp,
- pduIndex);
- numPduEncoded++;
- pduIndex++;
- }
- else
- {
- MAC_FREE(currDlSlot->dlInfo.dlMsgAlloc, sizeof(DlMsgAlloc));
- currDlSlot->dlInfo.dlMsgAlloc = NULLP;
- }
- }
+ if((currDlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || \
+ (currDlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDSCH_PDU))
+ {
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+ &currDlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg,
+ currDlSlot->dlInfo.rarAlloc[ueIdx]->bwp,
+ pduIndex);
+ numPduEncoded++;
+ pduIndex++;
+
+ DU_LOG("\033[1;32m");
+ DU_LOG("\nDEBUG --> LWR_MAC: RAR sent...");
+ DU_LOG("\033[0m");
+ }
+ }
+
+ if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
+ {
+ for(idx=0; idx<currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; idx++)
+ {
+ /* Filling Msg4 param */
+ if((currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH) || \
+ (currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == PDCCH_PDU))
+ {
+ if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].dlMsgInfo.isMsg4Pdu)
+ {
+ rntiType = TC_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
+ currDlSlot, idx, rntiType, CORESET_TYPE0, ueIdx);
+ }
+ else
+ {
+ /* Filling other DL msg params */
+ rntiType = C_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
+ currDlSlot, idx, rntiType, CORESET_TYPE1, ueIdx);
+ }
+ numPduEncoded++;
+ }
+
+ if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].dlMsgInfo.dlMsgPdu != NULLP)
+ {
+ if((currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == BOTH) || \
+ (currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].pduPres == PDSCH_PDU))
+ {
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], \
+ &currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].dlMsgPdschCfg,\
+ currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].bwp, pduIndex);
+ numPduEncoded++;
+ pduIndex++;
+
+ DU_LOG("\033[1;32m");
+ if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[idx].dlMsgInfo.isMsg4Pdu)
+ {
+ DU_LOG("\nDEBUG --> LWR_MAC: MSG4 sent...");
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> LWR_MAC: DL MSG sent...");
+ }
+ DU_LOG("\033[0m");
+ }
+
+ }
+ /* else
+ {
+ MAC_FREE(currDlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc));
+ currDlSlot->dlInfo.dlMsgAlloc[ueIdx] = NULLP;
+ }
+ */
+ }
+ }
+ }
+
+ dlTtiReq->ue_grp_info[dlTtiReq->nGroup].nUe = MAX_NUM_UE_PER_TTI;
+ dlTtiReq->nGroup++;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
- /* Intel L1 expects UL_TTI.request following DL_TTI.request */
- fillUlTtiReq(currTimingInfo, headerElem);
- /* send Tx-DATA req message */
- sendTxDataReq(dlTtiReqTimingInfo, &currDlSlot->dlInfo, headerElem);
- LwrMacSendToL1(headerElem);
- }
- else
- {
+
+ /* Intel L1 expects UL_TTI.request following DL_TTI.request */
+ fillUlTtiReq(currTimingInfo, dlTtiElem);
+ msgHeader->num_msg++;
+
+ /* Intel L1 expects UL_DCI.request following DL_TTI.request */
+ fillUlDciReq(dlTtiReqTimingInfo, dlTtiElem->p_next);
+ msgHeader->num_msg++;
+
+ /* send Tx-DATA req message */
+ sendTxDataReq(dlTtiReqTimingInfo, currDlSlot, dlTtiElem->p_next->p_next);
+ if(dlTtiElem->p_next->p_next->p_next)
+ {
+ msgHeader->num_msg++;
+ prevElem = dlTtiElem->p_next->p_next->p_next;
+ }
+ else
+ prevElem = dlTtiElem->p_next->p_next;
+ }
+ else
+ {
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
- /* Intel L1 expects UL_TTI.request following DL_TTI.request */
- fillUlTtiReq(currTimingInfo, headerElem);
- LwrMacSendToL1(headerElem);
- }
- memset(currDlSlot, 0, sizeof(MacDlSlot));
- return ROK;
+ /* Intel L1 expects UL_TTI.request following DL_TTI.request */
+ fillUlTtiReq(currTimingInfo, dlTtiElem);
+ msgHeader->num_msg++;
+
+ /* Intel L1 expects UL_DCI.request following DL_TTI.request */
+ fillUlDciReq(dlTtiReqTimingInfo, dlTtiElem->p_next);
+ msgHeader->num_msg++;
+
+ prevElem = dlTtiElem->p_next->p_next;
+ }
+
+ if(macCb.macCell[cellIdx]->state == CELL_TO_BE_STOPPED)
+ {
+ /* Intel L1 expects UL_DCI.request following DL_TTI.request */
+ lwr_mac_procStopReqEvt(currTimingInfo, prevElem);
+ msgHeader->num_msg++;
+ macCb.macCell[cellIdx]->state = CELL_STOP_IN_PROGRESS;
+ }
+ LwrMacSendToL1(headerElem);
+ memset(currDlSlot, 0, sizeof(MacDlSlot));
+ return ROK;
}
else
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request");
- memset(currDlSlot, 0, sizeof(MacDlSlot));
- return RFAILED;
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request");
+ memset(currDlSlot, 0, sizeof(MacDlSlot));
+ return RFAILED;
}
}
else
* RFAILED - failure
*
* ****************************************************************/
-uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t headerElem)
+uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
- uint8_t nPdu = 0;
- uint16_t cellIdx;
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : TX_DATA_REQ\n");
+#endif
+
+ uint8_t nPdu = 0;
+ uint8_t ueIdx=0;
+ uint8_t schInfoIdx = 0;
+ uint16_t cellIdx=0;
uint16_t pduIndex = 0;
fapi_tx_data_req_t *txDataReq =NULLP;
- fapi_msg_header_t *msgHeader =NULLP;
p_fapi_api_queue_elem_t txDataElem = 0;
GET_CELL_IDX(currTimingInfo.cellId, cellIdx);
/* send TX_Data request message */
- nPdu = calcTxDataReqPduCount(dlInfo);
+ nPdu = calcTxDataReqPduCount(dlSlot);
if(nPdu > 0)
{
LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
if(txDataElem == NULLP)
{
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for TX data Request");
- return RFAILED;
+ 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, \
- sizeof(fapi_tx_data_req_t));
+ sizeof(fapi_tx_data_req_t));
txDataReq = (fapi_tx_data_req_t *)(txDataElem +1);
memset(txDataReq, 0, sizeof(fapi_tx_data_req_t));
fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, sizeof(fapi_tx_data_req_t));
txDataReq->sfn = currTimingInfo.sfn;
txDataReq->slot = currTimingInfo.slot;
- if(dlInfo->brdcstAlloc.sib1Trans)
- {
- fillSib1TxDataReq(txDataReq->pdu_desc,
- &macCb.macCell[cellIdx]->macCellCfg, pduIndex);
- pduIndex++;
- txDataReq->num_pdus++;
- }
- if(dlInfo->rarAlloc != NULLP)
+ if(dlSlot->dlInfo.brdcstAlloc.sib1Trans)
{
- fillRarTxDataReq(txDataReq->pdu_desc, &dlInfo->rarAlloc->rarInfo, pduIndex);
- pduIndex++;
- txDataReq->num_pdus++;
-
- MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc));
- dlInfo->rarAlloc = NULLP;
+ fillSib1TxDataReq(txDataReq->pdu_desc, pduIndex, &macCb.macCell[cellIdx]->macCellCfg, \
+ dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg);
+ pduIndex++;
+ txDataReq->num_pdus++;
}
- if(dlInfo->dlMsgAlloc != NULLP)
+ if(dlSlot->pageAllocInfo != NULLP)
{
- fillDlMsgTxDataReq(txDataReq->pdu_desc, \
- &dlInfo->dlMsgAlloc->dlMsgInfo, pduIndex);
+ fillPageTxDataReq(txDataReq->pdu_desc, pduIndex, dlSlot->pageAllocInfo, \
+ dlSlot->pageAllocInfo->pagePdschCfg);
pduIndex++;
txDataReq->num_pdus++;
+ MAC_FREE(dlSlot->pageAllocInfo->dlPagePdu, sizeof(dlSlot->pageAllocInfo->dlPagePduLen));
+ MAC_FREE(dlSlot->pageAllocInfo,sizeof(DlPageAlloc));
+ }
+
+ for(ueIdx=0; ueIdx<MAX_NUM_UE; ueIdx++)
+ {
+ if(dlSlot->dlInfo.rarAlloc[ueIdx] != NULLP)
+ {
+ if((dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == BOTH) || (dlSlot->dlInfo.rarAlloc[ueIdx]->pduPres == PDSCH_PDU))
+ {
+ fillRarTxDataReq(txDataReq->pdu_desc, pduIndex, &dlSlot->dlInfo.rarAlloc[ueIdx]->rarInfo,\
+ dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg);
+ pduIndex++;
+ txDataReq->num_pdus++;
+ }
+ MAC_FREE(dlSlot->dlInfo.rarAlloc[ueIdx],sizeof(RarAlloc));
+ }
- MAC_FREE(dlInfo->dlMsgAlloc->dlMsgInfo.dlMsgPdu,\
- dlInfo->dlMsgAlloc->dlMsgInfo.dlMsgPduLen);
- dlInfo->dlMsgAlloc->dlMsgInfo.dlMsgPdu = NULLP;
- MAC_FREE(dlInfo->dlMsgAlloc, sizeof(DlMsgAlloc));
- dlInfo->dlMsgAlloc = NULLP;
+ if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP)
+ {
+ for(schInfoIdx=0; schInfoIdx < dlSlot->dlInfo.dlMsgAlloc[ueIdx]->numSchedInfo; schInfoIdx++)
+ {
+ if((dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == BOTH) || \
+ (dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].pduPres == PDSCH_PDU))
+ {
+ fillDlMsgTxDataReq(txDataReq->pdu_desc, pduIndex, \
+ &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo, \
+ dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgPdschCfg);
+ pduIndex++;
+ txDataReq->num_pdus++;
+ }
+ MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu, \
+ dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPduLen);
+ dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu = NULLP;
+ }
+ MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc));
+ }
}
/* Fill message header */
DU_LOG("\nDEBUG --> LWR_MAC: Sending TX DATA Request");
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg++;
- headerElem->p_next->p_next->p_next = txDataElem;
+ prevElem->p_next = txDataElem;
}
#endif
return ROK;
* RFAILED - failure
*
******************************************************************/
-uint16_t fillUlTtiReq(SlotIndInfo currTimingInfo, p_fapi_api_queue_elem_t headerElem)
+uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_TTI_REQUEST\n");
+#endif
+
#ifdef INTEL_FAPI
uint16_t cellIdx =0;
uint8_t pduIdx = -1;
- SlotIndInfo ulTtiReqTimingInfo;
+ SlotTimingInfo ulTtiReqTimingInfo;
MacUlSlot *currUlSlot = NULLP;
MacCellCfg macCellCfg;
fapi_ul_tti_req_t *ulTtiReq = NULLP;
- fapi_msg_header_t *msgHeader = NULLP;
p_fapi_api_queue_elem_t ulTtiElem;
if(lwrMacCb.phyState == PHY_STATE_RUNNING)
#ifdef ODU_SLOT_IND_DEBUG_LOG
DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request");
#endif
-
- /* Fill message header */
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg++;
- headerElem->p_next->p_next = ulTtiElem;
+ prevElem->p_next = ulTtiElem;
memset(currUlSlot, 0, sizeof(MacUlSlot));
return ROK;
******************************************************************/
void fillUlDciPdu(fapi_dl_dci_t *ulDciPtr, DciInfo *schDciInfo)
{
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_DCI_REQUEST\n");
+#endif
if(ulDciPtr != NULLP)
{
uint8_t numBytes =0;
* RFAILED - failure
*
******************************************************************/
-uint16_t fillUlDciReq(SlotIndInfo currTimingInfo)
+uint16_t fillUlDciReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
uint8_t cellIdx =0;
uint8_t numPduEncoded = 0;
- SlotIndInfo ulDciReqTimingInfo ={0};
+ SlotTimingInfo ulDciReqTimingInfo ={0};
MacDlSlot *currDlSlot = NULLP;
fapi_ul_dci_req_t *ulDciReq =NULLP;
- fapi_msg_header_t *msgHeader =NULLP;
p_fapi_api_queue_elem_t ulDciElem;
- p_fapi_api_queue_elem_t headerElem;
if(lwrMacCb.phyState == PHY_STATE_RUNNING)
{
GET_CELL_IDX(currTimingInfo.cellId, cellIdx);
- memcpy(&ulDciReqTimingInfo, &currTimingInfo, sizeof(SlotIndInfo));
+ memcpy(&ulDciReqTimingInfo, &currTimingInfo, sizeof(SlotTimingInfo));
currDlSlot = &macCb.macCell[cellIdx]->dlSlot[ulDciReqTimingInfo.slot % MAX_SLOTS];
- if(currDlSlot->dlInfo.ulGrant != NULLP)
- {
LWR_MAC_ALLOC(ulDciElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_dci_req_t)));
if(ulDciElem)
{
ulDciReq->sfn = ulDciReqTimingInfo.sfn;
ulDciReq->slot = ulDciReqTimingInfo.slot;
+ if(currDlSlot->dlInfo.ulGrant != NULLP)
+ {
ulDciReq->numPdus = 1; // No. of PDCCH PDUs
if(ulDciReq->numPdus > 0)
{
numPduEncoded++;
/* free UL GRANT at SCH */
MAC_FREE(currDlSlot->dlInfo.ulGrant, sizeof(DciInfo));
- currDlSlot->dlInfo.ulGrant = NULLP;
-
- /* Fill message header */
- LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
- if(!headerElem)
- {
- DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for UL DCI req header");
- LWR_MAC_FREE(ulDciElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_dci_req_t)));
- return RFAILED;
- }
- FILL_FAPI_LIST_ELEM(headerElem, ulDciElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
- sizeof(fapi_msg_header_t));
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg = 1;
- msgHeader->handle = 0;
+ }
#ifdef ODU_SLOT_IND_DEBUG_LOG
DU_LOG("\nDEBUG --> LWR_MAC: Sending UL DCI Request");
#endif
- LwrMacSendToL1(headerElem);
- }
}
- else
- {
- DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL DCI Request");
- memset(currDlSlot, 0, sizeof(MacDlSlot));
- return RFAILED;
- }
+ prevElem->p_next = ulDciElem;
}
}
else
lwr_mac_procConfigReqEvt,
lwr_mac_procConfigRspEvt,
lwr_mac_procInvalidEvt,
- lwr_mac_procStopReqEvt,
+ lwr_mac_procInvalidEvt,
}
};
Code Review / o-du / l2.git / blobdiff