#include "du_app_mac_inf.h"
#include "mac.h"
#include "rg.x" /* typedefs for MAC */
+#include "lwr_mac_phy.h"
+#include "math.h"
#define MIB_SFN_BITMASK 0xFC
#define PDCCH_PDU_TYPE 0
#define SSB_PDU_TYPE 3
#define SETLENGTH(x, size) x += size
+extern void fapiMacConfigRsp();
+/* Global variables */
+SlotIndInfo slotIndInfo;
+uint8_t slotIndIdx;
-EXTERN void sendToPhy ARGS((uint8_t msgType, uint32_t msgLen, void *msg));
-SlotIndInfo slotIndInfo; //global variable
+void lwrMacInit()
+{
+#ifdef INTEL_WLS
+ uint8_t idx;
+
+ /* Initializing WLS free mem list */
+ slotIndIdx = 1;
+ for(idx = 0; idx < WLS_MEM_FREE_PRD; idx++)
+ {
+ cmLListInit(&wlsBlockToFreeList[idx]);
+ }
+#endif
+}
/*******************************************************************
*
uint32_t msgLen; //Length of message Body
msgLen = 0;
fapi_param_req_t *paramReq;
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(paramReq, sizeof(fapi_param_req_t));
+#else
MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
+#endif
+
if(paramReq != NULLP)
{
fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen);
DU_LOG("\nLOWER MAC: sending param Req to Phy");
- sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
+ LwrMacSendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
MAC_FREE(paramReq, sizeof(fapi_param_req_t));
return ROK;
}
}
MAC_FREE(cellParam, sizeof(ClCellParam));
MAC_FREE(paramRsp, sizeof(fapi_param_resp_t));
+
+ sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL);
return ROK;
}
else
cellParams = rgCb[inst].cell;
macCfgParams = cellParams->macCellCfg;
configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t));
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(configReq, configReqSize);
+#else
MAC_ALLOC(configReq, configReqSize);
+#endif
if(configReq != NULL)
{
fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
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.prachFdm, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,
+ 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].numRootSeq, &msgLen);
fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_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);
+ //MAC_ALLOC(macCfgParams.prachCfg.fdm[0].unsuedRootSeq, \
+ sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq);
+ macCfgParams.prachCfg.fdm[0].unsuedRootSeq = (uint8_t *)malloc(sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq);
fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,
- sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
+ sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
DU_LOG("\nLOWER_MAC: Sending Config Request to Phy");
- sendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq);
+ /* TODO : Recheck the size / msglen to be sent to WLS_Put*/
+ LwrMacSendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq);
MAC_FREE(configReq, configReqSize);
return ROK;
}
{
DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n");
clGlobalCp.phyState = PHY_STATE_CONFIGURED;
+ /* TODO :
+ * Store config response into an intermediate struture and send to MAC
+ * Support LC and LWLC for sending config rsp to MAC
+ */
+ fapiMacConfigRsp();
MAC_FREE(configRsp, sizeof(fapi_config_resp_t));
return ROK;
}
S16 lwr_mac_handleStartReqEvt(void *msg)
{
-#ifdef FAPi
+#ifdef FAPI
uint32_t msgLen = 0;
fapi_start_req_t *startReq;
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(startReq, sizeof(fapi_start_req_t));
+#else
MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
+#endif
if(startReq != NULL)
{
fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
DU_LOG("\nLOWER MAC: Sending Start Request to PHY");
- sendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq);
+ LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq);
MAC_FREE(startReq, sizeof(fapi_start_req_t));
return ROK;
}
#ifdef FAPI
/* stop TX and RX operation return PHy to configured State
send stop.indication to l2/l3 */
-#else
- RETVALUE(ROK);
#endif
+ return ROK;
}
/*******************************************************************
{
if(dlDciPtr != NULLP)
{
+ uint8_t numBytes;
+ uint8_t bytePos;
+ uint8_t bitPos;
+
+ uint16_t coreset0Size;
+ uint16_t rbStart;
+ uint16_t rbLen;
+ uint32_t freqDomResAssign;
+ uint32_t timeDomResAssign;
+ uint8_t VRB2PRBMap;
+ uint32_t modNCodScheme;
+ uint8_t redundancyVer;
+ uint32_t sysInfoInd;
+ uint32_t reserved;
+
+ /* Size(in bits) of each field in DCI format 0_1
+ * as mentioned in spec 38.214 */
+ uint8_t freqDomResAssignSize;
+ uint8_t timeDomResAssignSize = 4;
+ uint8_t VRB2PRBMapSize = 1;
+ uint8_t modNCodSchemeSize = 5;
+ uint8_t redundancyVerSize = 2;
+ uint8_t sysInfoIndSize = 1;
+ uint8_t reservedSize = 15;
+
dlDciPtr->rnti = sib1PdcchInfo->sib1DlDci.rnti;
dlDciPtr->scramblingId = sib1PdcchInfo->sib1DlDci.scramblingId;
dlDciPtr->scramblingRnti = sib1PdcchInfo->sib1DlDci.scramblingRnti;
dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].beamIdx[0];
dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerValue;
dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerControlOffsetSS;
- //dlDciPtr->payloadSizeBits;
- //dlDciPtr->payload[DCI_PAYLOAD_BYTE_LEN];
+
+ /* 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= sib1PdcchInfo->sib1Coreset0Cfg.coreSet0Size;
+ rbStart = 0; /* For SIB1 */
+ //rbStart = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbStart;
+ rbLen = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.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 = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1TimeAlloc.
+ rowIndex -1;
+ VRB2PRBMap = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.\
+ vrbPrbMapping;
+ modNCodScheme = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].mcsIndex;
+ redundancyVer = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].rvIndex;
+ sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */
+ reserved = 0;
+
+ /* Reversing bits in each DCI field */
+ freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize);
+ timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize);
+ VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize);
+ modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize);
+ redundancyVer = reverseBits(redundancyVer, redundancyVerSize);
+ sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize);
+ reserved = reverseBits(reserved, reservedSize);
+
+ /* Calulating total number of bytes in buffer */
+ dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\
+ + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\
+ + sysInfoIndSize + reservedSize;
+
+ numBytes = dlDciPtr->payloadSizeBits / 8;
+ if(dlDciPtr->payloadSizeBits % 8)
+ numBytes += 1;
+
+ if(numBytes > DCI_PAYLOAD_BYTE_LEN)
+ {
+ DU_LOG("\nLOWER 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,\
+ redundancyVer, redundancyVerSize);
+ fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+ sysInfoInd, sysInfoIndSize);
+ fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\
+ reserved, reservedSize);
+
}
-}
+} /* fillDlDciPdu */
/*******************************************************************
*
dlTtiReqPdu->u.pdcch_pdu.shiftIndex = sib1PdcchInfo->sib1Coreset0Cfg.shiftIndex;
dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = sib1PdcchInfo->sib1Coreset0Cfg.precoderGranularity;
dlTtiReqPdu->u.pdcch_pdu.numDlDci = sib1PdcchInfo->numDlDci;
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
+#else
MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
+#endif
fillDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, sib1PdcchInfo);
dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t);
SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t));
{
#ifdef FAPI
uint8_t idx;
+ uint8_t nPdu = 0;
uint32_t msgLen = 0;
fapi_dl_tti_req_t *dlTtiReq = NULLP;
fapi_dl_tti_req_pdu_t *dlTtiReqPdu = NULLP;
if(dlTtiReqtimingInfo != NULLP)
{
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
+#else
MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
+#endif
if(dlTtiReq != NULLP)
{
dlTtiReq->sfn = dlTtiReqtimingInfo->sfn;
dlTtiReq->slot = dlTtiReqtimingInfo->slot;
currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED];
dlTtiReq->nPdus = calculatePduCount(&currDlSlot->cellBroadcastInfo); /* get total Pdus */
+ nPdu = dlTtiReq->nPdus;
dlTtiReq->nGroup = 0;
if(dlTtiReq->nPdus > 0)
{
- MAC_ALLOC(dlTtiReqPdu, (dlTtiReq->nPdus * sizeof(fapi_dl_tti_req_pdu_t)));
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
+#else
+ MAC_ALLOC(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
+#endif
if(currDlSlot->cellBroadcastInfo.ssbTrans)
{
if(dlTtiReqPdu != NULLP)
}
msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
- sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
+ /* TODO : Recheck the size / msglen to be sent to WLS_Put*/
+ LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
if(currDlSlot->cellBroadcastInfo.sib1Trans)
{
- MAC_FREE(dlTtiReq->pdus->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
+ MAC_FREE(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t));
}
- MAC_FREE(dlTtiReqPdu, (dlTtiReq->nPdus * sizeof(fapi_dl_tti_req_pdu_t)));
+ MAC_FREE(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
}
else
{
msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
- sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
+ /* TODO : Recheck the size / msglen to be sent to WLS_Put*/
+ LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
}
MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
return ROK;
{
lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo);
}
-#else
- return ROK;
#endif
+ return ROK;
}
lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
Code Review / o-du / l2.git / blobdiff