X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Fmac_cfg_hdl.c;h=fee5f4f77b54f112e14efba3c2a347239d10d4c5;hb=95d4c229dc30cec27c98ee66b5b689779a48dcc9;hp=65ca6a86ce3175d752f4ebe0d829451491e3882b;hpb=834004e09017b5b86cb738be98a7a1be79c0a9b0;p=o-du%2Fl2.git diff --git a/src/5gnrmac/mac_cfg_hdl.c b/src/5gnrmac/mac_cfg_hdl.c index 65ca6a86c..fee5f4f77 100644 --- a/src/5gnrmac/mac_cfg_hdl.c +++ b/src/5gnrmac/mac_cfg_hdl.c @@ -42,13 +42,26 @@ packMacCellCfgConfirm packMacCellCfmOpts[] = packMacCellCfgCfm, /* packing for light weight loosly coupled */ }; -SchCellCfgFunc SchCellCfgOpts[] = +MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] = { - packSchCellCfg, /* packing for loosely coupled */ - SchHdlCellCfgReq, /* packing for tightly coupled */ - packSchCellCfg /* packing for light weight loosly coupled */ + packDuMacCellDeleteRsp, /* packing for loosely coupled */ + DuProcMacCellDeleteRsp, /* packing for tightly coupled */ + packDuMacCellDeleteRsp /* packing for light weight loosly coupled */ }; +MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] = +{ + packDuMacSliceCfgRsp, /* packing for loosely coupled */ + DuProcMacSliceCfgRsp, /* packing for tightly coupled */ + packDuMacSliceCfgRsp /* packing for light weight loosly coupled */ +}; + +MacDuSliceRecfgRspFunc macDuSliceRecfgRspOpts[] = +{ + packDuMacSliceRecfgRsp, /* packing for loosely coupled */ + DuProcMacSliceRecfgRsp, /* packing for tightly coupled */ + packDuMacSliceRecfgRsp /* packing for light weight loosly coupled */ +}; /** * @brief Layer Manager Configuration request handler for Scheduler @@ -67,11 +80,13 @@ SchCellCfgFunc SchCellCfgOpts[] = **/ uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg) { - printf("\nReceived Scheduler gen config at MAC"); - pst->dstInst = DEFAULT_CELLS + 1; - SchProcGenCfgReq(pst, cfg); + Pst schPst; - return ROK; + DU_LOG("\nINFO --> MAC : Received Scheduler gen config at MAC"); + memset(&schPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG); + + return(SchMessageRouter(&schPst, (void *)cfg)); } /** @@ -91,7 +106,7 @@ uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg) **/ uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm) { - DU_LOG("\nDEBUG --> Sending Scheduler config confirm to DU APP"); + DU_LOG("\nDEBUG --> MAC : Sending Scheduler config confirm to DU APP"); pst->dstEnt = ENTDUAPP; pst->dstInst = 0; pst->srcInst = 0; @@ -120,8 +135,8 @@ uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm) uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) { Pst cfmPst; - uint16_t cellIdx; - uint8_t ret = ROK; + uint16_t cellIdx, scsInKhz = 0; + uint8_t ret = ROK, plmnIdx = 0,sliceIdx = 0; MacCellCb *macCellCb; memset((uint8_t *)&cfmPst, 0, sizeof(Pst)); @@ -137,18 +152,52 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) GET_CELL_IDX(macCellCfg->cellId, cellIdx); macCb.macCell[cellIdx] = macCellCb; macCb.macCell[cellIdx]->cellId = macCellCfg->cellId; + scsInKhz = convertScsEnumValToScsVal(macCellCfg->cellCfg.subCarrSpacing); + + /*Ref : 3GPP 38.211 Table 4.2-1: SCS = (2 ^ numerology * 15kHz)*/ + macCb.macCell[cellIdx]->numerology = log2(scsInKhz/BASE_SCS); + macCb.macCell[cellIdx]->numOfSlots = 10 * (1 << (macCb.macCell[cellIdx]->numerology)); memcpy(&macCb.macCell[cellIdx]->macCellCfg, macCellCfg, sizeof(MacCellCfg)); - MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \ - macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen); - if(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu == NULLP) + MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, \ + macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen); + if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu == NULLP) { DU_LOG("\nERROR --> MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n"); return RFAILED; } - memcpy(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1Pdu, \ - macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen); + memcpy(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, macCellCfg->cellCfg.sib1Cfg.sib1Pdu, \ + macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen); + for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) + { + macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].numSupportedSlice = macCellCfg->cellCfg.plmnInfoList[plmnIdx].numSupportedSlice; + MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai, macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].numSupportedSlice\ + * sizeof(Snssai*)); + if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai == NULLP) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq"); + return RFAILED; + } + + if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai) + { + for(sliceIdx=0; sliceIdxmacCellCfg.cellCfg.plmnInfoList[plmnIdx].numSupportedSlice; sliceIdx++) + { + if(macCellCfg->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx]) + { + MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai)); + if(!macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx]) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacProcCellCfgReq"); + return RFAILED; + } + memcpy(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], macCellCfg->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx],\ + sizeof(Snssai)); + } + } + } + } /* Send cell cfg to scheduler */ ret = MacSchCellCfgReq(pst, macCellCfg); if(ret != ROK) @@ -164,12 +213,6 @@ uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) } else { - if(macCellCfg->prachCfg.fdm[0].numUnusedRootSeq != 0) - { - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->prachCfg.fdm[0].unsuedRootSeq, - macCellCfg->prachCfg.fdm[0].numUnusedRootSeq* sizeof(uint8_t)); - } - MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen); MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg)); } return ret; @@ -193,105 +236,158 @@ uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg) { SchCellCfg schCellCfg; Pst cfgPst; - uint8_t ret =0; + uint8_t ssbMaskIdx = 0, rsrcListIdx = 0, sliceIdx=0, plmnIdx = 0; memset(&cfgPst, 0, sizeof(Pst)); memset(&schCellCfg, 0, sizeof(SchCellCfg)); schCellCfg.cellId = macCellCfg->cellId; - schCellCfg.phyCellId = macCellCfg->phyCellId; - schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw; - schCellCfg.numerology = macCellCfg->numerology; - schCellCfg.dupMode = macCellCfg->dupType; + schCellCfg.phyCellId = macCellCfg->cellCfg.phyCellId; - /* fill ssb scheduler parameters */ - schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr; - schCellCfg.ssbSchCfg.scsCommon = macCellCfg->ssbCfg.scsCmn; - schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA; - schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod]; - schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset; - for(uint8_t idx=0; idxssbCfg.ssbMask[idx]; + schCellCfg.plmnInfoList[plmnIdx].plmn = macCellCfg->cellCfg.plmnInfoList[plmnIdx].plmn; + if(macCellCfg->cellCfg.plmnInfoList[plmnIdx].snssai) + { + schCellCfg.plmnInfoList[plmnIdx].numSliceSupport = macCellCfg->cellCfg.plmnInfoList[plmnIdx].numSupportedSlice; + MAC_ALLOC(schCellCfg.plmnInfoList[plmnIdx].snssai, schCellCfg.plmnInfoList[plmnIdx].numSliceSupport * sizeof(Snssai*)); + if(!schCellCfg.plmnInfoList[plmnIdx].snssai) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq"); + return RFAILED; + } + for(sliceIdx=0; sliceIdxcellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx]) + { + MAC_ALLOC(schCellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai)); + if(!schCellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx]) + { + DU_LOG("\nERROR --> MAC: Memory allocation failed at MacSchCellCfgReq"); + return RFAILED; + } + memcpy(schCellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], macCellCfg->cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai)); + } + } + } } - /* fill SIB1 scheduler parameters */ - schCellCfg.sib1SchCfg.sib1PduLen = macCellCfg->sib1Cfg.sib1PduLen; - schCellCfg.sib1SchCfg.sib1NewTxPeriod = macCellCfg->sib1Cfg.sib1NewTxPeriod; - schCellCfg.sib1SchCfg.sib1RepetitionPeriod = macCellCfg->sib1Cfg.sib1RepetitionPeriod; - schCellCfg.sib1SchCfg.coresetZeroIndex = macCellCfg->sib1Cfg.coresetZeroIndex; - schCellCfg.sib1SchCfg.searchSpaceZeroIndex = macCellCfg->sib1Cfg.searchSpaceZeroIndex; - schCellCfg.sib1SchCfg.sib1Mcs = macCellCfg->sib1Cfg.sib1Mcs; + schCellCfg.dupMode = macCellCfg->cellCfg.dupType; + schCellCfg.dlBandwidth = macCellCfg->carrCfg.dlBw; + schCellCfg.ulBandwidth = macCellCfg->carrCfg.ulBw; - /* fill RACH config params */ - schCellCfg.schRachCfg.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx; - schCellCfg.schRachCfg.prachSubcSpacing = \ - macCellCfg->prachCfg.prachSubcSpacing; - schCellCfg.schRachCfg.msg1FreqStart = macCellCfg->prachCfg.msg1FreqStart; - schCellCfg.schRachCfg.msg1Fdm = macCellCfg->prachCfg.msg1Fdm; - schCellCfg.schRachCfg.rootSeqLen = macCellCfg->prachCfg.rootSeqLen; - schCellCfg.schRachCfg.rootSeqIdx = macCellCfg->prachCfg.fdm[0].rootSeqIdx; - schCellCfg.schRachCfg.numRootSeq = macCellCfg->prachCfg.fdm[0].numRootSeq; - schCellCfg.schRachCfg.k1 = macCellCfg->prachCfg.fdm[0].k1; - schCellCfg.schRachCfg.ssbPerRach = macCellCfg->prachCfg.ssbPerRach; - schCellCfg.schRachCfg.prachMultCarrBand = \ - macCellCfg->prachCfg.prachMultCarrBand; - schCellCfg.schRachCfg.raContResTmr = macCellCfg->prachCfg.raContResTmr; - schCellCfg.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb; - schCellCfg.schRachCfg.raRspWindow = macCellCfg->prachCfg.raRspWindow; + schCellCfg.dlCfgCommon.schFreqInfoDlSib.offsetToPointA = macCellCfg->ssbCfg.ssbOffsetPointA; + schCellCfg.dlCfgCommon.schFreqInfoDlSib.schSpcCarrier[0].subCarrierSpacing = macCellCfg->ssbCfg.scsCmn; /* fill initial DL BWP */ - schCellCfg.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialDlBwp.bwp.firstPrb; - schCellCfg.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialDlBwp.bwp.numPrb; - schCellCfg.schInitialDlBwp.bwp.scs = macCellCfg->initialDlBwp.bwp.scs; - schCellCfg.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->initialDlBwp.bwp.cyclicPrefix; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.coresetId; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.duration; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8; - schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 = - macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16; - schCellCfg.schInitialDlBwp.pdschCommon.k0 = macCellCfg->initialDlBwp.pdschCommon.k0; - schCellCfg.schInitialDlBwp.pdschCommon.mappingType = - macCellCfg->initialDlBwp.pdschCommon.mappingType; - schCellCfg.schInitialDlBwp.pdschCommon.startSymbol = - macCellCfg->initialDlBwp.pdschCommon.startSymbol; - schCellCfg.schInitialDlBwp.pdschCommon.lengthSymbol = - macCellCfg->initialDlBwp.pdschCommon.lengthSymbol; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->cellCfg.initialDlBwp.bwp.firstPrb; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->cellCfg.initialDlBwp.bwp.numPrb; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.scs = macCellCfg->cellCfg.initialDlBwp.bwp.scs; + schCellCfg.dlCfgCommon.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->cellCfg.initialDlBwp.bwp.cyclicPrefix; + + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.coresetId; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.duration; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 = + macCellCfg->cellCfg.initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16; + + schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->cellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc; + for(rsrcListIdx = 0; rsrcListIdxcellCfg.initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++) + { + schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 = + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType = + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol = + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; + schCellCfg.dlCfgCommon.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol = + macCellCfg->cellCfg.initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol; + } + + /* fill SIB1 scheduler parameters */ + schCellCfg.dlCfgCommon.schPcchCfg.numPO = macCellCfg->cellCfg.sib1Cfg.pagingCfg.numPO; + schCellCfg.dlCfgCommon.schPcchCfg.poPresent = macCellCfg->cellCfg.sib1Cfg.pagingCfg.poPresent; + if(schCellCfg.dlCfgCommon.schPcchCfg.poPresent) + { + memcpy(schCellCfg.dlCfgCommon.schPcchCfg.pagingOcc, macCellCfg->cellCfg.sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF); + } /* fill initial UL BWP */ - schCellCfg.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb; - schCellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb; - schCellCfg.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs; - schCellCfg.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix; - schCellCfg.schInitialUlBwp.puschCommon.k2 = macCellCfg->initialUlBwp.puschCommon.k2; - schCellCfg.schInitialUlBwp.puschCommon.mappingType = - macCellCfg->initialUlBwp.puschCommon.mappingType; - schCellCfg.schInitialUlBwp.puschCommon.startSymbol = - macCellCfg->initialUlBwp.puschCommon.startSymbol; - schCellCfg.schInitialUlBwp.puschCommon.lengthSymbol = - macCellCfg->initialUlBwp.puschCommon.lengthSymbol; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->cellCfg.initialUlBwp.bwp.firstPrb; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.scs = macCellCfg->cellCfg.initialUlBwp.bwp.scs; + schCellCfg.ulCfgCommon.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix; + /* fill RACH config params */ + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1Fdm = macCellCfg->prachCfg.msg1Fdm; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.msg1FreqStart = macCellCfg->prachCfg.msg1FreqStart; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.zeroCorrZoneCfg = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.prachCfgGeneric.raRspWindow = macCellCfg->prachCfg.raRspWindow; + + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.totalNumRaPreamble = macCellCfg->prachCfg.totalNumRaPreamble; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.ssbPerRach = macCellCfg->prachCfg.ssbPerRach; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.numCbPreamblePerSsb = macCellCfg->prachCfg.numCbPreamblePerSsb; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.raContResTmr = macCellCfg->prachCfg.raContResTmr; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.rootSeqIdx = macCellCfg->prachCfg.fdm[0].rootSeqIdx; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.numRootSeq = macCellCfg->prachCfg.fdm[0].numRootSeq; + schCellCfg.ulCfgCommon.schInitialUlBwp.schRachCfg.msg1SubcSpacing = \ + macCellCfg->prachCfg.prachSubcSpacing; + + schCellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon.pucchResourceCommon = \ + macCellCfg->cellCfg.initialUlBwp.pucchCommon.pucchResourceCommon; + schCellCfg.ulCfgCommon.schInitialUlBwp.pucchCommon.pucchGroupHopping = \ + macCellCfg->cellCfg.initialUlBwp.pucchCommon.pucchGroupHopping; + schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \ + macCellCfg->cellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc; + for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->cellCfg.initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++) + { + schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 = + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2; + schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType = + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType; + schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol = + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol; + schCellCfg.ulCfgCommon.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength = + macCellCfg->cellCfg.initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength; + } + #ifdef NR_TDD memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg)); #endif + /* fill ssb scheduler parameters */ + for(ssbMaskIdx=0; ssbMaskIdxssbCfg.ssbMask[ssbMaskIdx]; + } + schCellCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod]; + schCellCfg.ssbFrequency = macCellCfg->cellCfg.ssbFreq; + schCellCfg.dmrsTypeAPos = macCellCfg->ssbCfg.dmrsTypeAPos; + schCellCfg.ssbScs = macCellCfg->cellCfg.subCarrSpacing; + schCellCfg.pdcchCfgSib1.coresetZeroIndex = macCellCfg->cellCfg.sib1Cfg.pdcchCfgSib1.coresetZeroIndex; + schCellCfg.pdcchCfgSib1.searchSpaceZeroIndex = macCellCfg->cellCfg.sib1Cfg.pdcchCfgSib1.searchSpaceZeroIndex; + schCellCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr; + schCellCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset; + schCellCfg.sib1PduLen = macCellCfg->cellCfg.sib1Cfg.sib1PduLen; + FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG); - ret = (*SchCellCfgOpts[cfgPst.selector])(&cfgPst, &schCellCfg); - return ret; + return(SchMessageRouter(&cfgPst, (void *)&schCellCfg)); } /* end of MacSchCellCfgReq */ @@ -348,6 +444,10 @@ uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm) { uint16_t *cellId = NULLP; +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n"); +#endif + if(schCellCfgCfm->rsp == RSP_OK) { cellId = &schCellCfgCfm->cellId; @@ -388,6 +488,532 @@ void fapiMacConfigRsp(uint16_t cellId) MacSendCellCfgCfm(cellId, RSP_OK); } +/******************************************************************* + * + * @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(CauseOfResult status, 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 */ + + memset(deleteRsp, 0, sizeof(MacCellDeleteRsp)); + deleteRsp->cellId = cellId; + deleteRsp->status = status; + + /* 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 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, sliceIdx = 0, plmnIdx = 0; + uint16_t cellIdx=0; + CauseOfResult cause; + +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n"); +#endif + + 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) + { + cause = SUCCESSFUL; + for(plmnIdx = 0; plmnIdx < MAX_PLMN; plmnIdx++) + { + if(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai) + { + for(sliceIdx = 0; sliceIdxmacCellCfg.cellCfg.plmnInfoList[plmnIdx].numSupportedSlice; sliceIdx++) + { + MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai[sliceIdx], sizeof(Snssai)); + } + MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].snssai, macCb.macCell[cellIdx]->macCellCfg.cellCfg.plmnInfoList[plmnIdx].\ + numSupportedSlice * sizeof(Snssai*)); + } + } + MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1Pdu, \ + macCb.macCell[cellIdx]->macCellCfg.cellCfg.sib1Cfg.sib1PduLen); + MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb)); + } + else + { + DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); + cause = CELLID_INVALID; + ret = RFAILED; + } + } + else + { + DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); + cause = CELLID_INVALID; + ret = RFAILED; + } + } + else + { + DU_LOG("ERROR --> MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId); + cause = CELLID_INVALID; + ret = RFAILED; + } + if(MacSendCellDeleteRsp(cause, 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(SchCellDeleteReq *schCellDelReq) +{ + Pst schPst; + FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH); + return(SchMessageRouter(&schPst, (void *)schCellDelReq)); +} + +/******************************************************************* + * + * @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, MacCellDeleteReq *cellDelete) +{ + uint8_t ret = ROK, cellIdx=0; + SchCellDeleteReq 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(SchCellDeleteReq )); + 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(CELLID_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(MacCellDeleteReq)); + } + else + { + DU_LOG("\nERROR --> MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL"); + ret = RFAILED; + } + return ret; +} + +/** + * @brief free the temporary slice cfg stored in macCb. + * + * @details + * + * Function : freeMacSliceCfgReq + * + * free the temporary slice cfg stored in macCb + * + * @param[in] + * @return int + * -# ROK + **/ +void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst) +{ + uint8_t policyIdx = 0, memberListIdx=0; + + if(cfgReq->numOfRrmPolicy) + { + if(cfgReq->listOfRrmPolicy) + { + for(policyIdx = 0; policyIdxnumOfRrmPolicy; policyIdx++) + { + if(cfgReq->listOfRrmPolicy[policyIdx]) + { + if(cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem) + { + if(cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList) + { + for(memberListIdx = 0; memberListIdxlistOfRrmPolicy[policyIdx]->numOfRrmPolicyMem; memberListIdx++) + { + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList[memberListIdx], sizeof(RrmPolicyMemberList)); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx]->rRMPolicyMemberList,\ + cfgReq->listOfRrmPolicy[policyIdx]->numOfRrmPolicyMem * sizeof(RrmPolicyMemberList*)); + } + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy[policyIdx], sizeof(MacSliceRrmPolicy)); + } + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfRrmPolicy, cfgReq->numOfRrmPolicy * sizeof(MacSliceRrmPolicy*)); + } + } + +} + +/** + * @brief send slice cfg response to duapp. + * + * @details + * + * Function : MacSendSliceConfigRsp + * + * sends slice cfg response to duapp + * + * @param[in] MacSliceCfgRsp macSliceCfgRsp + * @return int + * -# ROK + **/ +uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp) +{ + Pst rspPst; + + memset(&rspPst, 0, sizeof(Pst)); + FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP); + return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp); + +} + +/** + * @brief Mac process the slice cfg rsp received from sch. + * + * @details + * + * Function : MacProcSchSliceCfgRsp + * + * This function process the slice cfg rsp received from sch + * + * @param[in] Pst *pst + * @param[in] SchSliceCfgRsp *sliceCfgrsp + * @return int + * -# ROK + **/ + +uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp) +{ + MacSliceCfgRsp *macSliceCfgRsp = NULLP; + + if(schSliceCfgRsp) + { + MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp)); + if(macSliceCfgRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceCfgRsp"); + return RFAILED; + } + macSliceCfgRsp->snssai = schSliceCfgRsp->snssai; + if(schSliceCfgRsp->rsp == RSP_OK) + macSliceCfgRsp->rsp = MAC_DU_APP_RSP_OK; + else + { + macSliceCfgRsp->rsp = MAC_DU_APP_RSP_NOK; + } + macSliceCfgRsp->cause = schSliceCfgRsp->cause; + MacSendSliceConfigRsp(macSliceCfgRsp); + } + return ROK; +} + +/** + * @brief send slice cfg response to duapp. + * + * @details + * + * Function : MacSendSliceReconfigRsp + * + * sends slice cfg response to duapp + * + * @param[in] MacSliceRecfgRsp macSliceRecfgRsp + * @return int + * -# ROK + **/ +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); + +} + +/** + * @brief Mac process the slice cfg rsp received from sch. + * + * @details + * + * Function : MacProcSchSliceRecfgRsp + * + * This function process the slice cfg rsp received from sch + * + * @param[in] Pst *pst + * @param[in] SchSliceCfgRsp *schSliceRecfgRsp + * @return int + * -# ROK + **/ +uint8_t MacProcSchSliceRecfgRsp(Pst *pst, SchSliceRecfgRsp *schSliceRecfgRsp) +{ + MacSliceRecfgRsp *macSliceRecfgRsp = NULLP; + + if(schSliceRecfgRsp) + { + MAC_ALLOC_SHRABL_BUF(macSliceRecfgRsp, sizeof(MacSliceRecfgRsp)); + if(macSliceRecfgRsp == NULLP) + { + DU_LOG("\nERROR --> MAC : Failed to allocate memory in MacProcSchSliceRecfgRsp"); + return RFAILED; + } + + macSliceRecfgRsp->snssai = schSliceRecfgRsp->snssai; + if(schSliceRecfgRsp->rsp == RSP_OK) + macSliceRecfgRsp->rsp = MAC_DU_APP_RSP_OK; + else + { + macSliceRecfgRsp->rsp = MAC_DU_APP_RSP_NOK; + } + macSliceRecfgRsp->cause = schSliceRecfgRsp->cause; + MacSendSliceReconfigRsp(macSliceRecfgRsp); + } + return ROK; +} + +/** + * @brief Mac process the downlink pcch indication received from DUAPP + * + * @details + * + * Function : MacProcDlPcchInd + * + * This function process the downlink pcch indication received from DUAPP + * + * @param[in] Pst *pst + * @param[in] DlPcchInd *pcchInd + * @return int + * -# ROK + **/ +uint8_t MacProcDlPcchInd(Pst *pst, DlPcchInd *pcchInd) +{ + uint8_t ret = RFAILED; + uint16_t cellIdx = 0; + Pst schPst; + SchPageInd *schPageInd = NULLP; + + if(pcchInd) + { + DU_LOG("\nINFO --> MAC : Received DL PCCH IND from DU_APP for cellId[%d]", pcchInd->cellId); + + GET_CELL_IDX(pcchInd->cellId, cellIdx); + + if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != pcchInd->cellId) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): CellId[%d] does not exist", pcchInd->cellId); + } + else + { + if((pcchInd->pcchPdu == NULLP) || (pcchInd->pduLen <= 0)) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Received Pcch pdu is null"); + } + else + { + MAC_ALLOC(schPageInd, sizeof(SchPageInd)); + if(schPageInd == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory"); + } + else + { + schPageInd->cellId = pcchInd->cellId; + schPageInd->pf = pcchInd->pf; + schPageInd->i_s = pcchInd->i_s; + schPageInd->pduLen = pcchInd->pduLen; + + MAC_ALLOC(schPageInd->pagePdu, pcchInd->pduLen); + if(schPageInd->pagePdu == NULLP) + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Failed to allocate memory"); + MAC_FREE(schPageInd, sizeof(SchPageInd)); + } + else + { + memcpy(schPageInd->pagePdu, pcchInd->pcchPdu, pcchInd->pduLen); + + FILL_PST_MAC_TO_SCH(schPst, EVENT_PAGING_IND_TO_SCH); + ret = SchMessageRouter(&schPst, (void *)schPageInd); + } + } + } + } + if((pcchInd->pcchPdu) && (pcchInd->pduLen > 0)) + { + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd->pcchPdu, pcchInd->pduLen); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, pcchInd, sizeof(DlPcchInd)); + } + else + { + DU_LOG("\nERROR --> MAC : MacProcDlPcchInd(): Received Null pointer"); + } + return ret; +} + +/** + * @brief Mac process the downlink Broadcast Req received from DUAPP + * + * @details + * + * Function : MacProcDlBroadcastReq + * + * This function process the downlink Broadcast Req received from DUAPP + * + * @param[in] Pst *pst + * @param[in] DlBroadcastReq *dlBroadcastReq + * @return int + * -# ROK + **/ +uint8_t MacProcDlBroadcastReq(Pst *pst, MacDlBroadcastReq *dlBroadcastReq) +{ + uint8_t ret = ROK, idx=0; + uint16_t cellIdx = 0; + + if(dlBroadcastReq) + { + DU_LOG("\nINFO --> MAC : Received DL braodcast req from DU_APP for cellId[%d]", dlBroadcastReq->cellId); + + GET_CELL_IDX(dlBroadcastReq->cellId, cellIdx); + + if(macCb.macCell[cellIdx] == NULLP || macCb.macCell[cellIdx]->cellId != dlBroadcastReq->cellId) + { + ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcDlBroadcastReq(): CellId[%d] does not exist", dlBroadcastReq->cellId); + } + else + { + /*TODO - Complete the processing of DL Broadcast Request*/ + } + for(idx = 0; idxnumSiBlock; idx++) + { + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq->siSchedulingInfo[idx]->siAreaID, sizeof(uint8_t)); + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq->siSchedulingInfo[idx], sizeof(SiSchedulingInfo)); + } + MAC_FREE_SHRABL_BUF(pst->region, pst->pool, dlBroadcastReq, sizeof(MacDlBroadcastReq)); + } + else + { + ret = RFAILED; + DU_LOG("\nERROR --> MAC : MacProcDlBroadcastReq(): Received Null pointer"); + } + return ret; +} /********************************************************************** End of file **********************************************************************/