/* This file contains message handling functionality for MAC */
-extern MacCb macCb;
+MacCb macCb;
uint16_t buildMacPdu(RlcData *dlData);
#ifdef EGTP_TEST
{
uint16_t cellIdx;
CrcIndInfo crcIndInfo;
- DU_LOG("\nMAC : Received CRC indication");
+ DU_LOG("\nDEBUG --> MAC : Received CRC indication");
GET_CELL_IDX(crcInd->cellId, cellIdx);
/* Considering one pdu and one preamble */
- crcIndInfo.cellId = macCb.macCell[cellIdx]->cellId;;
+ crcIndInfo.cellId = macCb.macCell[cellIdx]->cellId;
crcIndInfo.crnti = crcInd->crcInfo[0].rnti;
crcIndInfo.timingInfo.sfn = crcInd->timingInfo.sfn;
crcIndInfo.timingInfo.slot = crcInd->timingInfo.slot;
crcIndInfo.numCrcInd = crcInd->crcInfo[0].numCb;
crcIndInfo.crcInd[0] = crcInd->crcInfo[0].cbCrcStatus[0];
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, crcInd, sizeof(CrcInd));
return(sendCrcIndMacToSch(&crcIndInfo));
}
uint8_t fapiMacRxDataInd(Pst *pst, RxDataInd *rxDataInd)
{
uint16_t pduIdx;
- DU_LOG("\nMAC : Received Rx Data indication");
+ DU_LOG("\nDEBUG --> MAC : Received Rx Data indication");
/* TODO : compare the handle received in RxDataInd with handle send in PUSCH
* PDU, which is stored in raCb */
for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++)
{
unpackRxData(rxDataInd->cellId, rxDataInd->timingInfo, &rxDataInd->pdus[pduIdx]);
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rxDataInd->pdus[pduIdx].pduData,\
+ rxDataInd->pdus[pduIdx].pduLength);
}
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rxDataInd, sizeof(RxDataInd));
return ROK;
}
* ****************************************************************/
uint8_t MacProcRlcDlData(Pst* pstInfo, RlcData *dlData)
{
- uint8_t pduIdx;
- uint8_t *txPdu;
- uint16_t tbSize;
+ uint8_t pduIdx =0;
+ uint8_t lcIdx = 0;
+ uint8_t *txPdu =NULLP;
+ uint16_t tbSize =0,cellIdx=0;
MacDlData macDlData;
MacDlSlot *currDlSlot = NULLP;
+ DlRlcBoInfo dlBoInfo;
- DU_LOG("\nMAC: Received DL data for sfn=%d slot=%d", \
- dlData->slotInfo.sfn, dlData->slotInfo.slot);
+ 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);
/* Copy the pdus to be muxed into mac Dl data */
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)
{
- if(currDlSlot->dlInfo.dlMsgAlloc)
+ DU_LOG("\nERROR --> MAC : MacProcRlcDlData(): macCell does not exists");
+ return RFAILED;
+ }
+ currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlData->slotInfo.slot];
+ if(currDlSlot->dlInfo.dlMsgAlloc)
+ {
+ tbSize = currDlSlot->dlInfo.dlMsgAlloc->dlMsgPdschCfg.codeword[0].tbSize;
+ MAC_ALLOC(txPdu, tbSize);
+ if(!txPdu)
{
- tbSize = currDlSlot->dlInfo.dlMsgAlloc->dlMsgPdschCfg.codeword[0].tbSize;
- MAC_ALLOC(txPdu, tbSize);
- if(!txPdu)
- {
- DU_LOG("\nMAC : Memory allocation failed in MacProcRlcDlData");
- return RFAILED;
- }
- macMuxPdu(&macDlData, NULLP, txPdu, tbSize);
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcRlcDlData");
+ return RFAILED;
+ }
+ macMuxPdu(&macDlData, NULLP, txPdu, tbSize);
+
+ currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPduLen = tbSize;
+ currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu = txPdu;
+ }
- currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPduLen = tbSize;
- currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu = txPdu;
+ for(lcIdx = 0; lcIdx < dlData->numLc; lcIdx++)
+ {
+ if(dlData->boStatus[lcIdx].bo)
+ {
+ memset(&dlBoInfo, 0, sizeof(DlRlcBoInfo));
+ dlBoInfo.cellId = dlData->boStatus[lcIdx].cellId;
+ GET_CRNTI(dlBoInfo.crnti, dlData->boStatus[lcIdx].ueIdx);
+ dlBoInfo.lcId = dlData->boStatus[lcIdx].lcId;
+ dlBoInfo.dataVolume = dlData->boStatus[lcIdx].bo;
+ sendDlRlcBoInfoToSch(&dlBoInfo);
}
}
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;
}
uint8_t lcId, uint16_t pduLen, uint8_t *pdu)
{
Pst pst;
- RlcData *ulData;
+ RlcData *ulData;
/* Filling RLC Ul Data*/
MAC_ALLOC_SHRABL_BUF(ulData, sizeof(RlcData));
if(!ulData)
{
- DU_LOG("\nMAC : Memory allocation failed while sending UL data to RLC");
+ DU_LOG("\nERROR --> MAC : Memory allocation failed while sending UL data to RLC");
return RFAILED;
}
memset(ulData, 0, sizeof(RlcData));
MAC_ALLOC_SHRABL_BUF(schedRpt, sizeof(RlcSchedResultRpt));
if(!schedRpt)
{
- DU_LOG("\nMAC: Memory allocation failure in sendSchResultRepToRlc");
+ DU_LOG("\nERROR --> MAC: Memory allocation failure in sendSchResultRepToRlc");
return RFAILED;
}
- DU_LOG("\nMAC: Send scheduled result report for sfn %d slot %d", slotInfo.sfn, slotInfo.slot);
+ 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;
FILL_PST_MAC_TO_RLC(pst, RLC_DL_INST, EVENT_SCHED_RESULT_TO_RLC);
if(MacSendSchedResultRptToRlc(&pst, schedRpt) != ROK)
{
- DU_LOG("\nMAC: Failed to send Schedule result report to RLC");
+ DU_LOG("\nERROR --> MAC: Failed to send Schedule result report to RLC");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, schedRpt, sizeof(RlcSchedResultRpt));
return RFAILED;
}
*
* @details
*
- * Function : MacProcCellStartReq
+ * Function : MacProcCellStart
*
* Functionality:
* Handles cell start reuqest from DU APP
*
* @params[in] Post structure pointer
- * Cell Start Request info pointer
+ * Cell Id
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t MacProcCellStartReq(Pst *pst, MacCellStartInfo *cellStartInfo)
+uint8_t MacProcCellStart(Pst *pst, OduCellId *cellId)
{
- DU_LOG("\nMAC : Handling cell start request");
- sendToLowerMac(START_REQUEST, 0, cellStartInfo);
+ DU_LOG("\nINFO --> MAC : Handling cell start request");
+ gSlotCount = 0;
+ sendToLowerMac(START_REQUEST, 0, cellId);
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellStartInfo, \
- sizeof(MacCellStartInfo));
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, \
+ sizeof(OduCellId));
return ROK;
}
/*******************************************************************
*
- * @brief Handles cell stop request from DU APP
+ * @brief Handles cell stop from DU APP
*
* @details
*
- * Function : MacProcCellStartReq
+ * Function : MacProcCellStop
*
* Functionality:
- * Handles cell stop request from DU APP
+ * Handles cell stop from DU APP
*
* @params[in] Post structure pointer
- * Mac Cell stop information
+ * Cell Id
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t MacProcCellStopReq(Pst *pst, MacCellStopInfo *cellStopInfo)
+uint8_t MacProcCellStop(Pst *pst, OduCellId *cellId)
{
#ifdef INTEL_FAPI
- DU_LOG("\nMAC : Sending cell stop request to Lower Mac");
- sendToLowerMac(FAPI_STOP_REQUEST, 0, cellStopInfo);
+ uint16_t cellIdx;
+ SlotIndInfo slotInfo;
+
+ DU_LOG("\nINFO --> MAC : Sending cell stop request to Lower Mac");
+ GET_CELL_IDX(cellId->cellId, cellIdx);
+ if(macCb.macCell[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);
+ }
#endif
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellStopInfo, \
- sizeof(MacCellStopInfo));
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, \
+ sizeof(OduCellId));
return ROK;
}
* ****************************************************************/
uint8_t MacProcDlCcchInd(Pst *pst, DlCcchIndInfo *dlCcchIndInfo)
{
- uint8_t ueIdx = 0;
- uint16_t cellIdx;
- uint16_t idx;
+ uint8_t ueIdx = 0;
+ uint16_t cellIdx;
+ uint16_t idx;
DlRlcBoInfo dlBoInfo;
memset(&dlBoInfo, 0, sizeof(DlRlcBoInfo));
- DU_LOG("\nMAC : Handling DL CCCH IND");
+ DU_LOG("\nDEBUG --> MAC : Handling DL CCCH IND");
GET_CELL_IDX(dlCcchIndInfo->cellId, cellIdx);
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 + 1b byte sub-header) */
+ dlBoInfo.dataVolume = (dlCcchIndInfo->dlCcchMsgLen + 3) + (MAX_CRI_SIZE + 1);
/* storing Msg4 Pdu in raCb */
GET_UE_IDX(dlBoInfo.crnti, ueIdx);
MAC_ALLOC_SHRABL_BUF(ulCcchIndInfo, sizeof(UlCcchIndInfo));
if(!ulCcchIndInfo)
{
- DU_LOG("\nMAC: Memory failed in macProcUlCcchInd");
+ DU_LOG("\nERROR --> MAC: Memory failed in macProcUlCcchInd");
return RFAILED;
}
if(MacDuAppUlCcchInd(&pst, ulCcchIndInfo) != ROK)
{
- DU_LOG("\nMAC: Failed to send UL CCCH Ind to DU APP");
+ DU_LOG("\nERROR --> MAC: Failed to send UL CCCH Ind to DU APP");
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo->ulCcchMsg, ulCcchIndInfo->ulCcchMsgLen);
MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, ulCcchIndInfo, sizeof(UlCcchIndInfo));
ret = RFAILED;
memset(&srUciInd, 0, sizeof(SrUciIndInfo));
GET_CELL_IDX(macUciInd->cellId, cellIdx);
- srUciInd.cellId = macCb.macCell[cellIdx]->cellId;;
+ srUciInd.cellId = macCb.macCell[cellIdx]->cellId;
srUciInd.crnti = crnti;
srUciInd.slotInd.sfn = macUciInd->slotInd.sfn;
srUciInd.slotInd.slot = macUciInd->slotInd.slot;
case UCI_IND_PUCCH_F0F1:
if(macUciInd->pdus[pduIdx].uci.uciPucchF0F1.srInfo.srIndPres)
{
- DU_LOG("\nMAC : Received SR UCI indication");
+ DU_LOG("\nDEBUG --> MAC : Received SR UCI indication");
crnti = macUciInd->pdus[pduIdx].uci.uciPucchF0F1.crnti;
ret = buildAndSendSrInd(macUciInd, crnti);
}
case UCI_IND_PUCCH_F2F3F4:
break;
default:
- DU_LOG("\nMAC: Invalid Pdu Type %d at FapiMacUciInd", macUciInd->pdus[pduIdx].pduType);
+ DU_LOG("\nERROR --> MAC: Invalid Pdu Type %d at FapiMacUciInd", macUciInd->pdus[pduIdx].pduType);
ret = RFAILED;
break;
}
}
else
{
- DU_LOG("\nMAC: Received Uci Ind is NULL at FapiMacUciInd()");
+ DU_LOG("\nERROR --> MAC: Received Uci Ind is NULL at FapiMacUciInd()");
ret = RFAILED;
}
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macUciInd, sizeof(UciInd));
return ret;
}
Code Review / o-du / l2.git / blobdiff