MacCb macCb;
-uint16_t buildMacPdu(RlcData *dlData);
-#ifdef EGTP_TEST
-void macStubBuildUlData(Buffer *mBuf);
-#endif
-
/* Function pointer for sending crc ind from MAC to SCH */
MacSchCrcIndFunc macSchCrcIndOpts[]=
{
packMacSchSrUciInd
};
+/* Function pointer for sending Slice cfg ind from MAC to SCH */
+MacSchSliceCfgReqFunc macSchSliceCfgReqOpts[]=
+{
+ packMacSchSliceCfgReq,
+ MacSchSliceCfgReq,
+ packMacSchSliceCfgReq
+};
+
+/* Function pointer for sending Slice cfg ind from MAC to SCH */
+MacSchSliceReCfgReqFunc macSchSliceReCfgReqOpts[]=
+{
+ packMacSchSliceReCfgReq,
+ MacSchSliceReCfgReq,
+ packMacSchSliceReCfgReq
+};
/*******************************************************************
*
* @brief Sends DL BO Info to SCH
* ****************************************************************/
uint8_t MacProcRlcDlData(Pst* pstInfo, RlcData *dlData)
{
- uint8_t pduIdx =0;
- uint8_t lcIdx = 0;
- uint8_t *txPdu =NULLP;
- uint16_t tbSize =0;
- MacDlData macDlData;
- MacDlSlot *currDlSlot = NULLP;
- DlRlcBoInfo dlBoInfo;
-
+ uint8_t pduIdx = 0;
+ uint8_t ueId = 0;
+ uint8_t lcIdx = 0;
+ uint8_t *txPdu = NULLP;
+ uint8_t schInfoIdx = 0 ;
+ uint16_t cellIdx = 0, txPduLen = 0;
+ MacDlData macDlData;
+ MacDlSlot *currDlSlot = NULLP;
+ DlRlcBoInfo dlBoInfo;
+
memset(&macDlData , 0, sizeof(MacDlData));
DU_LOG("\nDEBUG --> MAC: Received DL data for sfn=%d slot=%d numPdu= %d", \
dlData->slotInfo.sfn, dlData->slotInfo.slot, dlData->numPdu);
+
+ GET_UE_ID(dlData->rnti, ueId);
+
/* Copy the pdus to be muxed into mac Dl data */
+ macDlData.ueId = ueId;
macDlData.numPdu = dlData->numPdu;
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
macDlData.pduInfo[pduIdx].dlPdu = dlData->pduInfo[pduIdx].pduBuf;
}
+ GET_CELL_IDX(dlData->cellId, cellIdx);
/* Store DL data in the scheduled slot */
- currDlSlot = &macCb.macCell[dlData->cellId -1]->dlSlot[dlData->slotInfo.slot];
- if(currDlSlot)
+ if(macCb.macCell[cellIdx] ==NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : MacProcRlcDlData(): macCell does not exists");
+ return RFAILED;
+ }
+ currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlData->slotInfo.slot];
+ if(currDlSlot->dlInfo.dlMsgAlloc[ueId-1])
{
- if(currDlSlot->dlInfo.dlMsgAlloc)
+ for(schInfoIdx=0; schInfoIdx<currDlSlot->dlInfo.dlMsgAlloc[ueId-1]->numSchedInfo; schInfoIdx++)
{
- tbSize = currDlSlot->dlInfo.dlMsgAlloc->dlMsgPdschCfg.codeword[0].tbSize;
- MAC_ALLOC(txPdu, tbSize);
- if(!txPdu)
- {
- DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcRlcDlData");
- return RFAILED;
- }
- macMuxPdu(&macDlData, NULLP, txPdu, tbSize);
+ if((currDlSlot->dlInfo.dlMsgAlloc[ueId-1]->dlMsgSchedInfo[schInfoIdx].pduPres == PDSCH_PDU) ||
+ (currDlSlot->dlInfo.dlMsgAlloc[ueId-1]->dlMsgSchedInfo[schInfoIdx].pduPres == BOTH))
+ break;
+ }
- currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPduLen = tbSize;
- currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu = txPdu;
+ txPduLen = currDlSlot->dlInfo.dlMsgAlloc[ueId-1]->dlMsgSchedInfo[schInfoIdx].dlMsgPdschCfg.codeword[0].tbSize\
+ - TX_PAYLOAD_HDR_LEN;
+ MAC_ALLOC(txPdu, txPduLen);
+ if(!txPdu)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcRlcDlData");
+ return RFAILED;
}
+ macMuxPdu(&macDlData, NULLP, txPdu, txPduLen);
+
+ currDlSlot->dlInfo.dlMsgAlloc[ueId-1]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPduLen = txPduLen;
+ currDlSlot->dlInfo.dlMsgAlloc[ueId-1]->dlMsgSchedInfo[schInfoIdx].dlMsgInfo.dlMsgPdu = txPdu;
}
for(lcIdx = 0; lcIdx < dlData->numLc; lcIdx++)
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
MAC_FREE_SHRABL_BUF(pstInfo->region, pstInfo->pool, dlData->pduInfo[pduIdx].pduBuf,\
- dlData->pduInfo[pduIdx].pduLen);
+ dlData->pduInfo[pduIdx].pduLen);
}
if(pstInfo->selector == ODU_SELECTOR_LWLC)
{
MAC_FREE_SHRABL_BUF(pstInfo->region, pstInfo->pool, dlData, sizeof(RlcData));
}
-
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t macProcUlData(uint16_t cellId, uint16_t rnti, SlotIndInfo slotInfo, \
+uint8_t macProcUlData(uint16_t cellId, uint16_t rnti, SlotTimingInfo slotInfo, \
uint8_t lcId, uint16_t pduLen, uint8_t *pdu)
{
Pst pst;
memset(ulData, 0, sizeof(RlcData));
ulData->cellId = cellId;
ulData->rnti = rnti;
- memcpy(&ulData->slotInfo, &slotInfo, sizeof(SlotIndInfo));
+ memcpy(&ulData->slotInfo, &slotInfo, sizeof(SlotTimingInfo));
ulData->slotInfo.cellId = cellId;
/* Filling pdu info */
GET_CRNTI(dlBoInfo.crnti, boStatus->ueIdx);
dlBoInfo.lcId = boStatus->lcId;
dlBoInfo.dataVolume = boStatus->bo;
-
+
sendDlRlcBoInfoToSch(&dlBoInfo);
if(pst->selector == ODU_SELECTOR_LWLC)
* RFAILED - failure
*
* ****************************************************************/
-uint8_t sendSchedRptToRlc(DlSchedInfo dlInfo, SlotIndInfo slotInfo)
+uint8_t sendSchedRptToRlc(DlSchedInfo dlInfo, SlotTimingInfo slotInfo, uint8_t ueIdx, uint8_t schInfoIdx)
{
Pst pst;
uint8_t lcIdx;
DU_LOG("\nDEBUG --> MAC: Send scheduled result report for sfn %d slot %d", slotInfo.sfn, slotInfo.slot);
schedRpt->cellId = dlInfo.cellId;
- schedRpt->rnti = dlInfo.dlMsgAlloc->crnti;
- schedRpt->numLc = dlInfo.dlMsgAlloc->numLc;
schedRpt->slotInfo.sfn = slotInfo.sfn;
schedRpt->slotInfo.slot = slotInfo.slot;
- for(lcIdx = 0; lcIdx < schedRpt->numLc; lcIdx++)
+ if(dlInfo.dlMsgAlloc[ueIdx])
{
- schedRpt->lcSch[lcIdx].lcId = dlInfo.dlMsgAlloc->lcSchInfo[lcIdx].lcId;
- schedRpt->lcSch[lcIdx].bufSize = dlInfo.dlMsgAlloc->lcSchInfo[lcIdx].schBytes;
- schedRpt->lcSch[lcIdx].commCh = false;
+ schedRpt->rnti = dlInfo.dlMsgAlloc[ueIdx]->crnti;
+ schedRpt->numLc = dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].numLc;
+ for(lcIdx = 0; lcIdx < schedRpt->numLc; lcIdx++)
+ {
+ schedRpt->lcSch[lcIdx].lcId = dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].lcSchInfo[lcIdx].lcId;
+ schedRpt->lcSch[lcIdx].bufSize = dlInfo.dlMsgAlloc[ueIdx]->dlMsgSchedInfo[schInfoIdx].lcSchInfo[lcIdx].schBytes;
+ schedRpt->lcSch[lcIdx].commCh = false;
+ }
}
/* Fill Pst */
{
#ifdef INTEL_FAPI
uint16_t cellIdx;
- SlotIndInfo slotInfo;
DU_LOG("\nINFO --> MAC : Sending cell stop request to Lower Mac");
GET_CELL_IDX(cellId->cellId, cellIdx);
- slotInfo.cellId = cellId->cellId;
- slotInfo.sfn = macCb.macCell[cellIdx]->currTime.sfn;
- slotInfo.slot = macCb.macCell[cellIdx]->currTime.slot;
- sendToLowerMac(FAPI_STOP_REQUEST, 0, &slotInfo);
+ if(macCb.macCell[cellIdx])
+ {
+ macCb.macCell[cellIdx]->state = CELL_TO_BE_STOPPED;
+ }
#endif
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, \
* ****************************************************************/
uint8_t MacProcDlCcchInd(Pst *pst, DlCcchIndInfo *dlCcchIndInfo)
{
- uint8_t ueIdx = 0;
+ uint8_t ueId = 0, ueIdx = 0;
uint16_t cellIdx;
uint16_t idx;
DlRlcBoInfo dlBoInfo;
if(dlCcchIndInfo->msgType == RRC_SETUP)
{
dlBoInfo.lcId = SRB0_LCID; // SRB ID 0 for msg4
- dlBoInfo.dataVolume = dlCcchIndInfo->dlCcchMsgLen;
+ /* (MSG4 pdu + 3 bytes sub-header) + (Contention resolution id MAC CE + 1 byte sub-header) */
+ dlBoInfo.dataVolume = (dlCcchIndInfo->dlCcchMsgLen + 3) + (MAX_CRI_SIZE + 1);
/* storing Msg4 Pdu in raCb */
- GET_UE_IDX(dlBoInfo.crnti, ueIdx);
- ueIdx = ueIdx -1;
+ GET_UE_ID(dlBoInfo.crnti, ueId);
+ ueIdx = ueId -1;
if(macCb.macCell[cellIdx]->macRaCb[ueIdx].crnti == dlCcchIndInfo->crnti)
{
macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4PduLen = dlCcchIndInfo->dlCcchMsgLen;
* lcg ID
* buffer size
*
+ * @return ROK - success
+ * RFAILED - failure
*
* ****************************************************************/
uint8_t macProcShortBsr(uint16_t cellId, uint16_t crnti, uint8_t lcgId, uint32_t bufferSize)
return(*macSchBsrOpts[pst.selector])(&pst, &bsrInd);
}
+/*******************************************************************
+ *
+ * @brief Processes received short BSR
+ *
+ * @details
+ *
+ * Function : macProcShortBsr
+ *
+ * Functionality:
+ * MAC sends Short BSR to SCH
+ *
+ * @params[in] cell ID
+ * crnti
+ * lcg ID
+ * buffer size
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t macProcLongBsr(uint16_t cellId, uint16_t crnti,uint8_t numLcg,\
+ DataVolInfo dataVolInfo[MAX_NUM_LOGICAL_CHANNEL_GROUPS])
+{
+ Pst pst;
+ UlBufferStatusRptInd bsrInd;
+ uint8_t lcgIdx = 0;
+
+ memset(&pst, 0, sizeof(Pst));
+ memset(&bsrInd, 0, sizeof(UlBufferStatusRptInd));
+
+ bsrInd.cellId = cellId;
+ bsrInd.crnti = crnti;
+ bsrInd.bsrType = LONG_BSR;
+ bsrInd.numLcg = numLcg;
+
+ for(lcgIdx = 0; lcgIdx < numLcg; lcgIdx++)
+ memcpy(&(bsrInd.dataVolInfo[lcgIdx]), &(dataVolInfo[lcgIdx]), sizeof(DataVolInfo));
+
+ FILL_PST_MAC_TO_SCH(pst, EVENT_LONG_BSR);
+ return(*macSchBsrOpts[pst.selector])(&pst, &bsrInd);
+}
+
/*******************************************************************
*
* @brief Builds and send SR UCI Indication to SCH
return ret;
}
+/*******************************************************************
+ *
+ * @brief fill Slice Cfg Request info in shared structre
+ *
+ * @details
+ *
+ * Function : fillSliceCfgInfo
+ *
+ * Functionality:
+ * fill Slice Cfg Request info in shared structre
+ *
+ * @params[in] SchSliceCfgReq *schSliceCfgReq
+ * MacSliceCfgReq *macSliceCfgReq;
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+ uint8_t fillSliceCfgInfo(SchSliceCfgReq *schSliceCfgReq, MacSliceCfgReq *macSliceCfgReq)
+ {
+ uint8_t cfgIdx = 0;
+
+ if(macSliceCfgReq->listOfSliceCfg)
+ {
+ schSliceCfgReq->numOfConfiguredSlice = macSliceCfgReq->numOfConfiguredSlice;
+ MAC_ALLOC(schSliceCfgReq->listOfConfirguration, schSliceCfgReq->numOfConfiguredSlice *sizeof(SchRrmPolicyOfSlice*));
+ if(schSliceCfgReq->listOfConfirguration == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
+ return RFAILED;
+ }
+ for(cfgIdx = 0; cfgIdx<schSliceCfgReq->numOfConfiguredSlice; cfgIdx++)
+ {
+ MAC_ALLOC(schSliceCfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice));
+ if(schSliceCfgReq->listOfConfirguration[cfgIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
+ return RFAILED;
+ }
+
+ memcpy(&schSliceCfgReq->listOfConfirguration[cfgIdx]->snssai, &macSliceCfgReq->listOfSliceCfg[cfgIdx]->snssai, sizeof(Snssai));
+
+ if(macSliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio)
+ {
+ MAC_ALLOC(schSliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio));
+ if(schSliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in fillSliceCfgInfo");
+ return RFAILED;
+ }
+ schSliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo->policyMaxRatio = macSliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMaxRatio;
+ schSliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo->policyMinRatio = macSliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMinRatio;
+ schSliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo->policyDedicatedRatio = macSliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyDedicatedRatio;
+ }
+ }
+ }
+ return ROK;
+ }
+/*******************************************************************
+ *
+ * @brief Processes Slice Cfg Request recived from DU
+ *
+ * @details
+ *
+ * Function : MacProcSliceCfgReq
+ *
+ * Functionality:
+ * Processes Processes Slice Cfg Request recived from DU
+ *
+ * @params[in] Post Structure Pointer
+ * MacSliceCfgReq *macSliceCfgReq;
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+uint8_t MacProcSliceCfgReq(Pst *pst, MacSliceCfgReq *macSliceCfgReq)
+{
+ uint8_t ret = ROK;
+ Pst schPst;
+ SchSliceCfgReq *schSliceCfgReq;
+
+ DU_LOG("\nINFO --> MAC : Received Slice Cfg request from DU APP");
+ if(macSliceCfgReq)
+ {
+ MAC_ALLOC(schSliceCfgReq, sizeof(SchSliceCfgReq));
+ if(schSliceCfgReq == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcSliceCfgReq");
+ ret = RFAILED;
+ }
+ else
+ {
+ if(fillSliceCfgInfo(schSliceCfgReq, macSliceCfgReq) == ROK)
+ {
+ FILL_PST_MAC_TO_SCH(schPst, EVENT_SLICE_CFG_REQ_TO_SCH);
+ ret = (*macSchSliceCfgReqOpts[schPst.selector])(&schPst, schSliceCfgReq);
+ }
+ }
+ freeMacSliceCfgReq(macSliceCfgReq, pst);
+ }
+ else
+ {
+ DU_LOG("\nINFO --> MAC : Received MacSliceCfgReq is NULL");
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Processes Slice ReCfg Request recived from DU
+ *
+ * @details
+ *
+ * Function : MacProcSliceReCfgReq
+ *
+ * Functionality:
+ * Processes Processes Slice ReCfg Request recived from DU
+ *
+ * @params[in] Post Structure Pointer
+ * MacSliceCfgReq *macSliceReCfgReq;
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ **********************************************************************/
+uint8_t MacProcSliceReCfgReq(Pst *pst, MacSliceCfgReq *macSliceReCfgReq)
+{
+ uint8_t ret = ROK;
+ Pst schPst;
+ SchSliceCfgReq *schSliceReCfgReq;
+
+ DU_LOG("\nINFO --> MAC : Received Slice ReCfg request from DU APP");
+ if(macSliceReCfgReq)
+ {
+ MAC_ALLOC(schSliceReCfgReq, sizeof(SchSliceCfgReq));
+ if(schSliceReCfgReq == NULLP)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcSliceReCfgReq");
+ ret = RFAILED;
+ }
+ else
+ {
+ if(fillSliceCfgInfo(schSliceReCfgReq, macSliceReCfgReq) == ROK)
+ {
+ FILL_PST_MAC_TO_SCH(schPst, EVENT_SLICE_RECFG_REQ_TO_SCH);
+ ret = (*macSchSliceReCfgReqOpts[schPst.selector])(&schPst, schSliceReCfgReq);
+ }
+
+ }
+ freeMacSliceCfgReq(macSliceReCfgReq, pst);
+ }
+ else
+ {
+ DU_LOG("\nINFO --> MAC : Received MacSliceCfgReq is NULL");
+ }
+ return ret;
+}
/**********************************************************************
End of file
Code Review / o-du / l2.git / blobdiff