packDuMacSliceCfgRsp /* packing for light weight loosly coupled */
};
-MacDuSliceReCfgRspFunc macDuSliceReCfgRspOpts[] =
+MacDuSliceRecfgRspFunc macDuSliceRecfgRspOpts[] =
{
- packDuMacSliceReCfgRsp, /* packing for loosely coupled */
- DuProcMacSliceReCfgRsp, /* packing for tightly coupled */
- packDuMacSliceReCfgRsp /* packing for light weight loosly coupled */
+ packDuMacSliceRecfgRsp, /* packing for loosely coupled */
+ DuProcMacSliceRecfgRsp, /* packing for tightly coupled */
+ packDuMacSliceRecfgRsp /* packing for light weight loosly coupled */
};
MacSchPagingIndFunc macSchPagingIndOpts[] =
*
* ****************************************************************/
-uint8_t sendCellDelReqToSch(SchCellDelete *schCellDel)
+uint8_t sendCellDelReqToSch(SchCellDeleteReq *schCellDelReq)
{
Pst schPst;
FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
- return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDel);
+ return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDelReq);
}
/*******************************************************************
*
*
* ****************************************************************/
-uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
+uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete)
{
uint8_t ret = ROK, cellIdx=0;
- SchCellDelete schCellDelete;
+ SchCellDeleteReq schCellDelete;
DU_LOG("\nINFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
{
if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
{
- memset(&schCellDelete, 0, sizeof(SchCellDelete));
+ memset(&schCellDelete, 0, sizeof(SchCellDeleteReq ));
schCellDelete.cellId = cellDelete->cellId;
ret = sendCellDelReqToSch(&schCellDelete);
if(ret != ROK)
}
}
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDelete));
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDeleteReq));
}
else
{
*
* sends slice cfg response to duapp
*
-* @param[in] MacSliceCfgRsp macSliceRecfgRsp
+* @param[in] MacSliceRecfgRsp macSliceRecfgRsp
* @return int
* -# ROK
**/
-uint8_t MacSendSliceReconfigRsp(MacSliceCfgRsp *macSliceRecfgRsp)
+uint8_t MacSendSliceReconfigRsp(MacSliceRecfgRsp *macSliceRecfgRsp)
{
Pst rspPst;
memset(&rspPst, 0, sizeof(Pst));
FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP);
- return (*macDuSliceReCfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
+ return (*macDuSliceRecfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
}
*
* @details
*
- * Function : MacProcSchSliceReCfgRsp
+ * Function : MacProcSchSliceRecfgRsp
*
* This function process the slice cfg rsp received from sch
*
* @return int
* -# ROK
**/
-uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceRecfgRsp)
+uint8_t MacProcSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *schSliceRecfgRsp)
{
- MacSliceCfgRsp *macSliceReCfgRsp = NULLP;
+ MacSliceRecfgRsp *macSliceRecfgRsp = NULLP;
if(schSliceRecfgRsp)
{
- MAC_ALLOC_SHRABL_BUF(macSliceReCfgRsp, sizeof(MacSliceCfgRsp));
- if(macSliceReCfgRsp == NULLP)
+ MAC_ALLOC_SHRABL_BUF(macSliceRecfgRsp, sizeof(MacSliceRecfgRsp));
+ if(macSliceRecfgRsp == NULLP)
{
- DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceReCfgRsp");
+ DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceRecfgRsp");
return RFAILED;
}
if(schSliceRecfgRsp->listOfSliceCfgRsp)
{
- if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceReCfgRsp) != ROK)
+ if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceRecfgRsp) != ROK)
{
DU_LOG("\nERROR --> MAC : Failed to fill the slice Recfg response");
return RFAILED;
}
- MacSendSliceReconfigRsp(macSliceReCfgRsp);
+ MacSendSliceReconfigRsp(macSliceRecfgRsp);
}
freeSchSliceCfgRsp(schSliceRecfgRsp);
}
* This function process the downlink pcch indication received from DUAPP
*
* @param[in] Pst *pst
- * @param[in] MacPcchInd *pcchInd
+ * @param[in] DlPcchInd *pcchInd
* @return int
* -# ROK
**/
-uint8_t MacProcDlPcchInd(Pst *pst, MacPcchInd *pcchInd)
+uint8_t MacProcDlPcchInd(Pst *pst, DlPcchInd *pcchInd)
{
uint8_t ret = RFAILED;
uint16_t cellIdx = 0;
{
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd->pcchPdu, pcchInd->pduLen);
}
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(MacPcchInd));
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(DlPcchInd));
}
else
{
packMacSchSrUciInd
};
-/* Function pointer for sending HARQ Uci ind from MAC to SCH */
-MacSchHarqUciIndFunc macSchHarqUciIndOpts[]=
+/* Function pointer for sending DL HARQ Ind from MAC to SCH */
+MacSchDlHarqIndFunc macSchDlHarqIndOpts[]=
{
- packMacSchHarqUciInd,
- MacSchHarqUciInd,
- packMacSchHarqUciInd
+ packMacSchDlHarqInd,
+ MacSchDlHarqInd,
+ packMacSchDlHarqInd
};
/* Function pointer for sending Slice cfg ind from MAC to SCH */
};
/* Function pointer for sending Slice cfg ind from MAC to SCH */
-MacSchSliceReCfgReqFunc macSchSliceReCfgReqOpts[]=
+MacSchSliceRecfgReqFunc macSchSliceRecfgReqOpts[]=
{
- packMacSchSliceReCfgReq,
- MacSchSliceReCfgReq,
- packMacSchSliceReCfgReq
+ packMacSchSliceRecfgReq,
+ MacSchSliceRecfgReq,
+ packMacSchSliceRecfgReq
};
/*******************************************************************
*
* RFAILED - failure
*
* ****************************************************************/
-uint8_t MacProcCellStart(Pst *pst, OduCellId *cellId)
+uint8_t MacProcCellStart(Pst *pst, CellStartInfo *cellStart)
{
DU_LOG("\nINFO --> MAC : Handling cell start request");
gSlotCount = 0;
- sendToLowerMac(START_REQUEST, 0, cellId);
+ sendToLowerMac(START_REQUEST, 0, cellStart);
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, \
- sizeof(OduCellId));
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellStart, \
+ sizeof(CellStartInfo));
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t MacProcCellStop(Pst *pst, OduCellId *cellId)
+uint8_t MacProcCellStop(Pst *pst, CellStopInfo *cellStop)
{
#ifdef INTEL_FAPI
uint16_t cellIdx;
DU_LOG("\nINFO --> MAC : Sending cell stop request to Lower Mac");
- GET_CELL_IDX(cellId->cellId, cellIdx);
+ GET_CELL_IDX(cellStop->cellId, cellIdx);
if(macCb.macCell[cellIdx])
{
macCb.macCell[cellIdx]->state = CELL_TO_BE_STOPPED;
}
#endif
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, \
- sizeof(OduCellId));
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellStop, \
+ sizeof(CellStopInfo));
return ROK;
}
/*******************************************************************
*
- * @brief Builds and send HARQ UCI Indication to SCH
+ * @brief Builds and send DL HARQ Indication to SCH
*
* @details
*
{
uint16_t harqCounter=0;
Pst pst;
- HarqUciIndInfo harqUciInd;
+ DlHarqInd dlHarqInd;
memset(&pst, 0, sizeof(Pst));
- memset(&harqUciInd, 0, sizeof(HarqUciIndInfo));
-
- harqUciInd.cellId = macCb.macCell[cellIdx]->cellId;
- harqUciInd.crnti = crnti;
- harqUciInd.slotInd.sfn = slotInd->sfn;
- harqUciInd.slotInd.slot = slotInd->slot;
- harqUciInd.numHarq = harqInfo->numHarq;
- memset(harqUciInd.harqPayload, 0, MAX_SR_BITS_IN_BYTES);
+ memset(&dlHarqInd, 0, sizeof(DlHarqInd));
+
+ dlHarqInd.cellId = macCb.macCell[cellIdx]->cellId;
+ dlHarqInd.crnti = crnti;
+ dlHarqInd.slotInd.sfn = slotInd->sfn;
+ dlHarqInd.slotInd.slot = slotInd->slot;
+ dlHarqInd.numHarq = harqInfo->numHarq;
+ memset(dlHarqInd.harqPayload, 0, MAX_SR_BITS_IN_BYTES);
for(harqCounter = 0; harqCounter < harqInfo->numHarq; harqCounter++)
{
- harqUciInd.harqPayload[harqCounter] = harqInfo->harqValue[harqCounter];
+ dlHarqInd.harqPayload[harqCounter] = harqInfo->harqValue[harqCounter];
}
/* Fill Pst */
- FILL_PST_MAC_TO_SCH(pst, EVENT_UCI_IND_TO_SCH);
+ FILL_PST_MAC_TO_SCH(pst, EVENT_DL_HARQ_IND_TO_SCH);
- return(*macSchHarqUciIndOpts[pst.selector])(&pst, &harqUciInd);
+ return(*macSchDlHarqIndOpts[pst.selector])(&pst, &dlHarqInd);
}
*
* @details
*
- * Function : MacProcSliceReCfgReq
+ * Function : MacProcSliceRecfgReq
*
* Functionality:
* Processes Processes Slice ReCfg Request recived from DU
*
* @params[in] Post Structure Pointer
- * MacSliceCfgReq *macSliceReCfgReq;
+ * MacSliceCfgReq *macSliceRecfgReq;
* @return ROK - success
* RFAILED - failure
*
**********************************************************************/
-uint8_t MacProcSliceReCfgReq(Pst *pst, MacSliceCfgReq *macSliceReCfgReq)
+uint8_t MacProcSliceRecfgReq(Pst *pst, MacSliceRecfgReq *macSliceRecfgReq)
{
uint8_t ret = ROK;
Pst schPst;
- SchSliceCfgReq *schSliceReCfgReq;
+ SchSliceRecfgReq *schSliceRecfgReq;
DU_LOG("\nINFO --> MAC : Received Slice ReCfg request from DU APP");
- if(macSliceReCfgReq)
+ if(macSliceRecfgReq)
{
- MAC_ALLOC(schSliceReCfgReq, sizeof(SchSliceCfgReq));
- if(schSliceReCfgReq == NULLP)
+ MAC_ALLOC(schSliceRecfgReq, sizeof(SchSliceRecfgReq));
+ if(schSliceRecfgReq == NULLP)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcSliceReCfgReq");
+ DU_LOG("\nERROR --> MAC : Memory allocation failed in MacProcSliceRecfgReq");
ret = RFAILED;
}
else
{
- if(fillSliceCfgInfo(schSliceReCfgReq, macSliceReCfgReq) == ROK)
+ if(fillSliceCfgInfo(schSliceRecfgReq, macSliceRecfgReq) == ROK)
{
FILL_PST_MAC_TO_SCH(schPst, EVENT_SLICE_RECFG_REQ_TO_SCH);
- ret = (*macSchSliceReCfgReqOpts[schPst.selector])(&schPst, schSliceReCfgReq);
+ ret = (*macSchSliceRecfgReqOpts[schPst.selector])(&schPst, schSliceRecfgReq);
}
}
- freeMacSliceCfgReq(macSliceReCfgReq, pst);
+ freeMacSliceCfgReq(macSliceRecfgReq, pst);
}
else
{
- DU_LOG("\nINFO --> MAC : Received MacSliceCfgReq is NULL");
+ DU_LOG("\nINFO --> MAC : Received MacSliceRecfgReq is NULL");
}
return ret;
}
case EVENT_MAC_SLICE_RECFG_REQ:
{
/* Process Slice Reconfiguration Request */
- unpackMacSliceCfgReq(MacProcSliceReCfgReq, pst, mBuf);
+ unpackMacSliceRecfgReq(MacProcSliceRecfgReq, pst, mBuf);
break;
}
case EVENT_MAC_RACH_RESOURCE_REQ:
};
-SchSliceReCfgRspFunc SchSliceReCfgRspOpts[] =
+SchSliceRecfgRspFunc SchSliceRecfgRspOpts[] =
{
- packSchSliceReCfgRsp, /* LC */
- MacProcSchSliceReCfgRsp, /* TC */
- packSchSliceReCfgRsp /* LWLC */
+ packSchSliceRecfgRsp, /* LC */
+ MacProcSchSliceRecfgRsp, /* TC */
+ packSchSliceRecfgRsp /* LWLC */
};
/**
/*******************************************************************
*
- * @brief Processes HARQ UCI indication from MAC
+ * @brief Processes DL HARQ indication from MAC
*
* @details
*
- * Function : MacSchHarqUciInd
+ * Function : MacSchDlHarqInd
*
* Functionality:
- * Processes HARQ UCI indication from MAC
+ * Processes DL HARQ indication from MAC
*
* @params[in] Post structure
- * UCI Indication
+ * DL HARQ Indication
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t MacSchHarqUciInd(Pst *pst, HarqUciIndInfo *uciInd)
+uint8_t MacSchDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd)
{
Inst inst = pst->dstInst-SCH_INST_START;
SchUeCb *ueCb;
SchCellCb *cellCb = schCb[inst].cells[inst];
#ifdef CALL_FLOW_DEBUG_LOG
- DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UCI_IND_TO_SCH\n");
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_HARQ_IND_TO_SCH\n");
#endif
DU_LOG("\nDEBUG --> SCH : Received HARQ");
- ueCb = schGetUeCb(cellCb, uciInd->crnti);
+ ueCb = schGetUeCb(cellCb, dlHarqInd->crnti);
if(ueCb->state == SCH_UE_STATE_INACTIVE)
{
- DU_LOG("\nERROR --> SCH : Crnti %d is inactive", uciInd->crnti);
+ DU_LOG("\nERROR --> SCH : Crnti %d is inactive", dlHarqInd->crnti);
return ROK;
}
- schUpdateHarqFdbk(ueCb, uciInd->numHarq, uciInd->harqPayload, &uciInd->slotInd);
+ schUpdateHarqFdbk(ueCb, dlHarqInd->numHarq, dlHarqInd->harqPayload, &dlHarqInd->slotInd);
return ROK;
}
* RFAILED - Failure
*
* ********************************************************************************/
-uint8_t fillSliceCfgRsp(bool sliceReCfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count)
+uint8_t fillSliceCfgRsp(bool sliceRecfg, SchSliceCfg *storedSliceCfg, SchCellCb *cellCb, SchSliceCfgReq *schSliceCfgReq, SchSliceCfgRsp *schSliceCfgRsp, uint8_t *count)
{
bool sliceFound = false;
uint8_t cfgIdx = 0, sliceIdx = 0;
{
sliceFound = false;
/* Here comparing the slice cfg request with the slice stored in cellCfg */
- if(sliceReCfg != true)
+ if(sliceRecfg != true)
{
for(sliceIdx = 0; sliceIdx<cellCb->cellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
{
* ROK - Success
* RFAILED - Failure
* ********************************************************************************/
-void freeSchSliceCfgReq(SchSliceCfgReq *cfgReq)
+void freeSchSliceCfgReq(SchSliceCfgReq *sliceCfgReq)
{
uint8_t cfgIdx = 0;
- if(cfgReq)
+ if(sliceCfgReq)
{
- if(cfgReq->numOfConfiguredSlice)
+ if(sliceCfgReq->numOfConfiguredSlice)
{
- for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
+ for(cfgIdx = 0; cfgIdx<sliceCfgReq->numOfConfiguredSlice; cfgIdx++)
{
- if(cfgReq->listOfConfirguration[cfgIdx])
+ if(sliceCfgReq->listOfConfirguration[cfgIdx])
{
- SCH_FREE(cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio));
- SCH_FREE(cfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice));
+ SCH_FREE(sliceCfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo, sizeof(SchRrmPolicyRatio));
+ SCH_FREE(sliceCfgReq->listOfConfirguration[cfgIdx], sizeof(SchRrmPolicyOfSlice));
}
}
- SCH_FREE(cfgReq->listOfConfirguration, cfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*));
+ SCH_FREE(sliceCfgReq->listOfConfirguration, sliceCfgReq->numOfConfiguredSlice * sizeof(SchRrmPolicyOfSlice*));
}
- SCH_FREE(cfgReq, sizeof(SchSliceCfgReq));
+ SCH_FREE(sliceCfgReq, sizeof(SchSliceCfgReq));
}
}
/*******************************************************************************
* RFAILED - Failure
*
* ********************************************************************************/
-uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, SchSliceCfgRsp cfgRsp, uint8_t count)
+uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceRecfgReq *recfgReq, SchSliceRecfgRsp recfgRsp, uint8_t count)
{
uint8_t cfgIdx = 0, sliceIdx = 0;
return RFAILED;
}
- for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
+ for(cfgIdx = 0; cfgIdx<recfgReq->numOfConfiguredSlice; cfgIdx++)
{
- if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
+ if(recfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
{
for(sliceIdx = 0; sliceIdx<storeSliceCfg->numOfSliceConfigured; sliceIdx++)
{
- if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &cfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai)))
+ if(!memcmp(&storeSliceCfg->listOfConfirguration[sliceIdx]->snssai, &recfgReq->listOfConfirguration[cfgIdx]->snssai, sizeof(Snssai)))
{
- memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, cfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo,
+ memcpy(storeSliceCfg->listOfConfirguration[sliceIdx]->rrmPolicyRatioInfo, recfgReq->listOfConfirguration[cfgIdx]->rrmPolicyRatioInfo,
sizeof(SchRrmPolicyRatio));
break;
}
}
}
}
- freeSchSliceCfgReq(cfgReq);
+ freeSchSliceCfgReq(recfgReq);
return ROK;
}
/*******************************************************************************
*
* @details
*
- * Function : SchSendSliceCfgRspToMac
+ * Function : SchSendSliceRecfgRspToMac
*
* Functionality:
* function is used to send Slice re Cfg rsp to MAC
*
- * @params[in] Pst *pst, SchSliceCfgRsp schSliceReCfgRsp
+ * @params[in] Pst *pst, SchSliceRecfgRsp schSliceRecfgRsp
*
* @return- void
*
* ********************************************************************************/
-void SchSendSliceReCfgRspToMac(Inst inst, SchSliceCfgRsp schSliceReCfgRsp)
+void SchSendSliceRecfgRspToMac(Inst inst, SchSliceRecfgRsp schSliceRecfgRsp)
{
Pst rspPst;
FILL_PST_SCH_TO_MAC(rspPst, inst);
rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC;
- SchSliceReCfgRspOpts[rspPst.selector](&rspPst, &schSliceReCfgRsp);
+ SchSliceRecfgRspOpts[rspPst.selector](&rspPst, &schSliceRecfgRsp);
}
/*******************************************************************************
*
*
* @details
*
- * Function : MacSchSliceReCfgReq
+ * Function : MacSchSliceRecfgReq
*
* Functionality:
* function is used to store the slice re configuration Sch DB
*
- * @params[in] Pst *pst, SchSliceCfgReq *schSliceReCfgReq
+ * @params[in] Pst *pst, SchSliceRecfgReq *schSliceRecfgReq
*
* @return
* ROK - Success
* RFAILED - Failure
*
* ********************************************************************************/
-uint8_t MacSchSliceReCfgReq(Pst *pst, SchSliceCfgReq *schSliceReCfgReq)
+uint8_t MacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq)
{
uint8_t count = 0;
Inst inst = pst->dstInst - SCH_INST_START;
- SchSliceCfgRsp schSliceReCfgRsp;
+ SchSliceRecfgRsp schSliceRecfgRsp;
DU_LOG("\nINFO --> SCH : Received Slice ReCfg request from MAC");
- if(schSliceReCfgReq)
+ if(schSliceRecfgReq)
{
- if(schSliceReCfgReq->listOfConfirguration)
+ if(schSliceRecfgReq->listOfConfirguration)
{
/* filling the slice configuration response of each slice */
- if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceReCfgReq, &schSliceReCfgRsp, &count) != ROK)
+ if(fillSliceCfgRsp(true, &schCb[inst].sliceCfg, NULLP, schSliceRecfgReq, &schSliceRecfgRsp, &count) != ROK)
{
DU_LOG("\nERROR --> SCH : Failed to fill sch slice cfg response");
return RFAILED;
}
/* Modify the slice configuration stored in schCb */
- if(modifySliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceReCfgReq, schSliceReCfgRsp, count) != ROK)
+ if(modifySliceCfgInSchDb(&schCb[inst].sliceCfg, schSliceRecfgReq, schSliceRecfgRsp, count) != ROK)
{
DU_LOG("\nERROR --> SCH : Failed to modify slice cfg of SchDb");
return RFAILED;
}
- SchSendSliceReCfgRspToMac(inst, schSliceReCfgRsp);
+ SchSendSliceRecfgRspToMac(inst, schSliceRecfgRsp);
}
}
else
{
- DU_LOG("\nERROR --> SCH : Received SchSliceCfgReq is NULL");
+ DU_LOG("\nERROR --> SCH : Received SchSliceRecfgReq is NULL");
}
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t SchSendCellDeleteRspToMac(SchCellDelete *ueDelete, Inst inst, SchMacRsp result)
+uint8_t SchSendCellDeleteRspToMac(SchCellDeleteReq *ueDelete, Inst inst, SchMacRsp result)
{
Pst rspPst;
uint8_t ret=0;
*
* ****************************************************************/
-uint8_t MacSchCellDeleteReq(Pst *pst, SchCellDelete *cellDelete)
+uint8_t MacSchCellDeleteReq(Pst *pst, SchCellDeleteReq *cellDelete)
{
uint8_t cellIdx=0, ret = RFAILED;
Inst inst = pst->dstInst - SCH_INST_START;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packMacCellStart(Pst *pst, OduCellId *cellId)
+uint8_t packMacCellStart(Pst *pst, CellStartInfo *cellStart)
{
Buffer *mBuf = NULLP;
}
/* pack the address of the structure */
- CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)cellStart, mBuf);
}
return ODU_POST_TASK(pst,mBuf);
* ****************************************************************/
uint8_t unpackMacCellStart(DuMacCellStart func, Pst *pst, Buffer *mBuf)
{
- OduCellId *cellId;
+ CellStartInfo *cellStart;
if(pst->selector == ODU_SELECTOR_LWLC)
{
/* unpack the address of the structure */
- CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cellStart, mBuf);
ODU_PUT_MSG_BUF(mBuf);
- return (*func)(pst, cellId);
+ return (*func)(pst, cellStart);
}
else
{
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packMacCellStop(Pst *pst, OduCellId *cellId)
+uint8_t packMacCellStop(Pst *pst, CellStopInfo *cellStop)
{
if(pst->selector == ODU_SELECTOR_LC)
{
}
/* pack the address of the structure */
- CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)cellStop, mBuf);
return ODU_POST_TASK(pst,mBuf);
}
* ****************************************************************/
uint8_t unpackMacCellStop(DuMacCellStop func, Pst *pst, Buffer *mBuf)
{
- OduCellId *cellId;
+ CellStopInfo *cellStop;
if(pst->selector == ODU_SELECTOR_LWLC)
{
/* unpack the address of the structure */
- CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cellStop, mBuf);
ODU_PUT_MSG_BUF(mBuf);
- return (*func)(pst, cellId);
+ return (*func)(pst, cellStop);
}
else
{
{
if(pst->selector == ODU_SELECTOR_LWLC)
{
- MacCellDelete *cellDelete=NULLP;
+ MacCellDeleteReq *cellDelete=NULLP;
/* unpack the address of the structure */
CMCHKUNPK(oduUnpackPointer, (PTR *)&cellDelete, mBuf);
*
* ****************************************************************/
-uint8_t packDuMacCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
+uint8_t packDuMacCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete)
{
Buffer *mBuf = NULLP;
* Functionality:
* Pack and send Slice ReCfg request from MAC to DU APP
*
- * @params[in] Pst *pst, MacSliceCfgReq *sliceReCfgReq
+ * @params[in] Pst *pst, MacSliceRecfgReq *sliceRecfgReq
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packDuMacSliceRecfgReq(Pst *pst, MacSliceCfgReq *sliceReCfgReq)
+uint8_t packDuMacSliceRecfgReq(Pst *pst, MacSliceRecfgReq *sliceRecfgReq)
{
Buffer *mBuf = NULLP;
DU_LOG("\nERROR --> MAC : Memory allocation failed in packDuMacSliceRecfgReq");
return RFAILED;
}
- CMCHKPK(oduPackPointer,(PTR)sliceReCfgReq, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)sliceRecfgReq, mBuf);
}
else
{
* RFAILED - failure
*
* ****************************************************************/
-uint8_t unpackMacSliceReCfgReq(DuMacSliceRecfgReq func, Pst *pst, Buffer *mBuf)
+uint8_t unpackMacSliceRecfgReq(DuMacSliceRecfgReq func, Pst *pst, Buffer *mBuf)
{
if(pst->selector == ODU_SELECTOR_LWLC)
{
- MacSliceCfgReq *sliceReCfgReq;
+ MacSliceRecfgReq *sliceRecfgReq;
/* unpack the address of the structure */
- CMCHKUNPK(oduUnpackPointer, (PTR *)&sliceReCfgReq, mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&sliceRecfgReq, mBuf);
ODU_PUT_MSG_BUF(mBuf);
- return (*func)(pst, sliceReCfgReq);
+ return (*func)(pst, sliceRecfgReq);
}
else
{
*
* @details
*
- * Function : packDuMacSliceReCfgRsp
+ * Function : packDuMacSliceRecfgRsp
*
* Functionality:
* Pack and send Slice config response from MAC to DU APP
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packDuMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp)
+uint8_t packDuMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *sliceRecfgRsp)
{
Buffer *mBuf = NULLP;
{
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacSliceReCfgRsp");
+ DU_LOG("\nERROR --> MAC : Memory allocation failed at packDuMacSliceRecfgRsp");
return RFAILED;
}
/* pack the address of the structure */
- CMCHKPK(oduPackPointer,(PTR)cfgRsp, mBuf);
+ CMCHKPK(oduPackPointer,(PTR)sliceRecfgRsp, mBuf);
}
else
{
- DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacSliceReCfgRsp");
+ DU_LOG("\nERROR --> MAC: Only LWLC supported for packDuMacSliceRecfgRsp");
return RFAILED;
}
*
* @details
*
- * Function :unpackDuMacSliceReCfgRsp
+ * Function :unpackDuMacSliceRecfgRsp
*
* Functionality: Unpack Slice ReConfig Response from MAC to DU APP
*
* RFAILED - failure
*
* ****************************************************************/
-uint8_t unpackDuMacSliceReCfgRsp(MacDuSliceReCfgRspFunc func, Pst *pst, Buffer *mBuf)
+uint8_t unpackDuMacSliceRecfgRsp(MacDuSliceRecfgRspFunc func, Pst *pst, Buffer *mBuf)
{
if(pst->selector == ODU_SELECTOR_LWLC)
{
- MacSliceCfgRsp *cfgRsp = NULLP;
+ MacSliceRecfgRsp *sliceRecfgRsp = NULLP;
/* unpack the address of the structure */
- CMCHKUNPK(oduUnpackPointer, (PTR *)&cfgRsp, mBuf);
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&sliceRecfgRsp, mBuf);
ODU_PUT_MSG_BUF(mBuf);
- return (*func)(pst, cfgRsp);
+ return (*func)(pst, sliceRecfgRsp);
}
ODU_PUT_MSG_BUF(mBuf);
* Pack and send Dl Pcch indication to MAC
*
* @params[in] Post structure
- * MacPcchInd *pcchInd;
+ * DlPcchInd *pcchInd;
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packDuMacDlPcchInd(Pst *pst, MacPcchInd *pcchInd)
+uint8_t packDuMacDlPcchInd(Pst *pst, DlPcchInd *pcchInd)
{
Buffer *mBuf = NULLP;
{
if(pst->selector == ODU_SELECTOR_LWLC)
{
- MacPcchInd *pcchInd=NULLP;
+ DlPcchInd *pcchInd=NULLP;
/* unpack the address of the structure */
CMCHKUNPK(oduUnpackPointer, (PTR *)&pcchInd, mBuf);
UeDeleteStatus result;
}MacUeDeleteRsp;
-typedef struct macCellDelete
+typedef struct macCellDeleteReq
{
uint16_t cellId;
-}MacCellDelete;
+}MacCellDeleteReq;
typedef struct macCellDeleteRsp
{
MacSliceRsp **listOfSliceCfgRsp;
}MacSliceCfgRsp;
-typedef struct macPcchInd
+/*As per ORAN-WG8, Slice Cfg and ReCfg are same structures*/
+typedef struct macSliceCfgReq MacSliceRecfgReq;
+typedef struct macSliceCfgRsp MacSliceRecfgRsp;
+
+typedef struct dlPcchInd
{
uint16_t cellId;
uint16_t pf;
uint8_t i_s;
uint16_t pduLen;
uint8_t *pcchPdu;
-}MacPcchInd;
+}DlPcchInd;
+
+typedef struct cellInfo
+{
+ SlotTimingInfo slotInfo;
+ uint16_t cellId;
+}CellInfo;
+
+typedef struct cellInfo CellStartInfo;
+typedef struct cellInfo CellStopInfo;
/* Functions for CellUp Ind from MAC to DU APP*/
typedef uint8_t (*DuMacCellUpInd) ARGS((
/* Functions for mac cell start req */
typedef uint8_t (*DuMacCellStart) ARGS((
Pst *pst,
- OduCellId *cellId));
+ CellStartInfo *cellId));
/* Functions for mac cell stop request */
typedef uint8_t (*DuMacCellStop) ARGS((
Pst *pst,
- OduCellId *cellId ));
+ CellStopInfo *cellId ));
/* Function pointers for packing macCellCfg Request and Confirm */
typedef uint8_t (*packMacCellCfgReq) ARGS((
/* Cell Delete Request from DU APP to MAC*/
typedef uint8_t (*DuMacCellDeleteReq) ARGS((
Pst *pst,
- MacCellDelete *cellDelete ));
+ MacCellDeleteReq *cellDelete ));
/* Cell Delete Response from MAC to DU APP*/
typedef uint8_t (*MacDuCellDeleteRspFunc) ARGS((
/* Slice ReReCfg Request from DU APP to MAC*/
typedef uint8_t (*DuMacSliceRecfgReq) ARGS((
Pst *pst,
- MacSliceCfgReq *CfgReq));
+ MacSliceRecfgReq *CfgReq));
/* Slice ReReCfg Response from MAC to DU APP */
-typedef uint8_t (*MacDuSliceReCfgRspFunc) ARGS((
+typedef uint8_t (*MacDuSliceRecfgRspFunc) ARGS((
Pst *pst,
- MacSliceCfgRsp *cfgRsp));
+ MacSliceRecfgRsp *cfgRsp));
/* Pcch indication from DU APP to MAC*/
typedef uint8_t (*DuMacDlPcchInd) ARGS((
Pst *pst,
- MacPcchInd *pcchInd));
+ DlPcchInd *pcchInd));
uint64_t ueBitMapPerCell[MAX_NUM_CELL]; /* Bit Map to store used/free UE-IDX per Cell */
uint8_t packMacCellUpInd(Pst *pst, OduCellId *cellId);
uint8_t unpackMacCellUpInd(DuMacCellUpInd func, Pst *pst, Buffer *mBuf);
uint8_t duHandleCellUpInd(Pst *pst, OduCellId *cellId);
-uint8_t packMacCellStart(Pst *pst, OduCellId *cellId);
+uint8_t packMacCellStart(Pst *pst, CellStartInfo *cellStartInfo);
uint8_t unpackMacCellStart(DuMacCellStart func, Pst *pst, Buffer *mBuf);
-uint8_t MacProcCellStart(Pst *pst, OduCellId *cellId);
-uint8_t packMacCellStop(Pst *pst, OduCellId *cellId);
+uint8_t MacProcCellStart(Pst *pst, CellStartInfo *cellStartInfo);
+uint8_t packMacCellStop(Pst *pst, CellStopInfo *cellStopInfo);
uint8_t unpackMacCellStop(DuMacCellStop func, Pst *pst, Buffer *mBuf);
-uint8_t MacProcCellStop(Pst *pst, OduCellId *cellId);
+uint8_t MacProcCellStop(Pst *pst, CellStopInfo *cellStopInfo);
uint8_t packMacCellCfg(Pst *pst, MacCellCfg *macCellCfg);
uint8_t unpackDuMacCellCfg(DuMacCellCfgReq func, Pst *pst, Buffer *mBuf);
uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg);
uint8_t packDuMacUeDeleteRsp(Pst *pst, MacUeDeleteRsp *deleteRsp);
uint8_t DuProcMacUeDeleteRsp(Pst *pst, MacUeDeleteRsp *deleteRsp);
uint8_t unpackDuMacUeDeleteRsp(MacDuUeDeleteRspFunc func, Pst *pst, Buffer *mBuf);
-uint8_t packDuMacCellDeleteReq(Pst *pst, MacCellDelete *cellDelete);
-uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete);
+uint8_t packDuMacCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete);
+uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDeleteReq *cellDelete);
uint8_t unpackMacCellDeleteReq(DuMacCellDeleteReq func, Pst *pst, Buffer *mBuf);
uint8_t packDuMacCellDeleteRsp(Pst *pst, MacCellDeleteRsp *cellDeleteRsp);
uint8_t DuProcMacCellDeleteRsp(Pst *pst, MacCellDeleteRsp *cellDeleteRsp);
uint8_t DuProcMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp);
uint8_t packDuMacSliceCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp);
uint8_t unpackDuMacSliceCfgRsp(MacDuSliceCfgRspFunc func, Pst *pst, Buffer *mBuf);
-uint8_t packDuMacSliceRecfgReq(Pst *pst, MacSliceCfgReq *sliceReCfgReq);
-uint8_t MacProcSliceReCfgReq(Pst *pst, MacSliceCfgReq *sliceReCfgReq);
-uint8_t unpackMacSliceReCfgReq(DuMacSliceRecfgReq func, Pst *pst, Buffer *mBuf);
-uint8_t DuProcMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp);
-uint8_t packDuMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *cfgRsp);
-uint8_t unpackDuMacSliceReCfgRsp(MacDuSliceReCfgRspFunc func, Pst *pst, Buffer *mBuf);
+uint8_t packDuMacSliceRecfgReq(Pst *pst, MacSliceRecfgReq *sliceRecfgReq);
+uint8_t MacProcSliceRecfgReq(Pst *pst, MacSliceRecfgReq *sliceRecfgReq);
+uint8_t unpackMacSliceRecfgReq(DuMacSliceRecfgReq func, Pst *pst, Buffer *mBuf);
+uint8_t DuProcMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *sliceRecfgRsp);
+uint8_t packDuMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *sliceRecfgRsp);
+uint8_t unpackDuMacSliceRecfgRsp(MacDuSliceRecfgRspFunc func, Pst *pst, Buffer *mBuf);
uint8_t duHandleSlotInd(Pst *pst, SlotTimingInfo *slotIndInfo);
uint8_t packMacSlotInd(Pst *pst, SlotTimingInfo *slotIndInfo);
uint8_t unpackDuMacSlotInd(DuMacSlotInd func, Pst *pst, Buffer *mBuf);
-uint8_t packDuMacDlPcchInd(Pst *pst, MacPcchInd *pcchInd);
-uint8_t MacProcDlPcchInd(Pst *pst, MacPcchInd *pcchInd);
+uint8_t packDuMacDlPcchInd(Pst *pst, DlPcchInd *pcchInd);
+uint8_t MacProcDlPcchInd(Pst *pst, DlPcchInd *pcchInd);
uint8_t unpackMacDlPcchInd(DuMacDlPcchInd func, Pst *pst, Buffer *mBuf);
int8_t getFreeBitFromUeBitMap(uint16_t cellId);
void unsetBitInUeBitMap(uint16_t cellId, uint8_t bitPos);
/*******************************************************************
*
- * @brief Pack and Send HARQ UCI Ind from MAC to SCH
+ * @brief Pack and Send DL HARQ Ind from MAC to SCH
*
* @details
*
- * Function : packMacHarqSchUciInd
+ * Function : packMacSchDlHarqInd
*
* Functionality:
- * Pack and Send HARQ UCI Ind from MAC to SCH
+ * Pack and Send DL HARQ Ind from MAC to SCH
*
* @params[in]
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packMacSchHarqUciInd(Pst *pst, HarqUciIndInfo *uciInd)
+uint8_t packMacSchDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd)
{
if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
{
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packMacSchCellDeleteReq(Pst *pst, SchCellDelete *schCellDelete)
+uint8_t packMacSchCellDeleteReq(Pst *pst, SchCellDeleteReq *schCellDelete)
{
if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LC))
{
*
* @details
*
- * Function : packMacSchSliceReCfgReq
+ * Function : packMacSchSliceRecfgReq
*
* Functionality:
* Pack and Send Slice ReCfg request from MAC to SCH
*
- * @params[in] Pst *pst, SchSliceCfgReq *cfgReq
+ * @params[in] Pst *pst, SchSliceRecfgReq *cfgReq
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packMacSchSliceReCfgReq(Pst *pst, SchSliceCfgReq *cfgReq)
+uint8_t packMacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *sliceRecfgReq)
{
if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
{
*
* @details
*
- * Function : packSchSliceReCfgRsp
+ * Function : packSchSliceRecfgRsp
*
*
- * @param[in] Pst *pst, SchSliceCfgRsp *cfgRsp
+ * @param[in] Pst *pst, SchSliceRecfgRsp *cfgRsp
* @return S16 - ROK
**/
-uint8_t packSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *cfgRsp)
+uint8_t packSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *recfgRsp)
{
return ROK;
}
#define EVENT_PAGING_IND_TO_SCH 28
#define EVENT_DL_PAGING_ALLOC 29
#define EVENT_DL_REL_HQ_PROC 30
+#define EVENT_DL_HARQ_IND_TO_SCH 31
/*macros*/
#define MAX_SSB_IDX 1 /* forcing it as 1 for now. Right value is 64 */
#define SCH_SSB_MASK_SIZE 1
typedef struct schCellCfgCfm
{
uint16_t cellId; /* Cell Id */
- SchMacRsp rsp;
+ SchMacRsp rsp;
+ SchFailureCause cause;
}SchCellCfgCfm;
typedef struct ssbInfo
typedef struct schRachRsrcReq
{
- uint16_t cellId;
- uint16_t crnti;
- uint8_t numSsb;
- uint8_t ssbIdx[MAX_NUM_SSB];
+ SlotTimingInfo slotInd;
+ uint16_t cellId;
+ uint16_t crnti;
+ uint8_t numSsb;
+ uint8_t ssbIdx[MAX_NUM_SSB];
}SchRachRsrcReq;
typedef struct schCfraSsbResource
typedef struct schRachRsrcRel
{
+ SlotTimingInfo slotInd;
uint16_t cellId;
uint16_t crnti;
SchCfraResource cfraResource;
ErrorCause cause;
}SchUeDeleteRsp;
-typedef struct schCellDelete
+typedef struct schCellDeleteReq
{
uint16_t cellId;
-}SchCellDelete;
+}SchCellDeleteReq;
typedef struct schCellDeleteRsp
{
- uint16_t cellId;
- SchMacRsp rsp;
+ uint16_t cellId;
+ SchMacRsp rsp;
+ SchFailureCause cause;
}SchCellDeleteRsp;
typedef struct dataVolInfo
uint8_t srPayload[MAX_SR_BITS_IN_BYTES];
}SrUciIndInfo;
-typedef struct harqUciIndInfo
+typedef struct dlHarqInd
{
uint16_t cellId;
uint16_t crnti;
SlotTimingInfo slotInd;
uint8_t numHarq;
uint8_t harqPayload[MAX_HARQ_BITS_IN_BYTES];
-}HarqUciIndInfo;
+}DlHarqInd;
typedef struct schRrmPolicyRatio
{
RspCause cause;
}SliceRsp;
-typedef struct schSliceRsp
+typedef struct schSliceCfgRsp
{
uint8_t numSliceCfgRsp;
SliceRsp **listOfSliceCfgRsp;
}SchSliceCfgRsp;
+/*As per ORAN-WG8, Slice Cfg and ReCfg are same structures*/
+typedef struct schSliceCfgReq SchSliceRecfgReq;
+typedef struct schSliceCfgRsp SchSliceRecfgRsp;
+
typedef struct schPageInd
{
uint16_t cellId;
UlBufferStatusRptInd *bsrInd
));
-typedef uint8_t (*MacSchHarqUciIndFunc) ARGS((
+typedef uint8_t (*MacSchDlHarqIndFunc) ARGS((
Pst *pst, /* Post structure */
- HarqUciIndInfo *uciInd)); /* UCI IND Info */
+ DlHarqInd *dlHarqInd)); /* Dl HARQ IND Info */
typedef uint8_t (*MacSchSrUciIndFunc) ARGS((
Pst *pst, /* Post structure */
typedef uint8_t (*MacSchCellDeleteReqFunc) ARGS((
Pst *pst, /* Post structure */
- SchCellDelete *schCellDelete)); /*Scheduler UE Del*/
+ SchCellDeleteReq *schCellDelete)); /*Scheduler UE Del*/
typedef uint8_t (*SchCellDeleteRspFunc) ARGS((
Pst *pst, /* Post structure */
SchSliceCfgRsp *schSliceCfgRsp /* Cell Cfg Cfm */
));
-typedef uint8_t (*MacSchSliceReCfgReqFunc) ARGS((
+typedef uint8_t (*MacSchSliceRecfgReqFunc) ARGS((
Pst *pst, /* Post structure */
- SchSliceCfgReq *schSliceReCfgReq)); /* Scheduler Slice ReCfg Req */
+ SchSliceRecfgReq *schSliceRecfgReq)); /* Scheduler Slice ReCfg Req */
-typedef uint8_t (*SchSliceReCfgRspFunc) ARGS((
+typedef uint8_t (*SchSliceRecfgRspFunc) ARGS((
Pst *pst, /* Post Structure */
- SchSliceCfgRsp *schSliceReCfgRsp /* Cell ReCfg Cfm */
+ SchSliceRecfgRsp *schSliceRecfgRsp /* Cell ReCfg Cfm */
));
typedef uint8_t (*MacSchPagingIndFunc) ARGS((
uint8_t packMacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd);
uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd);
uint8_t packMacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd);
-uint8_t packMacSchHarqUciInd(Pst *pst, HarqUciIndInfo *uciInd);
-uint8_t MacSchHarqUciInd(Pst *pst, HarqUciIndInfo *uciInd);
+uint8_t packMacSchDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd);
+uint8_t MacSchDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd);
uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd);
uint8_t packMacSchModUeConfigReq(Pst *pst, SchUeCfg *ueCfgToSch);
uint8_t MacSchModUeConfigReq(Pst *pst, SchUeCfg *ueCfgToSch);
uint8_t MacSchUeDeleteReq(Pst *pst, SchUeDelete *ueDelete);
uint8_t packSchUeDeleteRsp(Pst *pst, SchUeDeleteRsp *delRsp);
uint8_t MacProcSchUeDeleteRsp(Pst *pst, SchUeDeleteRsp *schUeDelRsp);
-uint8_t packMacSchCellDeleteReq(Pst *pst, SchCellDelete *schCellDelete);
-uint8_t MacSchCellDeleteReq(Pst *pst, SchCellDelete *schCellDelete);
+uint8_t packMacSchCellDeleteReq(Pst *pst, SchCellDeleteReq *schCellDelete);
+uint8_t MacSchCellDeleteReq(Pst *pst, SchCellDeleteReq *schCellDelete);
uint8_t packSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDeleteRsp);
uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDeleteRsp);
uint8_t packMacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *cfgReq);
uint8_t MacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq);
uint8_t packSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *cfgRsp);
uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *cfgRsp);
-uint8_t packMacSchSliceReCfgReq(Pst *pst, SchSliceCfgReq *cfgReq);
-uint8_t MacSchSliceReCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq);
-uint8_t packSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *cfgRsp);
-uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *sliceReCfgrsp);
+uint8_t packMacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *recfgReq);
+uint8_t MacSchSliceRecfgReq(Pst *pst, SchSliceRecfgReq *schSliceRecfgReq);
+uint8_t packSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *schSliceRecfgRsp);
+uint8_t MacProcSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *sliceRecfgrsp);
uint8_t packMacSchPagingInd(Pst *pst, SchPageInd *pageInd);
uint8_t MacSchPagingInd(Pst *pst, SchPageInd *pageInd);
uint8_t packSchMacDlPageAlloc(Pst *pst, DlPageAlloc *dlPageAlloc);
typedef struct rlcSchedResultRpt
{
//Slot info
+ SlotTimingInfo slotInfo; /*!< Timing info */
uint16_t cellId; /*!< CELL ID */
uint16_t rnti; /*!< Temporary CRNTI */
uint8_t numLc; /*!< Number of logical channels scheduled */
- SlotTimingInfo slotInfo; /*!< Timing info */
RlcLcSchInfo lcSch[MAX_NUM_LC]; /*!< Scheduled info of logical channels */
}RlcSchedResultRpt;
*
* Functionality: Send pcch indication to MAC
*
- * @Params[in] MacPcchInd *pcchInd
+ * @Params[in] DlPcchInd *pcchInd
* @return ROK - success
* RFAILED - failure
*
* ****************************************************************/
-uint8_t sendDlPcchIndToMac(MacPcchInd *pcchInd)
+uint8_t sendDlPcchIndToMac(DlPcchInd *pcchInd)
{
uint8_t ret = ROK;
Pst pst;
{
Pst pst;
uint8_t ret=ROK;
- MacCellDelete *cellDelete = NULLP;
+ MacCellDeleteReq *cellDelete = NULLP;
- DU_ALLOC_SHRABL_BUF(cellDelete, sizeof(MacCellDelete));
+ DU_ALLOC_SHRABL_BUF(cellDelete, sizeof(MacCellDeleteReq));
if(cellDelete)
{
cellDelete->cellId = cellId;
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : sendCellDeleteReqToMac(): Failed to send Cell delete Req to MAC");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cellDelete, sizeof(MacCellDelete));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, cellDelete, sizeof(MacCellDeleteReq));
}
}
else
PCCH_Message_t *pcchMsg = NULLP;
asn_enc_rval_t encRetVal;
PagingRrc_t *pagingMsg = NULLP;
- MacPcchInd *macPcchInd = NULLP;
+ DlPcchInd *macPcchInd = NULLP;
uint8_t recordIdx = 0, ret = RFAILED;
/*As per 38.473 Sec 9.3.1.39,5G-S-TMSI :48 Bits >> Bytes and 0 UnusedBits */
{
DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for RRC PDU for Pcch indication \n");
- DU_ALLOC_SHRABL_BUF(macPcchInd, sizeof(MacPcchInd));
+ DU_ALLOC_SHRABL_BUF(macPcchInd, sizeof(DlPcchInd));
if(macPcchInd == NULLP)
{
DU_LOG("\nERROR --> DU APP: BuildAndSendDlPcchIndToMac(); (macPcchInd) Memory Alloction failed!");
if(ret != ROK)
{
DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macPcchInd->pcchPdu, macPcchInd->pduLen);
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macPcchInd, sizeof(MacPcchInd));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, macPcchInd, sizeof(DlPcchInd));
break;
}
}
void duProcF1SetupRsp();
uint8_t duGetCellCb(uint16_t cellId, DuCellCb **cellCb);
uint8_t BuildAndSendSliceConfigReq(RrmPolicy *rrmPolicy[], uint8_t totalRrrmPolicy, uint8_t totalSliceCfgReq);
-uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceReCfg);
+uint8_t BuildAndSendSliceRecfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceRecfg);
uint8_t processPagingMsg(uint16_t cellId, DuPagingMsg *rcvdF1apPagingParam);
uint8_t BuildAndSendDlPcchIndToMac(uint16_t cellId, uint16_t pf, uint8_t i_s, CmLListCp *pageUeLL);
#endif
}
else
{
- BuildAndSendSliceReCfgReq(duCfgParam.tempSliceCfg.rrmPolicy, duCfgParam.tempSliceCfg.totalRrmPolicy,\
+ BuildAndSendSliceRecfgReq(duCfgParam.tempSliceCfg.rrmPolicy, duCfgParam.tempSliceCfg.totalRrmPolicy,\
duCfgParam.tempSliceCfg.totalSliceCount);
}
}
}
case EVENT_MAC_SLICE_RECFG_RSP:
{
- ret = unpackDuMacSliceReCfgRsp(DuProcMacSliceReCfgRsp, pst, mBuf);
+ ret = unpackDuMacSliceRecfgRsp(DuProcMacSliceRecfgRsp, pst, mBuf);
break;
}
case EVENT_MAC_RACH_RESOURCE_RSP:
};
-DuMacSliceRecfgReq packMacSliceReCfgReqOpts[] =
+DuMacSliceRecfgReq packMacSliceRecfgReqOpts[] =
{
packDuMacSliceRecfgReq, /* Loose coupling */
- MacProcSliceReCfgReq, /* TIght coupling */
+ MacProcSliceRecfgReq, /* TIght coupling */
packDuMacSliceRecfgReq /* Light weight-loose coupling */
};
/**************************************************************************
uint8_t duBuildAndSendMacCellStart()
{
Pst pst;
- OduCellId *cellId = NULL;
+ CellStartInfo *cellStart = NULL;
DU_LOG("\nINFO --> DU APP : Building and Sending cell start request to MAC");
/* Send Cell Start Request to MAC */
- DU_ALLOC_SHRABL_BUF(cellId, sizeof(OduCellId));
- if(!cellId)
+ DU_ALLOC_SHRABL_BUF(cellStart, sizeof(CellStartInfo));
+ if(!cellStart)
{
DU_LOG("\nERROR --> DU APP : Memory alloc failed while building cell start request");
return RFAILED;
{
if(duCb.actvCellLst[id])
{
- cellId->cellId = duCb.actvCellLst[id]->cellId;
+ cellStart->cellId = duCb.actvCellLst[id]->cellId;
/* Fill Pst */
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_CELL_START);
- return (*packMacCellStartOpts[pst.selector])(&pst, cellId);
+ return (*packMacCellStartOpts[pst.selector])(&pst, cellStart);
}
}
return ROK;
*
* ****************************************************************/
-uint8_t fillSliceCfgReCfgInfo(MacSliceCfgReq *sliceCfgReq, RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
+uint8_t fillSliceCfgReCfgInfo(MacSliceRecfgReq *sliceRecfgReq, RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
{
uint8_t sliceIdx = 0, cfgIdx = 0, memberListIdx = 0;
if(totalRrmPolicy)
{
- DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg, totalSliceCount*sizeof(MacSliceRrmPolicy*));
- if(sliceCfgReq->listOfSliceCfg == NULLP)
+ DU_ALLOC_SHRABL_BUF(sliceRecfgReq->listOfSliceCfg, totalSliceCount*sizeof(MacSliceRrmPolicy*));
+ if(sliceRecfgReq->listOfSliceCfg == NULLP)
{
DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
return RFAILED;
{
for(memberListIdx = 0; memberListIdx<rrmPolicy[sliceIdx]->numMemberList; memberListIdx++)
{
- DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy));
- if(sliceCfgReq->listOfSliceCfg[cfgIdx] == NULLP)
+ DU_ALLOC_SHRABL_BUF(sliceRecfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy));
+ if(sliceRecfgReq->listOfSliceCfg[cfgIdx] == NULLP)
{
DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
return RFAILED;
}
- memcpy(&sliceCfgReq->listOfSliceCfg[cfgIdx]->snssai, &rrmPolicy[sliceIdx]->memberList[memberListIdx]->snssai, sizeof(Snssai));
+ memcpy(&sliceRecfgReq->listOfSliceCfg[cfgIdx]->snssai, &rrmPolicy[sliceIdx]->memberList[memberListIdx]->snssai, sizeof(Snssai));
- DU_ALLOC_SHRABL_BUF(sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio));
- if(sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio == NULLP)
+ DU_ALLOC_SHRABL_BUF(sliceRecfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio));
+ if(sliceRecfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio == NULLP)
{
DU_LOG("\nERROR --> DU_APP : Memory allocation failed in fillSliceCfgReCfgInfo");
return RFAILED;
}
- sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMaxRatio = rrmPolicy[sliceIdx]->policyMaxRatio;
- sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMinRatio = rrmPolicy[sliceIdx]->policyMinRatio;
- sliceCfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyDedicatedRatio = rrmPolicy[sliceIdx]->policyDedicatedRatio;
- sliceCfgReq->numOfConfiguredSlice++;
+ sliceRecfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMaxRatio = rrmPolicy[sliceIdx]->policyMaxRatio;
+ sliceRecfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyMinRatio = rrmPolicy[sliceIdx]->policyMinRatio;
+ sliceRecfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio->policyDedicatedRatio = rrmPolicy[sliceIdx]->policyDedicatedRatio;
+ sliceRecfgReq->numOfConfiguredSlice++;
cfgIdx++;
}
}
*
* @details
*
- * Function : BuildAndSendSliceReCfgReq
+ * Function : BuildAndSendSliceRecfgReq
*
* Functionality: Fill the slice configration and rrm policy related
*
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildAndSendSliceReCfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
+uint8_t BuildAndSendSliceRecfgReq(RrmPolicy *rrmPolicy[], uint8_t totalRrmPolicy, uint8_t totalSliceCount)
{
Pst pst;
- MacSliceCfgReq *sliceReCfgReq = NULLP;
+ MacSliceRecfgReq *sliceRecfgReq = NULLP;
DU_LOG("\nINFO --> DU_APP : Slice ReConfiguration Request received");
- DU_ALLOC_SHRABL_BUF(sliceReCfgReq, sizeof(MacSliceCfgReq));
- if(sliceReCfgReq == NULLP)
+ DU_ALLOC_SHRABL_BUF(sliceRecfgReq, sizeof(MacSliceRecfgReq));
+ if(sliceRecfgReq == NULLP)
{
- DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceReCfgReq");
+ DU_LOG("\nERROR --> DU_APP : Memory allocation failed to BuildAndSendSliceRecfgReq");
return RFAILED;
}
else
{
- if(fillSliceCfgReCfgInfo(sliceReCfgReq, rrmPolicy, totalRrmPolicy, totalSliceCount) != ROK)
+ if(fillSliceCfgReCfgInfo(sliceRecfgReq, rrmPolicy, totalRrmPolicy, totalSliceCount) != ROK)
{
DU_LOG("\nERROR --> DU_APP: Failed to fill slice cfg request info");
return RFAILED;
FILL_PST_DUAPP_TO_MAC(pst, EVENT_MAC_SLICE_RECFG_REQ);
DU_LOG("\nDEBUG --> DU_APP: Sending Slice ReCfg Request to MAC ");
- if( (*packMacSliceReCfgReqOpts[pst.selector])(&pst, sliceReCfgReq) == RFAILED)
+ if( (*packMacSliceRecfgReqOpts[pst.selector])(&pst, sliceRecfgReq) == RFAILED)
{
DU_LOG("\nERROR --> DU_APP: Failed to send Slice ReCfg Req to MAC");
- DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceReCfgReq, sizeof(MacSliceCfgReq));
+ DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, sliceRecfgReq, sizeof(MacSliceRecfgReq));
}
}
return ROK;
*
* @details
*
- * Function : DuProcMacSliceReCfgRsp
+ * Function : DuProcMacSliceRecfgRsp
*
* Functionality: process the slice ReCfg rsp received from MAC
*
- * @params[in] Post structure, MacSliceCfgRsp *ReCfgRsp
+ * @params[in] Post structure, MacSliceRecfgRsp *ReCfgRsp
*
* @return ROK - success
* RFAILED - failure
*
**********************************************************************/
-uint8_t DuProcMacSliceReCfgRsp(Pst *pst, MacSliceCfgRsp *reCfgRsp)
+uint8_t DuProcMacSliceRecfgRsp(Pst *pst, MacSliceRecfgRsp *reCfgRsp)
{
uint8_t cfgIdx = 0;