#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 PDSCH_PDU_TYPE 1
#define SSB_PDU_TYPE 3
+#define PRACH_PDU_TYPE 0
+#define PDU_PRESENT 1
#define SETLENGTH(x, size) x += size
+extern void fapiMacConfigRsp();
+extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
-EXTERN void sendToPhy ARGS((uint8_t msgType, uint32_t msgLen, void *msg));
-SlotIndInfo slotIndInfo; //global variable
+/* Global variables */
+SlotIndInfo slotIndInfo;
+uint8_t slotIndIdx;
+
+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_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;
}
/*******************************************************************
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;
RgCellCb *cellCbParams = NULLP;
MacDlSlot *currDlSlot = NULLP;
MacCellCfg macCellCfg;
- cmMemset((U8 *)&macCellCfg, 0, sizeof(MacCellCfg));
+ memset(&macCellCfg, 0, sizeof(MacCellCfg));
Inst inst = 0;
if(clGlobalCp.phyState == PHY_STATE_RUNNING)
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
+#endif
return ROK;
+}
+
+/***********************************************************************
+ *
+ * @brief calculates the total size to be allocated for UL TTI Req
+ *
+ * @details
+ *
+ * Function : getnPdus
+ *
+ * Functionality:
+ * -calculates the total pdu count to be allocated for UL TTI Req
+ *
+ * @params[in] Pointer to fapi Ul TTI Req
+ * Pointer to CurrUlSlot
+ * @return count
+ * ********************************************************************/
+#ifdef FAPI
+uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot)
+{
+ uint8_t pduCount = 0;
+
+ if(currUlSlot != NULLP)
+ {
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH)
+ {
+ pduCount++;
+ ulTtiReq->rachPresent = PDU_PRESENT;
+ }
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
+ {
+ pduCount++;
+ ulTtiReq->nUlsch = PDU_PRESENT;
+ }
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI)
+ {
+ pduCount++;
+ ulTtiReq->nUlcch = PDU_PRESENT;
+ }
+ if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS)
+ {
+ pduCount++;
+ }
+ }
+ return pduCount;
+}
+#endif
+
+/***********************************************************************
+ *
+ * @brief Set the value of zero correlation config in PRACH PDU
+ *
+ * @details
+ *
+ * Function : setNumCs
+ *
+ * Functionality:
+ * -Set the value of zero correlation config in PRACH PDU
+ *
+ * @params[in] Pointer to zero correlation config
+ * Pointer to MacCellCfg
+ * ********************************************************************/
+
+void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg)
+{
+#ifdef FAPI
+ uint8_t idx;
+ if(macCellCfg != NULLP)
+ {
+ idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg;
+ *numCs = UnrestrictedSetNcsTable[idx];
+ }
#endif
}
+/***********************************************************************
+ *
+ * @brief Fills the PRACH PDU in UL TTI Request
+ *
+ * @details
+ *
+ * Function : fillPrachPdu
+ *
+ * Functionality:
+ * -Fills the PRACH PDU in UL TTI Request
+ *
+ * @params[in] Pointer to Prach Pdu
+ * Pointer to CurrUlSlot
+ * Pointer to macCellCfg
+ * Pointer to msgLen
+ * ********************************************************************/
+
+#ifdef FAPI
+void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen)
+{
+ if(ulTtiReqPdu != NULLP)
+ {
+ ulTtiReqPdu->pduType = PRACH_PDU_TYPE;
+ 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;
+ ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa;
+ ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \
+ 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;
+ ulTtiReqPdu->u.prach_pdu.beamforming.digBfInterfaces = 0;
+ ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0;
+ ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0;
+ ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t);
+ SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t));
+ }
+}
+#endif
+
+/*******************************************************************
+ *
+ * @brief Sends UL TTI Request to PHY
+ *
+ * @details
+ *
+ * Function : handleUlTtiReq
+ *
+ * Functionality:
+ * -Sends FAPI Param req to PHY
+ *
+ * @params[in] Pointer to CmLteTimingInfo
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ******************************************************************/
+S16 handleUlTtiReq(CmLteTimingInfo *currTimingInfo)
+{
+#ifdef FAPI
+ uint32_t msgLen = 0;
+ fapi_ul_tti_req_t *ulTtiReq = NULLP;
+ fapi_ul_tti_req_pdu_t *ulTtiReqPdu = NULLP;
+ RgCellCb *cellCbParams = NULLP;
+ MacUlSlot *currUlSlot = 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)
+ {
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(ulTtiReq, sizeof(fapi_ul_tti_req_t));
+#else
+ MAC_ALLOC(ulTtiReq, sizeof(fapi_ul_tti_req_t));
+#endif
+ if(ulTtiReq != NULLP)
+ {
+ ulTtiReq->sfn = currTimingInfo->sfn;
+ ulTtiReq->slot = currTimingInfo->slot;
+ currUlSlot = &macCb.macCell->ulSlot[ulTtiReq->slot % MAX_SLOT_SUPPORTED];
+ ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
+ ulTtiReq->nGroup = 0;
+ if(ulTtiReq->nPdus > 0)
+ {
+#ifdef INTEL_WLS
+ WLS_MEM_ALLOC(ulTtiReqPdu, (ulTtiReq->nPdus * sizeof(fapi_ul_tti_req_pdu_t)));
+#else
+ MAC_ALLOC(ulTtiReqPdu, (ulTtiReq->nPdus * sizeof(fapi_ul_tti_req_pdu_t)));
+#endif
+ /* Fill Prach Pdu */
+ if(ulTtiReq->rachPresent)
+ {
+ if(ulTtiReqPdu != NULLP)
+ {
+ fillPrachPdu(ulTtiReqPdu, &macCellCfg, currUlSlot, &msgLen);
+ ulTtiReq->pdus = ulTtiReqPdu;
+ }
+ msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
+ fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
+ LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq);
+ MAC_FREE(ulTtiReqPdu, (ulTtiReq->nPdus * sizeof(fapi_ul_tti_req_pdu_t)));
+ }
+ }
+ else
+ {
+ msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
+ fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
+ LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq);
+ }
+ MAC_FREE(ulTtiReq, sizeof(fapi_ul_tti_req_t));
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Failed to allocate memory for UL TTI Request");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Current TTI Info in UL is NULL");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ lwr_mac_handleInvalidEvt(currTimingInfo);
+ }
+#endif
+ return ROK;
+}
+
lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
{
{
Code Review / o-du / l2.git / blobdiff