packDuMacUeDeleteRsp /* packing for light weight loosly coupled */
};
-MacSchCellDeleteReqFunc macSchCellDeleteReqOpts[]=
-{
- packMacSchCellDeleteReq, /* packing for loosely coupled */
- MacSchCellDeleteReq, /* packing for tightly coupled */
- packMacSchCellDeleteReq /* packing for light weight loosely coupled */
-};
-
-MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] =
-{
- packDuMacCellDeleteRsp, /* packing for loosely coupled */
- DuProcMacCellDeleteRsp, /* packing for tightly coupled */
- packDuMacCellDeleteRsp /* packing for light weight loosly coupled */
-};
-
/*******************************************************************
*
* @brief Fills mac cell group config to be sent to scheduler
{
if(!schPdschCfg->maxMimoLayers)
{
- MAC_ALLOC_SHRABL_BUF(schPdschCfg->maxMimoLayers, sizeof(uint8_t));
+ MAC_ALLOC(schPdschCfg->maxMimoLayers, sizeof(uint8_t));
if(!schPdschCfg->maxMimoLayers)
{
DU_LOG("\nERROR --> MAC :Memory Alloc MimoLayers Failed at fillPdschServCellCfg()");
{
if(!schPdschCfg->maxCodeBlkGrpPerTb)
{
- MAC_ALLOC_SHRABL_BUF(schPdschCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB));
+ MAC_ALLOC(schPdschCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB));
if(!schPdschCfg->maxCodeBlkGrpPerTb)
{
DU_LOG("\nERROR --> MAC :Memory Alloc for code Block Failed at fillPdschServCellCfg()");
{
if(!schPdschCfg->codeBlkGrpFlushInd)
{
- MAC_ALLOC_SHRABL_BUF(schPdschCfg->codeBlkGrpFlushInd, sizeof(bool));
+ MAC_ALLOC(schPdschCfg->codeBlkGrpFlushInd, sizeof(bool));
if(!schPdschCfg->codeBlkGrpFlushInd)
{
DU_LOG("\nERROR --> MAC :Memory Alloc for Flush Ind Failed at fillPdschServCellCfg()");
{
if(!schPdschCfg->xOverhead)
{
- MAC_ALLOC_SHRABL_BUF(schPdschCfg->xOverhead, sizeof(SchPdschXOverhead));
+ MAC_ALLOC(schPdschCfg->xOverhead, sizeof(SchPdschXOverhead));
if(!schPdschCfg->xOverhead)
{
DU_LOG("\nERROR --> MAC :Memory Alloc for xOverHead Failed at fillPdschServCellCfg()");
for(idx = 0; idx < schPdschCfg->numTimeDomRsrcAlloc; idx++)
{
+ if(macPdschCfg.timeDomRsrcAllociList[idx].k0)
+ {
+ MAC_ALLOC(schPdschCfg->timeDomRsrcAllociList[idx].k0, sizeof(uint8_t));
+ if(!schPdschCfg->timeDomRsrcAllociList[idx].k0)
+ {
+ DU_LOG("\nERROR --> MAC : Memory allocation failed for K0 in fillInitDlBwpPdschCfg()");
+ return RFAILED;
+ }
+ *(schPdschCfg->timeDomRsrcAllociList[idx].k0) = *(macPdschCfg.timeDomRsrcAllociList[idx].k0);
+ }
schPdschCfg->timeDomRsrcAllociList[idx].mappingType = \
macPdschCfg.timeDomRsrcAllociList[idx].mappingType;
schPdschCfg->timeDomRsrcAllociList[idx].startSymbol = \
if(macLcCfg->drbQos)
{
- if(!schLcCfg->drbQos)
- {
- MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
- if(!schLcCfg->drbQos)
- {
- DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
- ret = RFAILED;
- }
- }
- if(ret == ROK)
- {
- fillSchDrbQosInfo(macLcCfg->drbQos, schLcCfg->drbQos);
- }
- else
- return ret;
+ if(!schLcCfg->drbQos)
+ {
+ MAC_ALLOC(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
+ if(!schLcCfg->drbQos)
+ {
+ DU_LOG("\nERROR --> MAC : Memory alloc failed at drbQos at fillLogicalChannelCfg()");
+ ret = RFAILED;
+ }
+ }
+ if(ret == ROK)
+ {
+ fillSchDrbQosInfo(macLcCfg->drbQos, schLcCfg->drbQos);
+ }
+ else
+ return ret;
}
else
{
{
if(!schLcCfg->snssai)
{
- MAC_ALLOC(schLcCfg->snssai, sizeof(SchSnssai));
+ MAC_ALLOC(schLcCfg->snssai, sizeof(Snssai));
if(!schLcCfg->snssai)
{
DU_LOG("\nERROR --> MAC : Memory alloc failed at snssai at fillLogicalChannelCfg()");
schLcCfg->snssai->sst = macLcCfg->snssai->sst;
for(sdIdx = 0; sdIdx < SD_SIZE; sdIdx++)
{
- schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx];
+ schLcCfg->snssai->sd[sdIdx] = macLcCfg->snssai->sd[sdIdx];
}
}
- else
- {
- schLcCfg->snssai = NULLP;
- /*Freeing the previously allocated buffer in case of failure */
- if(schLcCfg->drbQos)
- {
- MAC_FREE(schLcCfg->drbQos, sizeof(SchDrbQosInfo));
- schLcCfg->drbQos = NULLP;
- }
- return ret;
- }
}
else
{
uint8_t ret = ROK;
schUeCfg->cellId = ueCfg->cellId;
+ schUeCfg->duUeF1apId = ueCfg->duUeF1apId;
schUeCfg->crnti = ueCfg->crnti;
-
+ schUeCfg->dataTransmissionInfo = ueCfg->transmissionAction;
/* Copy MAC cell group config */
if(ueCfg->macCellGrpCfgPres == true)
{
schUeCfg->ambrCfg->ulBr = ueCfg->ambrCfg->ulBr;
}
else
+ {
schUeCfg->ambrCfg = NULLP;
-
+ }
/* Fill DL modulation infor */
schUeCfg->dlModInfo.modOrder = ueCfg->dlModInfo.modOrder;
schUeCfg->dlModInfo.mcsIndex = ueCfg->dlModInfo.mcsIndex;
memcpy(&ulCb->lcCb[lcIdx], &ulCb->lcCb[lcIdx+1], sizeof(UlLcCb));
memset(&ulCb->lcCb[lcIdx+1], 0, sizeof(UlLcCb));
}
+ /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/
+#if 0
+ /*Checking the Memory Leakage of Last Index*/
+ if(ulCb->lcCb[ulCb->numUlLc].snssai != NULLP)
+ {
+ DU_LOG("ERROR --> MAC: updateMacUlCb Last index deleted :%d memory is leaking",\
+ ulCb->numUlLc);
+ MAC_FREE(ulCb->lcCb[ulCb->numUlLc].snssai, sizeof(Snssai));
+ }
+ else
+ {
+ DU_LOG("INFO --> MAC: updateMacUlCb Last index:%d (before deletion) memory is freed successfully",\
+ ulCb->numUlLc);
+ }
+#endif
}
/*******************************************************************
memcpy(&dlCb->lcCb[lcIdx], &dlCb->lcCb[lcIdx+1], sizeof(DlLcCb));
memset(&dlCb->lcCb[lcIdx+1], 0, sizeof(DlLcCb));
}
+ /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/
+#if 0
+ /*Checking the Memory Leakage of Last Index*/
+ if(dlCb->lcCb[dlCb->numDlLc].snssai != NULLP)
+ {
+ DU_LOG("ERROR --> MAC: updateMacDlCb Last Deleted index:%d memory is leaking",\
+ dlCb->numDlLc);
+ MAC_FREE(dlCb->lcCb[dlCb->numDlLc].snssai, sizeof(Snssai));
+ }
+ else
+ {
+ DU_LOG("INFO --> MAC: updateMacDlCb Last index:%d (before deletion) memory is freed successfully",\
+ dlCb->numDlLc);
+ }
+#endif
+}
+
+/*******************************************************************
+ *
+ * @brief Update Mac UL Lc List based on CONFIG_MOD/CONFIG_DEL
+ *
+ * @details
+ *
+ * Function : updateMacUlLcCtxt
+ *
+ * Functionality: Update UeUlCb Lc List
+ *
+ * @params[in] UeUlCb pointer, ueLcCfg(received from DUAPP)
+ * @return void
+ *
+ * ****************************************************************/
+void updateMacUlLcCtxt(UeUlCb *ulInfo, LcCfg *ueLcCfg)
+{
+ uint8_t ueLcIdx = 0;
+
+ /*Traversing UL LC to be updated/Deleted*/
+ for(ueLcIdx = 0; ueLcIdx < ulInfo->numUlLc; ueLcIdx++)
+ {
+ if(ulInfo->lcCb[ueLcIdx].lcId == ueLcCfg->lcId)
+ {
+ if(ueLcCfg->configType == CONFIG_MOD)
+ {
+ /*Modify UL LC CB */
+ ulInfo->lcCb[ueLcIdx].lcGrpId = ueLcCfg->ulLcCfg.lcGroup;
+
+ /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/
+#if 0
+ /*Modifying/Copying PduSession ID and S-NSSAI into MAC's UECB*/
+ if(ueLcCfg->drbQos)
+ {
+ ulInfo->lcCb[ueLcIdx].pduSessionId = ueLcCfg->drbQos->pduSessionId;
+ }
+ if(ueLcCfg->snssai)
+ {
+ if(ulInfo->lcCb[ueLcIdx].snssai == NULLP)
+ {
+ MAC_ALLOC(ulInfo->lcCb[ueLcIdx].snssai, sizeof(Snssai));
+ }
+
+ memcpy(ulInfo->lcCb[ueLcIdx].snssai, ueLcCfg->snssai, sizeof(Snssai));
+ }
+#endif
+ DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\
+ ueLcCfg->lcId,ueLcIdx);
+ break;
+ }
+ if(ueLcCfg->configType == CONFIG_DEL)
+ {
+ memset(&ulInfo->lcCb[ueLcIdx], 0, sizeof(UlLcCb));
+ (ulInfo->numUlLc)--;
+ updateMacUlCb(ueLcIdx, ulInfo);
+ DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueLcCfg->lcId);
+ break;
+ }
+ }
+ }
}
+/*******************************************************************
+ *
+ * @brief Update Mac DL Lc List based on CONFIG_MOD/CONFIG_DEL
+ *
+ * @details
+ *
+ * Function : updateMacDlLcCtxt
+ *
+ * Functionality: Update UeDlCb Lc List
+ *
+ * @params[in] UeDlCb pointer, ueLcCfg(received from DUAPP)
+ * @return void
+ *
+ * ****************************************************************/
+void updateMacDlLcCtxt(UeDlCb *dlInfo, LcCfg *ueLcCfg)
+{
+ uint8_t ueLcIdx = 0;
+
+ /*Traversing DL LC to be updated/Deleted*/
+ for(ueLcIdx = 0; ueLcIdx < dlInfo->numDlLc; ueLcIdx++)
+ {
+ if(dlInfo->lcCb[ueLcIdx].lcId == ueLcCfg->lcId)
+ {
+ if(ueLcCfg->configType == CONFIG_MOD)
+ {
+ /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/
+#if 0
+ /*Modifying/Copying PduSession ID and S-NSSAI into MAC's UECB*/
+ if(ueLcCfg->drbQos)
+ {
+ dlInfo->lcCb[ueLcIdx].pduSessionId = ueLcCfg->drbQos->pduSessionId;
+ }
+ if(ueLcCfg->snssai)
+ {
+ if(dlInfo->lcCb[ueLcIdx].snssai == NULLP)
+ {
+ MAC_ALLOC(dlInfo->lcCb[ueLcIdx].snssai, sizeof(Snssai));
+ }
+
+ memcpy(dlInfo->lcCb[ueLcIdx].snssai, ueLcCfg->snssai, sizeof(Snssai));
+ }
+#endif
+ DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d], ueLcIdx:%d",\
+ ueLcCfg->lcId,ueLcIdx);
+ break;
+ }
+ if(ueLcCfg->configType == CONFIG_DEL)
+ {
+ memset(&dlInfo->lcCb[ueLcIdx], 0, sizeof(DlLcCb));
+ (dlInfo->numDlLc)--;
+ updateMacDlCb(ueLcIdx, dlInfo);
+ DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueLcCfg->lcId);
+ break;
+ }
+ }
+ }
+}
/*******************************************************************
*
* @brief Fills Logical channel Cfg List to Add/Mod/Del
uint8_t fillMacLcCfgList(MacUeCb *ueCb, MacUeCfg *ueCfg)
{
- uint8_t lcIdx, ueLcIdx;
+ uint8_t lcIdx = 0;
for(lcIdx = 0; lcIdx < ueCfg->numLcs; lcIdx++)
{
{
if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_ADD)
{
- /*Filling DL LC CB */
+ /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/
+#if 0
+ /*Copying PduSession ID and S-NSSAI into MAC's UECB*/
+ if(ueCfg->lcCfgList[lcIdx].drbQos)
+ {
+ ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].pduSessionId = \
+ ueCfg->lcCfgList[lcIdx].drbQos->pduSessionId;
+
+ ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].pduSessionId = \
+ ueCfg->lcCfgList[lcIdx].drbQos->pduSessionId;
+ }
+ if(ueCfg->lcCfgList[lcIdx].snssai)
+ {
+ if(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai == NULLP)
+ {
+ MAC_ALLOC(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai, sizeof(Snssai));
+ }
+ if(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai == NULLP)
+ {
+ MAC_ALLOC(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai, sizeof(Snssai));
+ }
+
+ memcpy(ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].snssai, \
+ ueCfg->lcCfgList[lcIdx].snssai, sizeof(Snssai));
+
+ memcpy(ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].snssai, \
+ ueCfg->lcCfgList[lcIdx].snssai, sizeof(Snssai));
+
+ }
+#endif
+ /*Filling DL LC CB */
ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcId = ueCfg->lcCfgList[lcIdx].lcId;
ueCb->dlInfo.lcCb[ueCb->dlInfo.numDlLc].lcState = MAC_LC_STATE_ACTIVE;
ueCb->dlInfo.numDlLc++;
- /*Filling UL LC CB */
+ /*Filling UL LC CB */
ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcId = ueCfg->lcCfgList[lcIdx].lcId;
ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcGrpId = ueCfg->lcCfgList[lcIdx].ulLcCfg.lcGroup;
ueCb->ulInfo.lcCb[ueCb->ulInfo.numUlLc].lcActive = MAC_LC_STATE_ACTIVE;
ueCb->ulInfo.numUlLc++;
}/*End of Add Config */
else
- {
- //searching for Lc to be Mod
- for(ueLcIdx = 0; ueLcIdx < ueCb->ulInfo.numUlLc; ueLcIdx++)
- {
- if(ueCb->ulInfo.lcCb[ueLcIdx].lcId == ueCfg->lcCfgList[lcIdx].lcId)
- {
- if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_MOD)
- {
- /*Nothing to Modify in DL LC CB */
- /*Modify UL LC CB */
- ueCb->ulInfo.lcCb[ueLcIdx].lcGrpId = ueCfg->lcCfgList[lcIdx].ulLcCfg.lcGroup;
- DU_LOG("\nINFO --> MAC: Successfully Modified LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId);
- break;
- }
- if(ueCfg->lcCfgList[lcIdx].configType == CONFIG_DEL)
- {
- memset(&ueCb->dlInfo.lcCb[ueLcIdx], 0, sizeof(DlLcCb));
- (ueCb->dlInfo.numDlLc)--;
- updateMacDlCb(ueLcIdx, &ueCb->dlInfo);
-
- memset(&ueCb->ulInfo.lcCb[ueLcIdx], 0, sizeof(UlLcCb));
- (ueCb->ulInfo.numUlLc)--;
- updateMacUlCb(ueLcIdx, &ueCb->ulInfo);
- DU_LOG("\nINFO --> MAC: Successfully Deleted LC context for lcId[%d]", ueCfg->lcCfgList[lcIdx].lcId);
- break;
- }
- }
- }
+ {
+ updateMacUlLcCtxt(&ueCb->ulInfo, &ueCfg->lcCfgList[lcIdx]);
+ updateMacDlLcCtxt(&ueCb->dlInfo, &ueCfg->lcCfgList[lcIdx]);
}/*End of Mod Config */
}
}
{
uint8_t ret = ROK;
- ueCb->ueIdx = ueCfg->ueIdx;
+ ueCb->ueId = ueCfg->ueId;
ueCb->crnti = ueCfg->crnti;
ueCb->cellCb = macCb.macCell[cellIdx];
if(ueCfg->spCellCfgPres)
ueCb->dlInfo.dlHarqEnt.numHarqProcs = \
ueCfg->spCellCfg.servCellCfg.pdschServCellCfg.numHarqProcForPdsch;
}
- ueCb->state = UE_STATE_ACTIVE;
+
+ if(ueCfg->crnti)
+ ueCb->state = UE_STATE_ACTIVE;
+ else
+ ueCb->state = UE_HANDIN_IN_PROGRESS;
+
/*TODO: To check the bsr value during implementation */
if(ueCfg->macCellGrpCfgPres)
{
{
DU_LOG("\nERROR --> MAC: Failed while filing MAC LC List at fillMacUeCb()");
}
+ ueCb->transmissionAction = ueCfg->transmissionAction;
return ret;
}
{
uint8_t ret =ROK;
- if((ueCb->ueIdx == ueCfg->ueIdx) && (ueCb->crnti == ueCfg->crnti)\
+ if((ueCb->ueId == ueCfg->ueId) && (ueCb->crnti == ueCfg->crnti)\
&&(ueCb->state == UE_STATE_ACTIVE))
{
DU_LOG("\nERROR --> MAC : CRNTI %d already configured ", ueCfg->crnti);
}
else
{
- macCb.macCell[cellIdx]->numActvUe++;
- updateMacRaCb(cellIdx, ueCb);
- return ROK;
+ if(ueCb->state == UE_STATE_ACTIVE)
+ {
+ macCb.macCell[cellIdx]->numActvUe++;
+ updateMacRaCb(cellIdx, ueCb);
+ }
+ return ROK;
}
}
{
uint8_t ret = ROK;
- if((ueCb->ueIdx == ueCfg->ueIdx) && (ueCb->crnti == ueCfg->crnti)\
- &&(ueCb->state == UE_STATE_ACTIVE))
+ if((ueCb->ueId == ueCfg->ueId) && (ueCb->crnti == ueCfg->crnti)\
+ &&(ueCb->state == UE_STATE_ACTIVE))
{
DU_LOG("\nINFO --> MAC : Modifying Ue config Req for CRNTI %d ", ueCfg->crnti);
ret = fillMacUeCb(ueCb, ueCfg, cellIdx);
else
{
deleteMacRaCb(cellIdx, ueCb);
- return ROK;
+ return ROK;
}
}
return RFAILED;
}
/* Check if UE already configured */
- ueCb = &macCb.macCell[cellIdx]->ueCb[ueCfg->ueIdx -1];
+ if(ueCfg->crnti)
+ ueCb = &macCb.macCell[cellIdx]->ueCb[ueCfg->ueId -1];
+ else
+ ueCb = &macCb.macCell[cellIdx]->hoUeCb[ueCfg->duUeF1apId -1];
+
switch(pst->event)
{
case EVENT_UE_CONFIG_RSP_TO_MAC:
- ret = createUeCb(cellIdx, ueCb, ueCfg);
- if(ret != ROK)
- DU_LOG("\nERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx);
- break;
+ {
+ ret = createUeCb(cellIdx, ueCb, ueCfg);
+ if(ret != ROK)
+ DU_LOG("\nERROR --> MAC: AddUeConfigReq for cellIdx :%d failed in procMacUeCfgData()", cellIdx);
+ break;
+ }
+
case EVENT_UE_RECONFIG_RSP_TO_MAC:
- ret = modifyUeCb(cellIdx, ueCb, ueCfg);
- if(ret != ROK)
- DU_LOG("\nERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx);
- break;
+ {
+ ret = modifyUeCb(cellIdx, ueCb, ueCfg);
+ if(ret != ROK)
+ DU_LOG("\nERROR --> MAC: ModifyUeConfigReq for cellIdx :%d failed at procMacUeCfgData()", cellIdx);
+ break;
+ }
+
default:
- break;
+ break;
}
return ret;
}
memcpy(tmpData, ueCfg, sizeof(MacUeCfg));
GET_CELL_IDX(ueCfg->cellId, cellIdx);
- macCb.macCell[cellIdx]->ueCfgTmpData[ueCfg->ueIdx-1] = tmpData;
+ macCb.macCell[cellIdx]->ueCfgTmpData[ueCfg->duUeF1apId-1] = tmpData;
return ROK;
}
if(ret == ROK)
{
/*Sending Cfg Req to SCH */
- ret = fillSchUeCfg(pst, &schUeCfg, ueCfg);
- if(ret != ROK)
- DU_LOG("\nERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()");
- else
- {
+ ret = fillSchUeCfg(pst, &schUeCfg, ueCfg);
+ if(ret != ROK)
+ DU_LOG("\nERROR --> MAC : Failed to fill Sch Ue Cfg at MacProcUeCreateReq()");
+ else
+ {
/* Fill event and send UE create request to SCH */
ret = sendUeReqToSch(pst, &schUeCfg);
- if(ret != ROK)
- DU_LOG("\nERROR --> MAC : Failed to send UE Create request to SCH");
- }
+ if(ret != ROK)
+ DU_LOG("\nERROR --> MAC : Failed to send UE Create request to SCH");
+ }
}
else
{
- DU_LOG("\nERROR --> MAC : Failed to store MAC UE CFG ");
+ DU_LOG("\nERROR --> MAC : Failed to store MAC UE CFG ");
}
}
else
/* Filling UE Config response */
memset(cfgRsp, 0, sizeof(MacUeCfgRsp));
cfgRsp->cellId = schCfgRsp->cellId;
- cfgRsp->ueIdx = schCfgRsp->ueIdx;
+ cfgRsp->duUeF1apId = schCfgRsp->duUeF1apId;
cfgRsp->result = result;
/* Fill Post structure and send UE Create response*/
/* Filling UE Config response */
memset(cfgRsp, 0, sizeof(MacUeCfgRsp));
cfgRsp->cellId = schCfgRsp->cellId;
- cfgRsp->ueIdx = schCfgRsp->ueIdx;
+ cfgRsp->duUeF1apId = schCfgRsp->duUeF1apId;
cfgRsp->result = result;
/* Fill Post structure and send UE Create response*/
* Functionality:
* Function to return Mac Ue Cfg pointer
*
- * @params[in] cellIdx, ueIdx
+ * @params[in] cellIdx, ueId
*
* @return MacUeCfg pointer - success
* NULLP - failure
*
* ****************************************************************/
-MacUeCfg *getMacUeCfg(uint16_t cellIdx, uint8_t ueIdx)
+MacUeCfg *getMacUeCfg(uint16_t cellIdx, uint8_t duUeF1apId)
{
MacUeCfg *ueCfg = NULLP;
if(macCb.macCell[cellIdx])
{
- ueCfg = macCb.macCell[cellIdx]->ueCfgTmpData[ueIdx-1];
+ ueCfg = macCb.macCell[cellIdx]->ueCfgTmpData[duUeF1apId-1];
}
else
{
uint16_t cellIdx;
MacUeCfg *ueCfg = NULLP;
+#ifdef CALL_FLOW_DEBUG_LOG
+ switch(pst->event)
+ {
+ case EVENT_UE_CONFIG_RSP_TO_MAC:
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_CONFIG_RSP_TO_MAC\n");
+ break;
+ case EVENT_UE_RECONFIG_RSP_TO_MAC:
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_RECONFIG_RSP_TO_MAC\n");
+ break;
+ default:
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : Invalid Event\n");
+ break;
+ }
+#endif
+
GET_CELL_IDX(schCfgRsp->cellId, cellIdx);
- ueCfg = getMacUeCfg(cellIdx, schCfgRsp->ueIdx);
+ ueCfg = getMacUeCfg(cellIdx, schCfgRsp->duUeF1apId);
if(ueCfg == NULLP)
{
DU_LOG("\nERROR --> MAC : Failed to find the Mac Ue Cfg for event [%d] in MacProcSchUeCfgRsp()", pst->event);
switch(pst->event)
{
case EVENT_UE_CONFIG_RSP_TO_MAC:
- {
- if(schCfgRsp->rsp != RSP_NOK)
- {
- DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- if(ret == ROK)
- {
- ret = procMacUeCfgData(pst, ueCfg);
- if(ret == ROK)
- {
- result = MAC_DU_APP_RSP_OK;
+ {
+ if(schCfgRsp->rsp != RSP_NOK)
+ {
+ DU_LOG("\nINFO --> MAC: SCH UeConfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ if(ret == ROK)
+ {
+ ret = procMacUeCfgData(pst, ueCfg);
+ if(ret == ROK)
+ {
+ result = MAC_DU_APP_RSP_OK;
+ }
}
- }
- }
- else
- {
- DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- }
- ret = MacSendUeCreateRsp(result, schCfgRsp);
- }
- break;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC: SCH UeConfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
+ }
+ ret = MacSendUeCreateRsp(result, schCfgRsp);
+ }
+ break;
case EVENT_UE_RECONFIG_RSP_TO_MAC:
- {
- if(schCfgRsp->rsp != RSP_NOK)
- {
- DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- if(ret == ROK)
- {
- ret = procMacUeCfgData(pst, ueCfg);
- if(ret == ROK)
- {
- result = MAC_DU_APP_RSP_OK;
+ {
+
+ if(schCfgRsp->rsp != RSP_NOK)
+ {
+ DU_LOG("\nINFO --> MAC: SCH UeReconfigRsp for CRNTI[%d] is success in MacProcSchUeCfgRsp()",\
+ schCfgRsp->crnti);
+ if(ret == ROK)
+ {
+ ret = procMacUeCfgData(pst, ueCfg);
+ if(ret == ROK)
+ {
+ result = MAC_DU_APP_RSP_OK;
+ }
}
- }
- }
- else
- {
- DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()", schCfgRsp->crnti);
- }
- ret = MacSendUeReconfigRsp(result, schCfgRsp);
- }
- break;
-
- default:
- break;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC: SCH UeReconfigRsp for CRNTI[%d] is failed in MacProcSchUeCfgRsp()",\
+ schCfgRsp->crnti);
+ }
+ ret = MacSendUeReconfigRsp(result, schCfgRsp);
+ }
+ break;
}
MAC_FREE(ueCfg, sizeof(MacUeCfg));
ueCfg = NULLP;
-
return ret;
}
/* Filling UE delete response */
deleteRsp->cellId = cellId;
- GET_UE_IDX(crnti,deleteRsp->ueIdx);
+ GET_UE_ID(crnti, deleteRsp->ueId);
deleteRsp->result = result;
/* Fill Post structure and send UE delete response*/
}
-/*******************************************************************
-*
-* @brief Function to delete MAC Pdsch ServCellCfg
-*
-* @details
-*
-* Function : deleteMacPdschServCellCfg
-*
-* Functionality: Function to delete MAC Pdsch ServCellCfg
-*
-* @params[in] PdschServCellCfg *pdschServCellCfg
-* @return void
-*
-* ****************************************************************/
-
-void deleteMacPdschServCellCfg(PdschServCellCfg *pdschServCellCfg)
-{
- MAC_FREE(pdschServCellCfg->maxMimoLayers, sizeof(uint8_t));
- MAC_FREE(pdschServCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
- MAC_FREE(pdschServCellCfg->codeBlkGrpFlushInd, sizeof(bool));
- MAC_FREE(pdschServCellCfg->xOverhead, sizeof(PdschXOverhead));
-}
-
-/*******************************************************************
-*
-* @brief Handles UE Delete requst from DU APP
-*
-* @details
-*
-* Function : deleteMacUeCb
-*
-* Functionality: Handles UE Delete requst from DU APP
-*
-* @params[in] MacCellCb *cellCb,uint16_t ueIdx
-* @return ROK - success
-* RFAILED - failure
-*
-* ****************************************************************/
-
-void deleteMacUeCb(MacUeCb *ueCb)
-{
- MacUeCfg *ueCfg = NULLP;
- ServCellCfgInfo *servCellCfg;
-
- if(ueCb->cellCb)
- {
- MAC_FREE(ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4Pdu, ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4PduLen);
- MAC_FREE(ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4TxPdu, ueCb->cellCb->macRaCb[ueCb->ueIdx-1].msg4TbSize);
-
- if(ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1])
- {
- ueCfg =ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1];
- MAC_FREE(ueCfg->ambrCfg, sizeof(AmbrCfg));
- if(ueCfg->spCellCfgPres)
- {
- servCellCfg = &ueCfg->spCellCfg.servCellCfg;
- MAC_FREE(servCellCfg->bwpInactivityTmr, sizeof(uint8_t));
-
- if(servCellCfg->initUlBwp.pucchPresent)
- {
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.resrcSet, sizeof(PucchResrcSetCfg));
-
- if(servCellCfg->initUlBwp.pucchCfg.resrc)
- {
- deletePucchResourcesCfg(servCellCfg->initUlBwp.pucchCfg.resrc);
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.resrc, sizeof(PucchResrcCfg));
- }
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format1, sizeof(PucchFormatCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format2, sizeof(PucchFormatCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format3, sizeof(PucchFormatCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.format4, sizeof(PucchFormatCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.schedReq, sizeof(PucchSchedReqCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.multiCsiCfg, sizeof(PucchMultiCsiCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.spatialInfo, sizeof(PucchSpatialCfg));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.dlDataToUlAck , sizeof(PucchDlDataToUlAck));
- MAC_FREE(servCellCfg->initUlBwp.pucchCfg.powerControl, sizeof(PucchPowerControl));
- deleteMacPdschServCellCfg(&servCellCfg->pdschServCellCfg);
- }
- }
- for(uint8_t idx=0 ;idx < ueCfg->numLcs; idx++)
- {
- MAC_FREE(ueCfg->lcCfgList[idx].drbQos, sizeof(DrbQosInfo));
- MAC_FREE(ueCfg->lcCfgList[idx].snssai, sizeof(Snssai));
- }
- MAC_FREE(ueCb->cellCb->ueCfgTmpData[ueCb->ueIdx-1],sizeof(MacUeCfg));
- }
- }
- memset(ueCb, 0, sizeof(MacUeCb));
-}
-
/*******************************************************************
*
* @brief Processes UE delete response from scheduler
uint8_t MacProcSchUeDeleteRsp(Pst *pst, SchUeDeleteRsp *schUeDelRsp)
{
- uint8_t ueIdx =0;
+ uint8_t ueId =0, isCrntiValid = 0;
uint16_t cellIdx=0;
uint8_t ret = RFAILED;
UeDeleteStatus result;
-
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UE_DELETE_RSP_TO_MAC\n");
+#endif
+
if(schUeDelRsp)
{
if(schUeDelRsp->rsp == RSP_OK)
GET_CELL_IDX(schUeDelRsp->cellId, cellIdx);
if(macCb.macCell[cellIdx])
{
- GET_UE_IDX(schUeDelRsp->crnti, ueIdx);
- if(macCb.macCell[cellIdx]->ueCb[ueIdx -1].crnti == schUeDelRsp->crnti)
+ CHECK_CRNTI(schUeDelRsp->crnti, isCrntiValid);
+ if(!isCrntiValid)
{
- deleteMacUeCb(&macCb.macCell[cellIdx]->ueCb[ueIdx -1]);
- macCb.macCell[cellIdx]->numActvUe--;
- result = SUCCESS;
- ret = ROK;
+ /*C-RNTI value is out of Acceptable range*/
+ DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): Invalid crnti[%d] ",schUeDelRsp->crnti);
+ result = UEID_INVALID;
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti);
- result = UEIDX_INVALID;
+ GET_UE_ID(schUeDelRsp->crnti, ueId);
+ if(macCb.macCell[cellIdx]->ueCb[ueId -1].crnti == schUeDelRsp->crnti)
+ {
+
+ /*Commenting as S-NSSAI and PDU session will be stored in MAC DB in future scope*/
+#if 0
+ /*Looping around LCs to free S-NSSAI memory*/
+ for(lcIdx = 0; lcIdx < (macCb.macCell[cellIdx]->ueCb[ueId -1].ulInfo.numUlLc); lcIdx++)
+ {
+ MAC_FREE(macCb.macCell[cellIdx]->ueCb[ueId -1].ulInfo.lcCb[lcIdx].snssai, sizeof(Snssai));
+ }
+ for(lcIdx = 0; lcIdx < (macCb.macCell[cellIdx]->ueCb[ueId -1].dlInfo.numDlLc); lcIdx++)
+ {
+ MAC_FREE(macCb.macCell[cellIdx]->ueCb[ueId -1].dlInfo.lcCb[lcIdx].snssai, sizeof(Snssai));
+ }
+#endif
+ memset(&macCb.macCell[cellIdx]->ueCb[ueId -1], 0, sizeof(MacUeCb));
+ macCb.macCell[cellIdx]->numActvUe--;
+ result = SUCCESS;
+ ret = ROK;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : MacProcSchUeDeleteRsp(): crnti[%d] does not exist ",schUeDelRsp->crnti);
+ result = UEID_INVALID;
+ }
}
}
else
}
else
{
- result = (schUeDelRsp->cause == INVALID_CELLID) ? CELLID_INVALID : UEIDX_INVALID;
+ result = (schUeDelRsp->cause == INVALID_CELLID) ? CELLID_INVALID : UEID_INVALID;
}
if(MacSendUeDeleteRsp(schUeDelRsp->cellId, schUeDelRsp->crnti, result) != ROK)
{
MacUeCb *ueCb = NULLP;
MacCellCb *cellCb = NULLP;
- DU_LOG("\nINFO --> MAC : UE Delete Request received for ueIdx[%d]", ueDelete->ueIdx);
+ DU_LOG("\nINFO --> MAC : UE Delete Request received for ueId[%d]", ueDelete->ueId);
if(ueDelete)
{
cellCb = macCb.macCell[cellIdx];
if(cellCb)
{
- ueCb = &cellCb->ueCb[ueDelete->ueIdx-1];
+ ueCb = &cellCb->ueCb[ueDelete->ueId-1];
if(ueCb->crnti == ueDelete->crnti)
{
ret = sendUeDelReqToSch(pst, ueDelete);
else
{
DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): CRNTI is not matched");
- result = UEIDX_INVALID;
+ result = UEID_INVALID;
}
}
else
{
- DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeIdx = %d",ueDelete->ueIdx);
+ DU_LOG("\nERROR --> MAC : MacProcUeDeleteReq(): Failed to find the MacUeCb of UeId = %d",ueDelete->ueId);
result = CELLID_INVALID;
}
return ret;
}
-/*******************************************************************
- *
- * @brief Fill and Send Cell Delete response from MAC to DU APP
- *
- * @details
- *
- * Function : MacSendCellDeleteRsp
- *
- * Functionality: Fill and Send Cell Delete response from MAC to DUAPP
- *
- * @params[in] MAC Cell delete result
- * SCH Cell delete response
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId)
-{
- MacCellDeleteRsp *deleteRsp=NULLP;
- Pst rspPst;
-
- MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
- if(!deleteRsp)
- {
- DU_LOG("\nERROR --> MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
- return RFAILED;
- }
-
- /* Filling CELL delete response */
- deleteRsp->cellId = cellId;
- deleteRsp->result = result;
-
- /* Fill Post structure and send CELL delete response*/
- memset(&rspPst, 0, sizeof(Pst));
- FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP);
- return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
-}
-
-/*******************************************************************
- *
- * @brief delete MAC CellCb information
- *
- * @details
- *
- * Function : deleteMacCellCb
- *
- * Functionality:
- * delete MAC CellCb information
- *
- * @params[in] MacCellCb * cellCb
- *
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-void deleteMacCellCb(MacCellCb * cellCb)
-{
- uint8_t idx;
- for(idx=0; idx<MAX_SLOTS; idx++)
- {
- MAC_FREE(cellCb->dlSlot[idx].dlInfo.rarAlloc, sizeof(RarAlloc));
- if(cellCb->dlSlot[idx].dlInfo.ulGrant)
- {
- MAC_FREE(cellCb->dlSlot[idx].dlInfo.ulGrant->dciInfo.pdschCfg, sizeof(PdschCfg));
- MAC_FREE(cellCb->dlSlot[idx].dlInfo.ulGrant, sizeof(DciInfo));
- }
- if(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc)
- {
- MAC_FREE(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu,\
- cellCb->dlSlot[idx].dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPduLen);
- MAC_FREE(cellCb->dlSlot[idx].dlInfo.dlMsgAlloc, sizeof(DlMsgAlloc));
- }
- }
-
- memset(cellCb, 0, sizeof(MacCellCb));
-}
-
-/*******************************************************************
- *
- * @brief Processes CELL delete response from scheduler
- *
- * @details
- *
- * Function : MacProcSchCellDeleteRsp
- *
- * Functionality:
- * Processes CELL delete from scheduler
- *
- * @params[in] Pst : Post structure
- * schCellDelRsp : Scheduler CELL delete respons
- * @return ROK - success
- * RFAILED - failure
- *
- * * ****************************************************************/
-uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp)
-{
- uint8_t ret = ROK;
- uint16_t cellIdx=0;
- CellDeleteStatus status;
-
- if(schCellDelRsp)
- {
- if(schCellDelRsp->rsp == RSP_OK)
- {
- DU_LOG("\nINFO --> MAC : SCH CELL Delete response for cellId[%d] is successful ", \
- schCellDelRsp->cellId);
- GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
- if(macCb.macCell[cellIdx])
- {
- if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
- {
- deleteMacCellCb(macCb.macCell[cellIdx]);
- status = SUCCESSFUL_RSP;
- MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
- }
- else
- {
- DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
- status = CELL_ID_INVALID;
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
- status = CELL_ID_INVALID;
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
- status = CELL_ID_INVALID;
- ret = RFAILED;
- }
- if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK)
- {
- DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
- ret = RFAILED;
- }
-
- }
- else
- {
- DU_LOG("\nERROR --> MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
- ret = RFAILED;
- }
- return ret;
-}
-
-/*******************************************************************
- *
- * @brief Sends Cell delete req to Scheduler
- *
- * @details
- *
- * Function : sendCellDelReqToSch
- *
- * Functionality: sends Cell delete req to Scheduler
- *
- * @params[in] SchCellDelete *schCellDel
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-
-uint8_t sendCellDelReqToSch(SchCellDelete *schCellDel)
-{
- Pst schPst;
- FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
- return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDel);
-}
-
-/*******************************************************************
- *
- * @brief Handles CELL Delete requst from DU APP
- *
- * @details
- *
- * Function : MacProcCellDeleteReq
- *
- * Functionality: Handles CELL Delete requst from DU APP
- *
- * @params[in] Pst *pst, MacCellDelete *cellDelete
- * @return ROK - success
- * RFAILED - failure
- *
- *
- * ****************************************************************/
-uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
-{
- uint8_t ret = ROK, cellIdx=0;
- SchCellDelete schCellDelete;
-
- DU_LOG("\nINFO --> MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
-
- if(cellDelete)
- {
- GET_CELL_IDX(cellDelete->cellId, cellIdx);
- if(macCb.macCell[cellIdx])
- {
- if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
- {
- memset(&schCellDelete, 0, sizeof(SchCellDelete));
- schCellDelete.cellId = cellDelete->cellId;
- ret = sendCellDelReqToSch(&schCellDelete);
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
- cellDelete->cellId);
- ret = RFAILED;
- }
- }
- else
- {
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
- cellDelete->cellId);
- ret = RFAILED;
- }
-
- if(ret == RFAILED)
- {
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Sending failure response to DU");
- if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK)
- {
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
- cellDelete->cellId);
- }
-
- }
- MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDelete));
- }
- else
- {
- DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
- ret = RFAILED;
- }
- return ret;
-}
-
/**********************************************************************
End of file
**********************************************************************/
Code Review / o-du / l2.git / blobdiff