X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Flwr_mac_fsm.c;h=ba26c40279219b364a484ce3f6df18ea5dcd4dd1;hb=069ae37558afd5aee2d1072bbf5b517cf665bdd8;hp=fdc7e3cacf8471e6f0245eec754c561a01f3325e;hpb=d2087c85ac86d4ffb898e87aecc1495510ef9c68;p=o-du%2Fl2.git diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index fdc7e3cac..ba26c4027 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -61,16 +61,37 @@ #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 +} /******************************************************************* * @@ -1301,13 +1322,12 @@ S16 lwr_mac_handleParamReqEvt(void *msg) uint32_t msgLen; //Length of message Body msgLen = 0; fapi_param_req_t *paramReq; - MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); + LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); 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); - MAC_FREE(paramReq, sizeof(fapi_param_req_t)); + DU_LOG("\nLOWER MAC: Sending Param Request to Phy"); + LwrMacSendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq); return ROK; } else @@ -1831,7 +1851,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) } } MAC_FREE(cellParam, sizeof(ClCellParam)); - MAC_FREE(paramRsp, sizeof(fapi_param_resp_t)); + sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL); return ROK; } else @@ -1889,8 +1909,7 @@ S16 lwr_mac_handleConfigReqEvt(void *msg) cellParams = rgCb[inst].cell; macCfgParams = cellParams->macCellCfg; configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t)); - MAC_ALLOC(configReq, configReqSize); - + LWR_MAC_ALLOC(configReq, configReqSize); if(configReq != NULL) { configReq->number_of_tlvs = macCfgParams.numTlv; @@ -1933,8 +1952,18 @@ S16 lwr_mac_handleConfigReqEvt(void *msg) 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); - fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, - sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen); + if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq) + { + LWR_MAC_ALLOC(macCfgParams.prachCfg.fdm[0].unsuedRootSeq , + 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); + } + else + { + macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL; + } + 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); @@ -1958,8 +1987,8 @@ S16 lwr_mac_handleConfigReqEvt(void *msg) 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); - MAC_FREE(configReq, configReqSize); + /* TODO : Recheck the size / msglen to be sent to WLS_Put*/ + LwrMacSendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq); return ROK; } else @@ -1983,9 +2012,13 @@ S16 lwr_mac_handleConfigRspEvt(void *msg) { if(configRsp->error_code == MSG_OK) { - DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n"); + DU_LOG("\nLOWER MAC: PHY has moved to Configured state \n"); clGlobalCp.phyState = PHY_STATE_CONFIGURED; - MAC_FREE(configRsp, sizeof(fapi_config_resp_t)); + /* TODO : + * Store config response into an intermediate struture and send to MAC + * Support LC and LWLC for sending config rsp to MAC + */ + fapiMacConfigRsp(); return ROK; } else @@ -2007,17 +2040,16 @@ S16 lwr_mac_handleConfigRspEvt(void *msg) S16 lwr_mac_handleStartReqEvt(void *msg) { -#ifdef FAPi +#ifdef FAPI uint32_t msgLen = 0; fapi_start_req_t *startReq; - 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); DU_LOG("\nLOWER MAC: Sending Start Request to PHY"); - sendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq); - MAC_FREE(startReq, sizeof(fapi_start_req_t)); + LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq); return ROK; } else @@ -2035,9 +2067,8 @@ S16 lwr_mac_handleStopReqEvt(void *msg) #ifdef FAPI /* stop TX and RX operation return PHy to configured State send stop.indication to l2/l3 */ -#else - RETVALUE(ROK); #endif + return ROK; } /******************************************************************* @@ -2093,7 +2124,7 @@ S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */ dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId; dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss; - dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->cellBroadcastInfo.ssbInfo[ssbIdxCount].ssbIdx; + dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx; dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset; /* ssbOfPdufstA to be filled in ssbCfg */ dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA; @@ -2123,37 +2154,270 @@ S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, * * @details * - * Function : fillDlDciPdu + * Function : fillSib1DlDciPdu * * Functionality: * -Fills the Dl DCI PDU * * @params[in] Pointer to fapi_dl_dci_t - * Pointer to Sib1PdcchCfg + * Pointer to PdcchCfg * @return ROK * ******************************************************************/ -void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) +void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) { if(dlDciPtr != NULLP) { - dlDciPtr->rnti = sib1PdcchInfo->sib1DlDci.rnti; - dlDciPtr->scramblingId = sib1PdcchInfo->sib1DlDci.scramblingId; - dlDciPtr->scramblingRnti = sib1PdcchInfo->sib1DlDci.scramblingRnti; - dlDciPtr->cceIndex = sib1PdcchInfo->sib1DlDci.cceIndex; - dlDciPtr->aggregationLevel = sib1PdcchInfo->sib1DlDci.aggregLevel; - dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.numPrgs; - dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prgSize; - dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.digBfInterfaces; - dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].pmIdx; - 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]; + 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->dci.rnti; + dlDciPtr->scramblingId = sib1PdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = sib1PdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = sib1PdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = sib1PdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->dci.beamPdcchInfo.prgSize; + dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci.beamPdcchInfo.digBfInterfaces; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue; + dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->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= sib1PdcchInfo->coreset0Cfg.coreSet0Size; + rbStart = 0; /* For SIB1 */ + //rbStart = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbStart; + rbLen = sib1PdcchInfo->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 = sib1PdcchInfo->dci.pdschCfg->timeAlloc. + rowIndex -1; + VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->freqAlloc.\ + vrbPrbMapping; + modNCodScheme = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; + redundancyVer = sib1PdcchInfo->dci.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); + + /* 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); + } -} +} /* fillSib1DlDciPdu */ + +/******************************************************************* + * + * @brief fills Dl DCI PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillRarDlDciPdu + * + * Functionality: + * -Fills the Dl DCI PDU + * + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ + +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); + + 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; + + 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,\ + tbScaling, tbScalingSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + reserved, reservedSize); + } +} /* fillRarDlDciPdu */ /******************************************************************* * @@ -2168,34 +2432,42 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) * stored in MAC * * @params[in] Pointer to FAPI DL TTI Req - * Pointer to Sib1PdcchCfg + * Pointer to PdcchCfg * Pointer to msgLen of DL TTI Info * @return ROK * ******************************************************************/ -S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdcchCfg *sib1PdcchInfo, +S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdcchCfg *pdcchInfo, uint32_t *msgLen) { if(dlTtiReqPdu != NULLP) { dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; - dlTtiReqPdu->u.pdcch_pdu.bwpSize = sib1PdcchInfo->sib1PdcchBwpCfg.BWPSize; - dlTtiReqPdu->u.pdcch_pdu.bwpPart = sib1PdcchInfo->sib1PdcchBwpCfg.BWPStart; - dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = sib1PdcchInfo->sib1PdcchBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = sib1PdcchInfo->sib1PdcchBwpCfg.cyclicPrefix; - dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = sib1PdcchInfo->sib1Coreset0Cfg.startSymbolIndex; - dlTtiReqPdu->u.pdcch_pdu.durationSymbols = sib1PdcchInfo->sib1Coreset0Cfg.durationSymbols; - memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, sib1PdcchInfo->sib1Coreset0Cfg.freqDomainResource, 6); - dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = sib1PdcchInfo->sib1Coreset0Cfg.cceRegMappingType; - dlTtiReqPdu->u.pdcch_pdu.regBundleSize = sib1PdcchInfo->sib1Coreset0Cfg.regBundleSize; - dlTtiReqPdu->u.pdcch_pdu.interleaverSize = sib1PdcchInfo->sib1Coreset0Cfg.interleaverSize; - dlTtiReqPdu->u.pdcch_pdu.coreSetSize = sib1PdcchInfo->sib1Coreset0Cfg.coreSetType; - dlTtiReqPdu->u.pdcch_pdu.shiftIndex = sib1PdcchInfo->sib1Coreset0Cfg.shiftIndex; - dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = sib1PdcchInfo->sib1Coreset0Cfg.precoderGranularity; - dlTtiReqPdu->u.pdcch_pdu.numDlDci = sib1PdcchInfo->numDlDci; - MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t)); - fillDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, sib1PdcchInfo); + 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; + LWR_MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, 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); + } + dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t); SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t)); @@ -2217,13 +2489,13 @@ uint32_t *msgLen) * stored in MAC * * @params[in] Pointer to FAPI DL TTI Req - * Pointer to Sib1PdschCfg + * Pointer to PdschCfg * Pointer to msgLen of DL TTI Info * @return ROK * ******************************************************************/ -void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdschCfg *sib1PdschInfo, +void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo, uint32_t *msgLen) { uint8_t idx; @@ -2231,49 +2503,49 @@ uint32_t *msgLen) if(dlTtiReqPdu != NULLP) { dlTtiReqPdu->pduType = PDSCH_PDU_TYPE; - dlTtiReqPdu->u.pdsch_pdu.pduBitMap = sib1PdschInfo->pduBitmap; - dlTtiReqPdu->u.pdsch_pdu.rnti = sib1PdschInfo->rnti; - dlTtiReqPdu->u.pdsch_pdu.pduIndex = sib1PdschInfo->pduIndex; - dlTtiReqPdu->u.pdsch_pdu.bwpSize = sib1PdschInfo->sib1PdschBwpCfg.BWPSize; - dlTtiReqPdu->u.pdsch_pdu.bwpStart = sib1PdschInfo->sib1PdschBwpCfg.BWPStart; - dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = sib1PdschInfo->sib1PdschBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = sib1PdschInfo->sib1PdschBwpCfg.cyclicPrefix; - dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = sib1PdschInfo->numCodewords; + dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap; + dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti; + dlTtiReqPdu->u.pdsch_pdu.pduIndex = pdschInfo->pduIndex; + dlTtiReqPdu->u.pdsch_pdu.bwpSize = pdschInfo->pdschBwpCfg.BWPSize; + dlTtiReqPdu->u.pdsch_pdu.bwpStart = pdschInfo->pdschBwpCfg.BWPStart; + dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = pdschInfo->pdschBwpCfg.subcarrierSpacing; + dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = pdschInfo->pdschBwpCfg.cyclicPrefix; + dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords; for(idx = 0; idx < MAX_CODEWORDS ; idx++) { - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = sib1PdschInfo->codeword[idx].targetCodeRate; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = sib1PdschInfo->codeword[idx].qamModOrder; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = sib1PdschInfo->codeword[idx].mcsIndex; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = sib1PdschInfo->codeword[idx].mcsTable; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = sib1PdschInfo->codeword[idx].rvIndex; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = sib1PdschInfo->codeword[idx].tbSize; + dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate; + dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder; + dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex; + dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable; + dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex; + dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize; } - dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = sib1PdschInfo->dataScramblingId; - dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = sib1PdschInfo->numLayers; - dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = sib1PdschInfo->transmissionScheme; - dlTtiReqPdu->u.pdsch_pdu.refPoint = sib1PdschInfo->refPoint; - dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = sib1PdschInfo->dmrs.dlDmrsSymbPos; - dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = sib1PdschInfo->dmrs.dmrsConfigType; - dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = sib1PdschInfo->dmrs.dlDmrsScramblingId; - dlTtiReqPdu->u.pdsch_pdu.scid = sib1PdschInfo->dmrs.scid; - dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = sib1PdschInfo->dmrs.numDmrsCdmGrpsNoData; - dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = sib1PdschInfo->dmrs.dmrsPorts; - dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = sib1PdschInfo->sib1FreqAlloc.resourceAlloc; + dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId; + dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = pdschInfo->numLayers; + dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme; + dlTtiReqPdu->u.pdsch_pdu.refPoint = pdschInfo->refPoint; + dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos; + dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType; + dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId; + dlTtiReqPdu->u.pdsch_pdu.scid = pdschInfo->dmrs.scid; + dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData; + dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts; + dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->freqAlloc.resourceAlloc; /* since we are using type-1, hence rbBitmap excluded */ - dlTtiReqPdu->u.pdsch_pdu.rbStart = sib1PdschInfo->sib1FreqAlloc.rbStart; - dlTtiReqPdu->u.pdsch_pdu.rbSize = sib1PdschInfo->sib1FreqAlloc.rbSize; - dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = sib1PdschInfo->sib1FreqAlloc.vrbPrbMapping; - dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = sib1PdschInfo->sib1TimeAlloc.startSymbolIndex; - dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = sib1PdschInfo->sib1TimeAlloc.numSymbols; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = sib1PdschInfo->beamPdschInfo.numPrgs; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = sib1PdschInfo->beamPdschInfo.prgSize; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = sib1PdschInfo->beamPdschInfo.digBfInterfaces; + dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->freqAlloc.rbStart; + dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->freqAlloc.rbSize; + dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->freqAlloc.vrbPrbMapping; + dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->timeAlloc.startSymbolIndex; + dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->timeAlloc.numSymbols; + dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs; + dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize; + dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces; dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ - pmIdx = sib1PdschInfo->beamPdschInfo.prg[0].pmIdx; + pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx; dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ - beamIdx[0].beamidx = sib1PdschInfo->beamPdschInfo.prg[0].beamIdx[0]; - dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = sib1PdschInfo->txPdschPower.powerControlOffset; - dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = sib1PdschInfo->txPdschPower.powerControlOffsetSS; + beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0]; + dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset; + dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS; dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t); SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t)); @@ -2296,24 +2568,140 @@ uint32_t *msgLen) * @return count * * ********************************************************************/ -uint8_t calculatePduCount(DlBrdcstAlloc *cellBroadcastInfo) +uint8_t calculatePduCount(DlAlloc *dlInfo) { uint8_t count = 0; uint8_t idx = 0; - if(cellBroadcastInfo->ssbTrans) - { - for(idx = 0; idx < cellBroadcastInfo->ssbIdxSupported; idx++) + if(dlInfo->isBroadcastPres) + { + if(dlInfo->brdcstAlloc.ssbTrans) + { + for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++) + { + count++; + } + } + if(dlInfo->brdcstAlloc.sib1Trans) { - count++; + count += 2; } } - if(cellBroadcastInfo->sib1Trans) - { - count += 2; - } + if(dlInfo->isRarPres) + { + count += 2; + } return count; } +/*********************************************************************** + * + * @brief fills the SIB1 TX-DATA request message + * + * @details + * + * Function : fillSib1TxDataReq + * + * Functionality: + * - fills the SIB1 TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] MacCellCfg *macCellCfg + * @params[in] uint16_t pduIndex + * @params[in] uint32_t *msgLen + * @return ROK + * + * ********************************************************************/ +uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg, + uint16_t pduIndex, uint32_t *msgLen) +{ + 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 */ + pduDesc[pduIndex].pduLength = pduLen; + msgLen += pduLen; + +#ifndef INTEL_WLS + MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); +#endif + + + return ROK; +} + +/*********************************************************************** + * + * @brief fills the RAR TX-DATA request message + * + * @details + * + * Function : fillRarTxDataReq + * + * Functionality: + * - fills the RAR TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] RarInfo *rarInfo + * @params[in] uint16_t pduIndex + * @params[in] uint32_t *msgLen + * @return ROK + * + * ********************************************************************/ +uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo, + uint16_t pduIndex, uint32_t *msgLen) +{ + 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 */ + 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(rarTxdataValue,rarInfo->rarPduLen); +#endif + + return ROK; +} + #endif /******************************************************************* @@ -2332,17 +2720,301 @@ uint8_t calculatePduCount(DlBrdcstAlloc *cellBroadcastInfo) * RFAILED - failure * * ****************************************************************/ -S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) +uint16_t handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) +{ +#ifdef FAPI + uint8_t idx; + uint8_t nPdu = 0; + uint8_t numPduEncoded = 0; + uint32_t msgLen = 0; + fapi_dl_tti_req_t *dlTtiReq = NULLP; + fapi_tx_data_req_t *txDataReq = 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(dlTtiReqtimingInfo != NULLP) + { + LWR_MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t)); + if(dlTtiReq != NULLP) + { + dlTtiReq->sfn = dlTtiReqtimingInfo->sfn; + dlTtiReq->slot = dlTtiReqtimingInfo->slot; + currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED]; + dlTtiReq->nPdus = calculatePduCount(&currDlSlot->dlInfo); /* get total Pdus */ + nPdu = dlTtiReq->nPdus; + dlTtiReq->nGroup = 0; + if(dlTtiReq->nPdus > 0) + { + LWR_MAC_ALLOC(dlTtiReq->pdus, (nPdu * sizeof(fapi_dl_tti_req_pdu_t))); + if(!dlTtiReq->pdus) + { + DU_LOG("\nLOWER 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++) + { + if(idx > 0) + dlTtiReq->pdus++; + fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg, currDlSlot, &msgLen, idx); + numPduEncoded++; + } + } + DU_LOG("\nLOWER MAC: MIB sent.."); + } + 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); + numPduEncoded++; + } + DU_LOG("\nLOWER MAC: SIB1 sent..."); + } + } + if(currDlSlot->dlInfo.isRarPres) + { + /* Filling RAR param */ + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdcchCfg, &msgLen); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdschCfg, &msgLen); + numPduEncoded++; + DU_LOG("\nLOWER MAC: RAR sent..."); + } + + msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + /* TODO : Recheck the size / msglen to be sent to WLS_Put*/ + LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq); + + /* send TX_Data request message */ + if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) + { + msgLen = 0; + LWR_MAC_ALLOC(txDataReq,sizeof(fapi_tx_data_req_t)); + txDataReq->sfn = dlTtiReqtimingInfo->sfn; + txDataReq->slot = dlTtiReqtimingInfo->slot; + txDataReq->numPdus = 1; + LWR_MAC_ALLOC(txDataReq->pduDesc, (txDataReq->numPdus * \ + sizeof(fapi_tx_pdu_desc_t))); + fillSib1TxDataReq( + txDataReq->pduDesc, + &rgCb[inst].cell->macCellCfg, + currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg.pduIndex, + &msgLen); + 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, msgLen,(void *)txDataReq); + } + if(currDlSlot->dlInfo.isRarPres) + { + msgLen = 0; + /* mux and form RAR pdu */ + fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo); + LWR_MAC_ALLOC(txDataReq,sizeof(fapi_tx_data_req_t)); + txDataReq->sfn = dlTtiReqtimingInfo->sfn; + txDataReq->slot = dlTtiReqtimingInfo->slot; + txDataReq->numPdus = 1; + LWR_MAC_ALLOC(txDataReq->pduDesc, (txDataReq->numPdus * \ + sizeof(fapi_tx_pdu_desc_t))); + fillRarTxDataReq( + txDataReq->pduDesc, + &currDlSlot->dlInfo.rarAlloc.rarInfo, + currDlSlot->dlInfo.rarAlloc.rarPdschCfg.pduIndex, + &msgLen); + fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen); + LwrMacSendToPhy(txDataReq->header.message_type_id, msgLen,(void *)txDataReq); + } + } + else + { + msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + /* TODO : Recheck the size / msglen to be sent to WLS_Put*/ + LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq); + } + return ROK; + } + else + { + DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request"); + return RFAILED; + } + } + else + { + DU_LOG("\nLOWER MAC: Current TTI Info is NULL"); + return RFAILED; + } + } + else + { + lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo); + } +#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_dl_tti_req_t *dlTtiReq = NULLP; - fapi_dl_tti_req_pdu_t *dlTtiReqPdu = NULLP; + fapi_ul_tti_req_t *ulTtiReq = NULLP; + fapi_ul_tti_req_pdu_t *ulTtiReqPdu = NULLP; RgCellCb *cellCbParams = NULLP; - MacDlSlot *currDlSlot = NULLP; + MacUlSlot *currUlSlot = NULLP; MacCellCfg macCellCfg; - cmMemset((U8 *)&macCellCfg, 0, sizeof(MacCellCfg)); + memset(&macCellCfg, 0, sizeof(MacCellCfg)); Inst inst = 0; if(clGlobalCp.phyState == PHY_STATE_RUNNING) @@ -2350,82 +3022,61 @@ S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) cellCbParams = rgCb[inst].cell; macCellCfg = cellCbParams->macCellCfg; - if(dlTtiReqtimingInfo != NULLP) + if(currTimingInfo != NULLP) { - MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t)); - if(dlTtiReq != NULLP) + LWR_MAC_ALLOC(ulTtiReq, sizeof(fapi_ul_tti_req_t)); + if(ulTtiReq != 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 */ - dlTtiReq->nGroup = 0; - if(dlTtiReq->nPdus > 0) + 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) { - MAC_ALLOC(dlTtiReqPdu, (dlTtiReq->nPdus * sizeof(fapi_dl_tti_req_pdu_t))); - if(currDlSlot->cellBroadcastInfo.ssbTrans) + LWR_MAC_ALLOC(ulTtiReqPdu, (ulTtiReq->nPdus * + sizeof(fapi_ul_tti_req_pdu_t))); + /* Fill Prach Pdu */ + if(ulTtiReq->rachPresent) { - if(dlTtiReqPdu != NULLP) + if(ulTtiReqPdu != NULLP) { - for(idx = 0; idx < currDlSlot->cellBroadcastInfo.ssbIdxSupported; idx++) - { - if(idx > 0) - dlTtiReq->pdus++; - fillSsbPdu(dlTtiReqPdu, &macCellCfg, currDlSlot, &msgLen, idx); - dlTtiReq->pdus = dlTtiReqPdu; - } + 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); + DU_LOG("\nLOWER MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq); } - if(currDlSlot->cellBroadcastInfo.sib1Trans) - { - /* Filling SIB1 param */ - if(dlTtiReqPdu != NULLP) - { - dlTtiReq->pdus++; - fillPdcchPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.sib1Alloc.sib1PdcchCfg, &msgLen); - dlTtiReq->pdus = dlTtiReqPdu; - dlTtiReq->pdus++; - fillPdschPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.sib1Alloc.sib1PdschCfg, &msgLen); - dlTtiReq->pdus = dlTtiReqPdu; - } - } - 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); - if(currDlSlot->cellBroadcastInfo.sib1Trans) - { - MAC_FREE(dlTtiReq->pdus->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t)); - } - MAC_FREE(dlTtiReqPdu, (dlTtiReq->nPdus * 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); - } - MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t)); - return ROK; + } + else + { + msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); + DU_LOG("\nLOWER MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq); + } + return ROK; } - else - { - DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request"); + else + { + DU_LOG("\nLOWER MAC: Failed to allocate memory for UL TTI Request"); return RFAILED; } } else { - DU_LOG("\nLOWER MAC: Current TTI Info is NULL"); + DU_LOG("\nLOWER MAC: Current TTI Info in UL is NULL"); return RFAILED; } } else { - lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo); + lwr_mac_handleInvalidEvt(currTimingInfo); } -#else - return ROK; #endif + return ROK; } lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =