################################################################################
*******************************************************************************/
-#include <stdlib.h>
-#include <stdint.h>
/* header include files -- defines (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system service interface */
-#include "cm_hash.h" /* common hash list */
-#include "cm_mblk.h" /* common memory link list library */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
+#include "common_def.h"
#include "lrg.h" /* Layer manager interface includes*/
#include "crg.h" /* CRG interface includes*/
#include "rgu.h" /* RGU interface includes*/
#include "lwr_mac_fsm.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
#include "rgu.x" /* RGU types */
#include "tfu.x" /* RGU types */
#include "lrg.x" /* layer management typedefs for MAC */
#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 PRACH_PDU_TYPE 0
#define PUSCH_PDU_TYPE 1
+#define PUCCH_PDU_TYPE 2
#define PDU_PRESENT 1
#define SET_MSG_LEN(x, size) x += size
/* Global variables */
uint8_t slotIndIdx;
-uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo);
+uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo);
void lwrMacInit()
{
RETVALUE(ROK);
}
-#ifdef FAPI
+#ifdef INTEL_FAPI
/*******************************************************************
*
* @brief Fills FAPI message header
S16 lwr_mac_handleParamReqEvt(void *msg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
/* startGuardTimer(); */
uint32_t msgLen = 0; //Length of message Body
fapi_param_req_t *paramReq = NULL;
S16 lwr_mac_handleParamRspEvt(void *msg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
/* stopGuardTimer(); */
uint8_t index;
uint32_t encodedVal;
S16 lwr_mac_handleConfigReqEvt(void *msg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
Inst inst = 0;
uint8_t idx = 0;
uint8_t index = 0;
fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG, \
sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
+ /* fill DMRS Type A Pos */
+ fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \
+ sizeof(uint8_t), macCfgParams.dmrsTypeAPos, &msgLen);
+
fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
S16 lwr_mac_handleConfigRspEvt(void *msg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
fapi_config_resp_t *configRsp;
configRsp = (fapi_config_resp_t *)msg;
* ****************************************************************/
S16 lwr_mac_handleStartReqEvt(void *msg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
uint32_t msgLen = 0;
fapi_start_req_t *startReq;
S16 lwr_mac_handleStopReqEvt(void *msg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
uint32_t msgLen = 0;
fapi_stop_req_t *stopReq = NULLP;
LWR_MAC_ALLOC(stopReq, sizeof(fapi_stop_req_t));
DU_LOG("\nLWR_MAC: MIB PDU %x", *val);
}
-#ifdef FAPI
+#ifdef INTEL_FAPI
/*******************************************************************
*
* @brief fills SSB PDU required for DL TTI info in MAC
*/
coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size;
rbStart = 0; /* For SIB1 */
- //rbStart = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
- rbLen = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
+ //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->timeAlloc.
+ timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->pdschTimeAlloc.
rowIndex -1;
- VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->freqAlloc.\
+ VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.\
vrbPrbMapping;
modNCodScheme = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
redundancyVer = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size;
rbStart = 0; /* For SIB1 */
//rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
- rbLen = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
+ rbLen = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
{
}
/* Fetching DCI field values */
- timeDomResAssign = rarPdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1;
- VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping;
+ timeDomResAssign = rarPdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
+ VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
tbScaling = 0; /* configured to 0 scaling */
reserved = 0;
/* TODO: Fill values of coreset0Size, rbStart and rbLen */
coreset0Size = msg4PdcchInfo->coreset0Cfg.coreSet0Size;
//rbStart = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbStart;
- rbLen = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbSize;
+ rbLen = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb;
if((rbLen >=1) && (rbLen <= coreset0Size - rbStart))
{
/* Fetching DCI field values */
dciFormatId = msg4Info->dciFormatId; /* DCI indentifier for DL */
- timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1;
- VRB2PRBMap = msg4PdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping;
+ timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
+ VRB2PRBMap = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
modNCodScheme = msg4PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
ndi = msg4Info->ndi;
redundancyVer = msg4PdcchInfo->dci.pdschCfg->codeword[0].rvIndex;
* @return ROK
*
******************************************************************/
-
-S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlAlloc *dlAlloc, uint32_t *msgLen, RntiType rntiType)
+S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, uint32_t *msgLen, RntiType rntiType)
{
if(dlTtiReqPdu != NULLP)
{
PdcchCfg *pdcchInfo = NULLP;
+ BwpCfg *bwp = NULLP;
+
+ dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \
+ (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \
+ (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*)));
+
if(rntiType == SI_RNTI_TYPE)
{
- pdcchInfo = &dlAlloc->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
+ pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg;
+ bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp;
fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
}
else if(rntiType == RA_RNTI_TYPE)
{
- pdcchInfo = &dlAlloc->rarAlloc.rarPdcchCfg;
+ pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg;
+ bwp = &dlInfo->rarAlloc->bwp;
fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
}
else if(rntiType == TC_RNTI_TYPE)
{
- pdcchInfo = &dlAlloc->msg4Alloc->msg4PdcchCfg;
+ pdcchInfo = &dlInfo->msg4Alloc->msg4PdcchCfg;
+ bwp = &dlInfo->msg4Alloc->bwp;
fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\
- &dlAlloc->msg4Alloc->msg4Info);
+ &dlInfo->msg4Alloc->msg4Info);
}
else
{
return RFAILED;;
}
dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
- dlTtiReqPdu->u.pdcch_pdu.bwpSize = pdcchInfo->pdcchBwpCfg.BWPSize;
- dlTtiReqPdu->u.pdcch_pdu.bwpPart = pdcchInfo->pdcchBwpCfg.BWPStart;
- dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = pdcchInfo->pdcchBwpCfg.subcarrierSpacing;
- dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = pdcchInfo->pdcchBwpCfg.cyclicPrefix;
+ dlTtiReqPdu->u.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb;
+ dlTtiReqPdu->u.pdcch_pdu.bwpPart = bwp->freqAlloc.startPrb;
+ dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing;
+ dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = bwp->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.shiftIndex = pdcchInfo->coreset0Cfg.shiftIndex;
dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity;
dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
- dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \
- (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \
- (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*)));
/* Calculating PDU length. Considering only one dl dci pdu for now */
dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t);
sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize));
}
- return ROK;
+ return ROK;
}
/*******************************************************************
******************************************************************/
void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
-uint32_t *msgLen, uint16_t pduIndex)
+ BwpCfg bwp,uint32_t *msgLen, uint16_t pduIndex)
{
uint8_t idx;
dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap;
dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti;
dlTtiReqPdu->u.pdsch_pdu.pduIndex = 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.bwpSize = bwp.freqAlloc.numPrb;
+ dlTtiReqPdu->u.pdsch_pdu.bwpStart = bwp.freqAlloc.startPrb;
+ dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing;
+ dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = bwp.cyclicPrefix;
dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords;
for(idx = 0; idx < MAX_CODEWORDS ; idx++)
{
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;
+ dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->pdschFreqAlloc.resourceAllocType;
/* since we are using type-1, hence rbBitmap excluded */
- 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.rbStart = pdschInfo->pdschFreqAlloc.freqAlloc.startPrb;
+ dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->pdschFreqAlloc.freqAlloc.numPrb;
+ dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->pdschFreqAlloc.vrbPrbMapping;
+ dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->pdschTimeAlloc.timeAlloc.startSymb;
+ dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->pdschTimeAlloc.timeAlloc.numSymb;
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;
* @return count
*
* ********************************************************************/
-uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo)
+uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo)
{
uint8_t count = 0;
uint8_t idx = 0;
{
for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++)
{
+ /* SSB PDU is filled */
count++;
}
}
if(dlInfo->brdcstAlloc.sib1Trans)
{
+ /* PDCCH and PDSCH PDU is filled */
count += 2;
}
}
- if(dlInfo->isRarPres)
+ if(dlInfo->rarAlloc != NULLP)
{
+ /* PDCCH and PDSCH PDU is filled */
count += 2;
}
- if(dlInfo->msg4Alloc)
+ if(dlInfo->msg4Alloc != NULLP)
{
+ /* PDCCH and PDSCH PDU is filled */
count += 2;
}
* @return count
*
* ********************************************************************/
-uint8_t calcTxDataReqPduCount(DlAlloc *dlInfo)
+uint8_t calcTxDataReqPduCount(DlSchedInfo *dlInfo)
{
uint8_t count = 0;
{
count++;
}
- if(dlInfo->isRarPres)
+ if(dlInfo->rarAlloc != NULLP)
{
count++;
}
- if(dlInfo->msg4Alloc)
+ if(dlInfo->msg4Alloc != NULLP)
{
count++;
}
* RFAILED - failure
*
* ****************************************************************/
-uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo)
+uint16_t handleDlTtiReq(SlotIndInfo currTimingInfo)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
uint8_t idx;
uint8_t nPdu = 0;
uint8_t numPduEncoded = 0;
uint16_t pduIndex = 0;
uint32_t msgLen = 0;
uint32_t dlTtiReqMsgSize = 0;
+
fapi_dl_tti_req_t *dlTtiReq = NULLP;
+ SlotIndInfo dlTtiReqTimingInfo;
+
RgCellCb *cellCbParams = NULLP;
MacDlSlot *currDlSlot = NULLP;
MacCellCfg macCellCfg;
if(clGlobalCp.phyState == PHY_STATE_RUNNING)
{
+ /* consider phy delay */
+ ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA);
+
cellCbParams = rgCb[inst].cell;
- macCellCfg = cellCbParams->macCellCfg;
-
- if(currTimingInfo != NULLP)
- {
- currDlSlot = &macCb.macCell->dlSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED];
- nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
- dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
- sizeof(fapi_dl_tti_req_pdu_t));
- if(nPdu > 0)
- {
- if(currDlSlot->dlInfo.isBroadcastPres)
- {
- if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
- {
- dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
- }
-
- }
- if(currDlSlot->dlInfo.isRarPres)
- {
- dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
- }
- if(currDlSlot->dlInfo.msg4Alloc)
- {
- dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
- }
- }
- LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
- if(dlTtiReq != NULLP)
- {
- memset(dlTtiReq, 0, dlTtiReqMsgSize);
- dlTtiReq->sfn = currTimingInfo->sfn;
- dlTtiReq->slot = currTimingInfo->slot;
- dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */
- nPdu = dlTtiReq->nPdus;
- dlTtiReq->nGroup = 0;
-
- if(dlTtiReq->nPdus > 0)
- {
- dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \
- (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*)));
- if(!dlTtiReq->pdus)
- {
- DU_LOG("\nLWR_MAC: Memory allocation failed");
- return RFAILED;
- }
-
- if(currDlSlot->dlInfo.isBroadcastPres)
- {
- if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
- {
- if(dlTtiReq->pdus != NULLP)
- {
- for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
- {
- fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\
- currDlSlot, &msgLen, idx, dlTtiReq->sfn);
- numPduEncoded++;
- }
- }
- printf("\033[1;31m");
- DU_LOG("\nLWR_MAC: MIB sent..");
- printf("\033[0m");
- }
- if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
- {
- /* Filling SIB1 param */
- if(numPduEncoded != nPdu)
- {
- rntiType = SI_RNTI_TYPE;
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\
- &msgLen, rntiType);
- numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\
- sib1Alloc.sib1PdschCfg, &msgLen, pduIndex);
- pduIndex++;
- numPduEncoded++;
- }
- printf("\033[1;34m");
- DU_LOG("\nLWR_MAC: SIB1 sent...");
- printf("\033[0m");
- }
- }
- if(currDlSlot->dlInfo.isRarPres)
- {
- /* Filling RAR param */
- rntiType = RA_RNTI_TYPE;
- fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo);
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo, &msgLen, rntiType);
- numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo.rarAlloc.rarPdschCfg, &msgLen, pduIndex);
- numPduEncoded++;
- pduIndex++;
-
- printf("\033[1;32m");
- DU_LOG("\nLWR_MAC: RAR sent...");
- printf("\033[0m");
- }
- if(currDlSlot->dlInfo.msg4Alloc)
- {
- /* Filling Msg4 param */
- rntiType = TC_RNTI_TYPE;
- fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo, &msgLen, rntiType);
- numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], \
- &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg, &msgLen, pduIndex);
- numPduEncoded++;
- pduIndex++;
-
- printf("\033[1;32m");
- DU_LOG("\nLWR_MAC: MSG4 sent...");
- printf("\033[0m");
- }
- msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
- fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
- LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
- (void *)dlTtiReq);
-
- /* send Tx-DATA req message */
- sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
- }
- else
- {
- msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
- fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
- LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
- }
- return ROK;
- }
- else
- {
- DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
- return RFAILED;
- }
- }
- else
- {
- DU_LOG("\nLWR_MAC: Current TTI Info is NULL");
- return RFAILED;
- }
- }
+ macCellCfg = cellCbParams->macCellCfg;
+
+ currDlSlot = &macCb.macCell->dlSlot[dlTtiReqTimingInfo.slot];
+ nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
+ dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
+ sizeof(fapi_dl_tti_req_pdu_t));
+ if(nPdu > 0)
+ {
+ if(currDlSlot->dlInfo.isBroadcastPres)
+ {
+ if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
+ {
+ dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
+ }
+ }
+ if(currDlSlot->dlInfo.rarAlloc != NULLP)
+ {
+ dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
+ }
+ if(currDlSlot->dlInfo.msg4Alloc != NULLP)
+ {
+ dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
+ }
+ }
+ LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
+ if(dlTtiReq != NULLP)
+ {
+ memset(dlTtiReq, 0, dlTtiReqMsgSize);
+ 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)
+ {
+ dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \
+ (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*)));
+ if(!dlTtiReq->pdus)
+ {
+ DU_LOG("\nLWR_MAC: Memory allocation failed");
+ return RFAILED;
+ }
+
+ if(currDlSlot->dlInfo.isBroadcastPres)
+ {
+ if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
+ {
+ if(dlTtiReq->pdus != NULLP)
+ {
+ for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
+ {
+ fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\
+ currDlSlot, &msgLen, idx, dlTtiReq->sfn);
+ numPduEncoded++;
+ }
+ }
+ printf("\033[1;31m");
+ DU_LOG("\nLWR_MAC: MIB sent..");
+ printf("\033[0m");
+ }
+ if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
+ {
+ /* Filling SIB1 param */
+ if(numPduEncoded != nPdu)
+ {
+ rntiType = SI_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\
+ &msgLen, rntiType);
+ numPduEncoded++;
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+ &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg,
+ currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp,
+ &msgLen, pduIndex);
+ pduIndex++;
+ numPduEncoded++;
+ }
+ printf("\033[1;34m");
+ DU_LOG("\nLWR_MAC: SIB1 sent...");
+ printf("\033[0m");
+ }
+ }
+ if(currDlSlot->dlInfo.rarAlloc != NULLP)
+ {
+ /* Filling RAR param */
+ rntiType = RA_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
+ &currDlSlot->dlInfo, &msgLen, rntiType);
+ numPduEncoded++;
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+ &currDlSlot->dlInfo.rarAlloc->rarPdschCfg,
+ currDlSlot->dlInfo.rarAlloc->bwp,
+ &msgLen, pduIndex);
+ numPduEncoded++;
+ pduIndex++;
+
+ printf("\033[1;32m");
+ DU_LOG("\nLWR_MAC: RAR sent...");
+ printf("\033[0m");
+ }
+ if(currDlSlot->dlInfo.msg4Alloc != NULLP)
+ {
+ /* Filling Msg4 param */
+ rntiType = TC_RNTI_TYPE;
+ fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
+ &currDlSlot->dlInfo, &msgLen, rntiType);
+ numPduEncoded++;
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
+ &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg,
+ currDlSlot->dlInfo.msg4Alloc->bwp,
+ &msgLen, pduIndex);
+ numPduEncoded++;
+ pduIndex++;
+
+ printf("\033[1;32m");
+ DU_LOG("\nLWR_MAC: MSG4 sent...");
+ printf("\033[0m");
+ }
+ msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
+ fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
+ LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
+ (void *)dlTtiReq);
+
+ /* send Tx-DATA req message */
+ sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
+ }
+ else
+ {
+ msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
+ fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
+ LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
+ }
+ memset(currDlSlot, 0, sizeof(MacDlSlot));
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
+ memset(currDlSlot, 0, sizeof(MacDlSlot));
+ return RFAILED;
+ }
+ }
else
{
- lwr_mac_handleInvalidEvt(currTimingInfo);
+ lwr_mac_handleInvalidEvt(&currTimingInfo);
return RFAILED;
}
#endif
* RFAILED - failure
*
* ****************************************************************/
-uint16_t sendTxDataReq(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo)
+uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
uint8_t nPdu = 0;
uint32_t msgLen = 0;
uint16_t pduIndex = 0;
{
txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen;
}
- if(dlInfo->isRarPres)
+ if(dlInfo->rarAlloc != NULLP)
{
- txDataReqMsgSize += dlInfo->rarAlloc.rarInfo.rarPduLen;
+ txDataReqMsgSize += dlInfo->rarAlloc->rarInfo.rarPduLen;
}
- if(dlInfo->msg4Alloc)
+ if(dlInfo->msg4Alloc != NULLP)
{
txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen;
}
}
memset(txDataReq, 0, txDataReqMsgSize);
- txDataReq->sfn = currTimingInfo->sfn;
- txDataReq->slot = currTimingInfo->slot;
+ txDataReq->sfn = currTimingInfo.sfn;
+ txDataReq->slot = currTimingInfo.slot;
txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \
(sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *)));
pduIndex++;
txDataReq->numPdus++;
}
- if(dlInfo->isRarPres)
+ if(dlInfo->rarAlloc != NULLP)
{
- fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc.\
- rarInfo, &msgLen, pduIndex);
+ fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc->rarInfo, &msgLen, pduIndex);
pduIndex++;
txDataReq->numPdus++;
+
+ MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc));
+ dlInfo->rarAlloc = NULLP;
}
- if(dlInfo->msg4Alloc)
+ if(dlInfo->msg4Alloc != NULLP)
{
fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\
msg4Info, &msgLen, pduIndex);
pduIndex++;
txDataReq->numPdus++;
+
+ MAC_FREE(dlInfo->msg4Alloc,sizeof(Msg4Alloc));
+ dlInfo->msg4Alloc = NULLP;
}
msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t);
fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen);
* Pointer to CurrUlSlot
* @return count
* ********************************************************************/
-#ifdef FAPI
+#ifdef INTEL_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++;
- if(ulTtiReq)
- ulTtiReq->rachPresent = PDU_PRESENT;
- }
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)
+ if(ulTtiReq && currUlSlot)
+ {
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
{
- pduCount++;
- if(ulTtiReq)
- ulTtiReq->nUlsch++;
+ pduCount++;
+ ulTtiReq->rachPresent = PDU_PRESENT;
+ }
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
+ {
+ pduCount++;
+ ulTtiReq->nUlsch++;
}
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
{
pduCount++;
- if(ulTtiReq)
- ulTtiReq->nUlsch = PDU_PRESENT;
+ ulTtiReq->nUlsch = PDU_PRESENT;
}
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI)
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI)
{
pduCount++;
- if(ulTtiReq)
- ulTtiReq->nUlcch = PDU_PRESENT;
+ ulTtiReq->nUlcch = PDU_PRESENT;
}
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS)
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS)
{
pduCount++;
}
void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
uint8_t idx;
if(macCellCfg != NULLP)
{
* Pointer to msgLen
* ********************************************************************/
-#ifdef FAPI
+#ifdef INTEL_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.numPrachOcas = currUlSlot->ulInfo.prachSchInfo.numPrachOcas;
ulTtiReqPdu->u.prach_pdu.prachFormat = \
- currUlSlot->ulCellInfo.prachSchInfo.prachFormat;
- ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa;
+ currUlSlot->ulInfo.prachSchInfo.prachFormat;
+ ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa;
ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \
- currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb;
+ currUlSlot->ulInfo.prachSchInfo.prachStartSymb;
setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg);
ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0;
ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0;
{
ulTtiReqPdu->pduType = PUSCH_PDU_TYPE;
ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1;
- ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulCellInfo.crnti;
+ ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulInfo.crnti;
/* TODO : Fill handle in raCb when scheduling pusch and access here */
ulTtiReqPdu->u.pusch_pdu.handle = 100;
ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308;
ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2;
ulTtiReqPdu->u.pusch_pdu.mcsIndex = \
- currUlSlot->ulCellInfo.schPuschInfo.tbInfo.mcs;
+ currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs;
ulTtiReqPdu->u.pusch_pdu.mcsTable = 0;
ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1;
- ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulCellInfo.cellId;
+ ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId;
ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1;
ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4;
ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0;
- ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulCellInfo.cellId;
+ ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId;
ulTtiReqPdu->u.pusch_pdu.scid = 0;
ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1;
ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0;
ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \
- currUlSlot->ulCellInfo.schPuschInfo.resAllocType;
+ currUlSlot->ulInfo.schPuschInfo.resAllocType;
ulTtiReqPdu->u.pusch_pdu.rbStart = \
- currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.startPrb;
+ currUlSlot->ulInfo.schPuschInfo.fdAlloc.startPrb;
ulTtiReqPdu->u.pusch_pdu.rbSize = \
- currUlSlot->ulCellInfo.schPuschInfo.fdAlloc.numPrb;
+ currUlSlot->ulInfo.schPuschInfo.fdAlloc.numPrb;
ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0;
ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0;
ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0;
ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0;
ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \
- currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.startSymb;
+ currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb;
ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \
- currUlSlot->ulCellInfo.schPuschInfo.tdAlloc.numSymb;
+ currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb;
ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \
- currUlSlot->ulCellInfo.schPuschInfo.tbInfo.rv;
+ currUlSlot->ulInfo.schPuschInfo.tbInfo.rv;
ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \
- currUlSlot->ulCellInfo.schPuschInfo.harqProcId;
+ currUlSlot->ulInfo.schPuschInfo.harqProcId;
ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \
- currUlSlot->ulCellInfo.schPuschInfo.tbInfo.ndi;
+ currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi;
ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \
- currUlSlot->ulCellInfo.schPuschInfo.tbInfo.tbSize;
+ currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize;
/* numCb is 0 for new transmission */
ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0;
sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t)));
}
}
+
+void fillPucchPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg,\
+ MacUlSlot *currUlSlot, uint32_t *msgLen)
+{
+ if(ulTtiReqPdu != NULLP)
+ {
+ ulTtiReqPdu->pduType = PUCCH_PDU_TYPE;
+ ulTtiReqPdu->u.pucch_pdu.rnti = currUlSlot->ulInfo.schPucchInfo.rnti;
+ /* TODO : Fill handle in raCb when scheduling pucch and access here */
+ ulTtiReqPdu->u.pucch_pdu.handle = 100;
+ ulTtiReqPdu->u.pucch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb;
+ ulTtiReqPdu->u.pucch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb;
+ ulTtiReqPdu->u.pucch_pdu.subCarrierSpacing = macCellCfg->initialUlBwp.bwp.scs;
+ ulTtiReqPdu->u.pucch_pdu.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix;
+ ulTtiReqPdu->u.pucch_pdu.formatType = currUlSlot->ulInfo.schPucchInfo.pucchFormat; /* Supporting PUCCH Format 0 */
+ ulTtiReqPdu->u.pucch_pdu.multiSlotTxIndicator = 0; /* No Multi Slot transmission */
+ ulTtiReqPdu->u.pucch_pdu.pi2Bpsk = 0; /* Disabled */
+ ulTtiReqPdu->u.pucch_pdu.prbStart = currUlSlot->ulInfo.schPucchInfo.fdAlloc.startPrb;
+ ulTtiReqPdu->u.pucch_pdu.prbSize = currUlSlot->ulInfo.schPucchInfo.fdAlloc.numPrb;
+ ulTtiReqPdu->u.pucch_pdu.startSymbolIndex = currUlSlot->ulInfo.schPucchInfo.tdAlloc.startSymb;
+ ulTtiReqPdu->u.pucch_pdu.nrOfSymbols = currUlSlot->ulInfo.schPucchInfo.tdAlloc.numSymb;
+ ulTtiReqPdu->u.pucch_pdu.freqHopFlag = 0; /* Disabled */
+ ulTtiReqPdu->u.pucch_pdu.secondHopPrb = 0;
+ ulTtiReqPdu->u.pucch_pdu.groupHopFlag = 0;
+ ulTtiReqPdu->u.pucch_pdu.sequenceHopFlag = 0;
+ ulTtiReqPdu->u.pucch_pdu.hoppingId = 0;
+ ulTtiReqPdu->u.pucch_pdu.initialCyclicShift = 0;
+ ulTtiReqPdu->u.pucch_pdu.dataScramblingId = 0; /* Valid for Format 2, 3, 4 */
+ ulTtiReqPdu->u.pucch_pdu.timeDomainOccIdx = 0; /* Valid for Format 1 */
+ ulTtiReqPdu->u.pucch_pdu.preDftOccIdx = 0; /* Valid for Format 4 */
+ ulTtiReqPdu->u.pucch_pdu.preDftOccLen = 0; /* Valid for Format 4 */
+ ulTtiReqPdu->u.pucch_pdu.addDmrsFlag = 0; /* Valid for Format 3, 4 */
+ ulTtiReqPdu->u.pucch_pdu.dmrsScramblingId = 0; /* Valid for Format 2 */
+ ulTtiReqPdu->u.pucch_pdu.dmrsCyclicShift = 0; /* Valid for Format 4 */
+ ulTtiReqPdu->u.pucch_pdu.srFlag = currUlSlot->ulInfo.schPucchInfo.srFlag;
+ ulTtiReqPdu->u.pucch_pdu.bitLenHarq = currUlSlot->ulInfo.schPucchInfo.numHarqBits;
+ ulTtiReqPdu->u.pucch_pdu.bitLenCsiPart1 = 0; /* Valid for Format 2, 3, 4 */
+ ulTtiReqPdu->u.pucch_pdu.bitLenCsiPart2 = 0; /* Valid for Format 2, 3, 4 */
+ ulTtiReqPdu->u.pucch_pdu.beamforming.numPrgs = 0; /* Not Supported */
+ ulTtiReqPdu->u.pucch_pdu.beamforming.prgSize = 0;
+ ulTtiReqPdu->u.pucch_pdu.beamforming.digBfInterfaces = 0;
+ ulTtiReqPdu->u.pucch_pdu.beamforming.pmi_bfi[0].pmIdx = 0;
+ ulTtiReqPdu->u.pucch_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0;
+
+ ulTtiReqPdu->pduSize = sizeof(fapi_ul_pucch_pdu_t);
+ SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \
+ sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pucch_pdu_t)));
+ }
+}
+
#endif
/*******************************************************************
* RFAILED - failure
*
******************************************************************/
-uint16_t handleUlTtiReq(CmLteTimingInfo *currTimingInfo)
+uint16_t handleUlTtiReq(SlotIndInfo currTimingInfo)
{
-#ifdef FAPI
+#ifdef INTEL_FAPI
uint8_t pduIdx = -1;
uint8_t numPdu = 0;
uint32_t msgLen = 0;
uint32_t msgSize = 0;
fapi_ul_tti_req_t *ulTtiReq = NULLP;
+ SlotIndInfo ulTtiReqTimingInfo;
+
RgCellCb *cellCbParams = NULLP;
MacUlSlot *currUlSlot = NULLP;
MacCellCfg macCellCfg;
Inst inst = 0;
if(clGlobalCp.phyState == PHY_STATE_RUNNING)
- {
- cellCbParams = rgCb[inst].cell;
- macCellCfg = cellCbParams->macCellCfg;
-
- if(currTimingInfo != NULLP)
- {
- currUlSlot = &macCb.macCell->ulSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED];
- numPdu = getnPdus(NULL, currUlSlot);
- msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu * \
- sizeof(fapi_ul_tti_req_pdu_t));
- LWR_MAC_ALLOC(ulTtiReq, msgSize);
+ {
+ cellCbParams = rgCb[inst].cell;
+ macCellCfg = cellCbParams->macCellCfg;
- if(ulTtiReq != NULLP)
- {
- memset(ulTtiReq, 0, msgSize);
- ulTtiReq->sfn = currTimingInfo->sfn;
- ulTtiReq->slot = currTimingInfo->slot;
- ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
- ulTtiReq->nGroup = 0;
- if(ulTtiReq->nPdus > 0)
- {
- ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
- (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
- /* Fill Prach Pdu */
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH)
- {
- pduIdx++;
- fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
- }
+ /* add PHY delta */
+ ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA);
- /* Fill PUSCH PDU */
- if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH)
- {
- pduIdx++;
- fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
- }
+ currUlSlot = &macCb.macCell->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED];
+ numPdu = getnPdus(NULL, currUlSlot);
+ msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu*sizeof(fapi_ul_tti_req_pdu_t));
+ LWR_MAC_ALLOC(ulTtiReq, msgSize);
- if((currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) || \
- (currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH))
- {
- msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
- fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
-
- DU_LOG("\nLWR_MAC: Sending UL TTI Request");
- LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
- }
- }
- else
- {
- msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
- fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
-
- DU_LOG("\nLWR_MAC: Sending UL TTI Request");
- LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
- }
- memset(&currUlSlot, 0, sizeof(MacUlSlot));
- return ROK;
- }
- else
- {
- DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
- memset(&currUlSlot, 0, sizeof(MacUlSlot));
- return RFAILED;
- }
- }
- else
- {
- DU_LOG("\nLWR_MAC: Current TTI Info in UL is NULL");
- return RFAILED;
- }
- }
+ if(ulTtiReq != NULLP)
+ {
+ memset(ulTtiReq, 0, msgSize);
+ ulTtiReq->sfn = ulTtiReqTimingInfo.sfn;
+ ulTtiReq->slot = ulTtiReqTimingInfo.slot;
+ ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot);
+ ulTtiReq->nGroup = 0;
+ if(ulTtiReq->nPdus > 0)
+ {
+ ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \
+ (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*)));
+ /* Fill Prach Pdu */
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH)
+ {
+ pduIdx++;
+ fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+
+ /* Fill PUSCH PDU */
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)
+ {
+ pduIdx++;
+ fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+ /* Fill PUCCH PDU */
+ if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI)
+ {
+ pduIdx++;
+ fillPucchPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+ }
+ if((currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) || \
+ (currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)|| \
+ (currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI))
+ {
+ msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t));
+ fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
+
+ DU_LOG("\nLWR_MAC: Sending UL TTI Request");
+ LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
+ }
+ }
+ else
+ {
+ msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t);
+ fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen);
+
+ DU_LOG("\nLWR_MAC: Sending UL TTI Request");
+ LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq);
+ }
+ memset(currUlSlot, 0, sizeof(MacUlSlot));
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
+ memset(currUlSlot, 0, sizeof(MacUlSlot));
+ return RFAILED;
+ }
+ }
else
{
- lwr_mac_handleInvalidEvt(currTimingInfo);
+ lwr_mac_handleInvalidEvt(&currTimingInfo);
}
#endif
return ROK;
Code Review / o-du / l2.git / blobdiff