+/*******************************************************************
+ *
+ * @brief Fills DCI for UL grant
+ *
+ * @details
+ *
+ * Function : schFillUlDci
+ *
+ * Functionality: fills DCI for UL grant in response to BSR
+ *
+ * @params[in] SchUeCb *ueCb, SchPuschInfo *puschInfo, DciInfo *dciInfo,
+ * @params[in] bool isRetx, SchUlHqProcCb *hqP
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t schFillUlDci(SchUeCb *ueCb, SchPuschInfo *puschInfo, DciInfo *dciInfo, bool isRetx, SchUlHqProcCb *hqP)
+{
+ SchCellCb *cellCb = ueCb->cellCb;
+ SchControlRsrcSet coreset1 ;
+
+ memset(&coreset1, 0, sizeof(SchControlRsrcSet));
+ if(ueCb->ueCfg.spCellCfgPres == true)
+ {
+ coreset1 = ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdcchCfg.cRSetToAddModList[0];
+ }
+
+ dciInfo->cellId = cellCb->cellId;
+ dciInfo->crnti = ueCb->crnti;
+
+ /* fill bwp cfg */
+ dciInfo->bwpCfg.subcarrierSpacing = cellCb->cellCfg.sib1SchCfg.bwp.subcarrierSpacing;
+ dciInfo->bwpCfg.cyclicPrefix = cellCb->cellCfg.sib1SchCfg.bwp.cyclicPrefix;
+ dciInfo->bwpCfg.freqAlloc.startPrb = cellCb->cellCfg.schInitialDlBwp.bwp.freqAlloc.startPrb;
+ dciInfo->bwpCfg.freqAlloc.numPrb = cellCb->cellCfg.schInitialDlBwp.bwp.freqAlloc.numPrb;
+
+ /*fill coreset cfg */
+ //Considering number of RBs in coreset1 is same as coreset0
+ dciInfo->coresetCfg.coreSetSize = coresetIdxTable[0][1];
+ //Considering coreset1 also starts from same symbol as coreset0
+ dciInfo->coresetCfg.startSymbolIndex = searchSpaceIdxTable[0][3];
+ dciInfo->coresetCfg.durationSymbols = coreset1.duration;
+ memcpy(dciInfo->coresetCfg.freqDomainResource, coreset1.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
+
+ dciInfo->coresetCfg.cceRegMappingType = coreset1.cceRegMappingType; /* non-interleaved */
+ dciInfo->coresetCfg.regBundleSize = 6; /* must be 6 for non-interleaved */
+ dciInfo->coresetCfg.interleaverSize = 0; /* NA for non-interleaved */
+ dciInfo->coresetCfg.coreSetType = 1; /* non PBCH coreset */
+ dciInfo->coresetCfg.shiftIndex = cellCb->cellCfg.phyCellId;
+ dciInfo->coresetCfg.precoderGranularity = coreset1.precoderGranularity;
+ dciInfo->coresetCfg.cceIndex = 0; /* 0-3 for UL and 4-7 for DL */
+ dciInfo->coresetCfg.aggregationLevel = 4; /* same as for sib1 */
+
+ dciInfo->formatType = FORMAT0_0;
+
+ /* fill UL grant */
+ dciInfo->format.format0_0.resourceAllocType = puschInfo->resAllocType;
+ dciInfo->format.format0_0.freqAlloc.startPrb = puschInfo->fdAlloc.startPrb;
+ dciInfo->format.format0_0.freqAlloc.numPrb = puschInfo->fdAlloc.numPrb;
+ dciInfo->format.format0_0.timeAlloc.startSymb = puschInfo->tdAlloc.startSymb;
+ dciInfo->format.format0_0.timeAlloc.numSymb = puschInfo->tdAlloc.numSymb;
+ dciInfo->format.format0_0.rowIndex = 0; /* row Index */
+ dciInfo->format.format0_0.mcs = puschInfo->tbInfo.mcs;
+ dciInfo->format.format0_0.harqProcId = puschInfo->harqProcId;
+ dciInfo->format.format0_0.puschHopFlag = FALSE; /* disabled */
+ dciInfo->format.format0_0.freqHopFlag = FALSE; /* disabled */
+ dciInfo->format.format0_0.ndi = puschInfo->tbInfo.ndi; /* new transmission */
+ dciInfo->format.format0_0.rv = puschInfo->tbInfo.rv;
+ dciInfo->format.format0_0.tpcCmd = 0; //Sphoorthi TODO: check
+ dciInfo->format.format0_0.sUlCfgd = FALSE; /* SUL not configured */
+
+ /* Fill DCI Structure */
+ dciInfo->dciInfo.rnti = ueCb->crnti;
+ dciInfo->dciInfo.scramblingId = cellCb->cellCfg.phyCellId;
+ dciInfo->dciInfo.scramblingRnti = 0;
+ dciInfo->dciInfo.cceIndex = 0; /* 0-3 for UL and 4-7 for DL */
+ dciInfo->dciInfo.aggregLevel = 4;
+ dciInfo->dciInfo.beamPdcchInfo.numPrgs = 1;
+ dciInfo->dciInfo.beamPdcchInfo.prgSize = 1;
+ dciInfo->dciInfo.beamPdcchInfo.digBfInterfaces = 0;
+ dciInfo->dciInfo.beamPdcchInfo.prg[0].pmIdx = 0;
+ dciInfo->dciInfo.beamPdcchInfo.prg[0].beamIdx[0] = 0;
+ dciInfo->dciInfo.txPdcchPower.powerValue = 0;
+ dciInfo->dciInfo.txPdcchPower.powerControlOffsetSS = 0;
+ dciInfo->dciInfo.pdschCfg = NULL; /* No DL data being sent */
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Function to Modify Ue Config request from MAC
+ *
+ * @details
+ *
+ * Function : MacSchModUeConfigReq
+ *
+ * Functionality: Function to modify Ue Config request from MAC
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t MacSchModUeConfigReq(Pst *pst, SchUeCfg *ueCfg)
+{
+ uint8_t ueId, lcIdx, ret = ROK;
+ SchCellCb *cellCb = NULLP;
+ SchUeCb *ueCb = NULLP;
+ SchUeCfgRsp cfgRsp;
+ Inst inst = pst->dstInst - SCH_INST_START;
+ memset(&cfgRsp, 0, sizeof(SchUeCfgRsp));
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_MODIFY_UE_CONFIG_REQ_TO_SCH\n");
+#endif
+
+ if(!ueCfg)
+ {
+ DU_LOG("\nERROR --> SCH : Modifying Ue Config request failed at MacSchModUeConfigReq()");
+ return RFAILED;
+ }
+ DU_LOG("\nDEBUG --> SCH : Modifying Ue Config Request for CRNTI[%d]", ueCfg->crnti);
+ cellCb = getSchCellCb(pst->event, inst, ueCfg);
+
+ /* Search if UE already configured */
+ GET_UE_ID(ueCfg->crnti, ueId);
+ ueCb = &cellCb->ueCb[ueId -1];
+
+ if(!ueCb)
+ {
+ DU_LOG("\nERROR --> SCH : SchUeCb not found at MacSchModUeConfigReq() ");
+ SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_NOK, &cfgRsp);
+ return RFAILED;
+ }
+ if((ueCb->crnti == ueCfg->crnti) && (ueCb->state == SCH_UE_STATE_ACTIVE))
+ {
+ /* Found the UeCb to Reconfig */
+ ret = fillSchUeCb(inst, ueCb, ueCfg);
+ if(ret == ROK)
+ {
+ ueCb->cellCb = cellCb;
+ ueCb->srRcvd = false;
+ ueCb->bsrRcvd = false;
+ for(lcIdx=0; lcIdx<MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcIdx++)
+ ueCb->bsrInfo[lcIdx].dataVol = 0;
+
+ SchSendUeCfgRspToMac(pst->event, ueCfg, inst, RSP_OK, &cfgRsp);
+ }
+ }
+ return ret;
+}
+
+/*******************************************************************
+*
+* @brief Fill and send UE delete response to MAC
+*
+* @details
+*
+* Function : SchSendUeDeleteRspToMac
+*
+* Functionality: Fill and send UE delete response to MAC
+*
+* @params[in] Inst inst, SchUeDelete *ueDelete, SchMacRsp result,
+* ErrorCause cause
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+void SchSendUeDeleteRspToMac(Inst inst, SchUeDelete *ueDelete, SchMacRsp result, ErrorCause cause)
+{
+ Pst rspPst;
+ SchUeDeleteRsp delRsp;
+
+ memset(&delRsp, 0, sizeof(SchUeDeleteRsp));
+ delRsp.cellId = ueDelete->cellId;
+ delRsp.crnti = ueDelete->crnti;
+ delRsp.rsp = result;
+ delRsp.cause = cause;
+
+ /* Filling response post */
+ memset(&rspPst, 0, sizeof(Pst));
+ FILL_PST_SCH_TO_MAC(rspPst, inst);
+ rspPst.event = EVENT_UE_DELETE_RSP_TO_MAC;
+ SchUeDeleteRspOpts[rspPst.selector](&rspPst, &delRsp);
+}
+
+/*******************************************************************
+*
+* @brief Function to delete Sch Pucch ResrcCfg
+*
+* @details
+*
+* Function : deleteSchPucchResrcCfg
+*
+* Functionality: Function to delete Sch Pucch ResrcCfg
+*
+* @params[in] SchPucchResrcCfg *resrc
+* @return void
+*
+* ****************************************************************/
+
+void deleteSchPucchResrcCfg(SchPucchResrcCfg *resrc)
+{
+ uint8_t rsrcIdx=0;
+ for(rsrcIdx=0; rsrcIdx < resrc->resrcToAddModListCount; rsrcIdx++)
+ {
+ switch(resrc->resrcToAddModList[rsrcIdx].pucchFormat)
+ {
+ case PUCCH_FORMAT_0:
+ {
+ SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format0,\
+ sizeof(SchPucchFormat0));
+ break;
+ }
+ case PUCCH_FORMAT_1:
+ {
+ SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format1,\
+ sizeof(SchPucchFormat1));
+ break;
+ }
+ case PUCCH_FORMAT_2:
+ {
+ SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format2,\
+ sizeof(SchPucchFormat2_3));
+ break;
+ }
+ case PUCCH_FORMAT_3:
+ {
+ SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format3,\
+ sizeof(SchPucchFormat2_3));
+ break;
+ }
+ case PUCCH_FORMAT_4:
+ {
+ SCH_FREE(resrc->resrcToAddModList[rsrcIdx].SchPucchFormat.format4,\
+ sizeof(SchPucchFormat4));
+ break;
+ }
+ }
+ }
+}
+
+/*******************************************************************
+*
+* @brief Function to delete SCH Pdsch ServCellCfg
+*
+* @details
+*
+* Function : deleteSchPdschServCellCfg
+*
+* Functionality: Function to delete SCH Pdsch ServCellCfg
+*
+* @params[in] SchPdschServCellCfg *pdschServCellCfg
+* @return void
+*
+* ****************************************************************/
+
+void deleteSchPdschServCellCfg(SchPdschServCellCfg *pdschServCellCfg)
+{
+ SCH_FREE(pdschServCellCfg->maxMimoLayers, sizeof(uint8_t));
+ SCH_FREE(pdschServCellCfg->maxCodeBlkGrpPerTb, sizeof(SchMaxCodeBlkGrpPerTB));
+ SCH_FREE(pdschServCellCfg->codeBlkGrpFlushInd, sizeof(bool));
+ SCH_FREE(pdschServCellCfg->xOverhead, sizeof(SchPdschXOverhead));
+}
+
+/*******************************************************************
+*
+* @brief Function to delete SCH UeCb
+*
+* @details
+*
+* Function : deleteSchUeCb
+*
+* Functionality: Function to delete SCH UeCb
+*
+* @params[in]
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+void deleteSchUeCb(SchUeCb *ueCb)
+{
+ uint8_t timeDomRsrcIdx = 0, ueLcIdx = 0, idx =0;
+ SchPucchCfg *pucchCfg = NULLP;
+ SchPdschConfig *pdschCfg = NULLP;
+
+ if(ueCb)
+ {
+ if(ueCb->hqDlmap)
+ {
+ for (idx = 0; idx<ueCb->cellCb->numSlots; idx++)
+ {
+ if(ueCb->hqDlmap[idx])
+ {
+ cmLListDeleteLList(&ueCb->hqDlmap[idx]->hqList);
+ SCH_FREE(ueCb->hqDlmap[idx], sizeof(SchHqDlMap));
+ }
+ }
+ SCH_FREE(ueCb->hqDlmap, sizeof(SchHqDlMap*)*(ueCb->cellCb->numSlots));
+ }
+
+ if(ueCb->hqUlmap)
+ {
+ for (idx = 0; idx<ueCb->cellCb->numSlots; idx++)
+ {
+ if(ueCb->hqUlmap[idx])
+ {
+ cmLListDeleteLList(&ueCb->hqUlmap[idx]->hqList);
+ SCH_FREE(ueCb->hqUlmap[idx], sizeof(SchHqUlMap));
+ }
+ }
+ SCH_FREE(ueCb->hqUlmap, sizeof(SchHqUlMap*)*(ueCb->cellCb->numSlots));
+ }
+
+ SCH_FREE(ueCb->ueCfg.ambrCfg, sizeof(SchAmbrCfg));
+ if(ueCb->ueCfg.spCellCfgPres)
+ {
+ if(ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfgPres == true)
+ {
+ pdschCfg = &ueCb->ueCfg.spCellCfg.servCellCfg.initDlBwp.pdschCfg;
+ for(timeDomRsrcIdx = 0; timeDomRsrcIdx < pdschCfg->numTimeDomRsrcAlloc; timeDomRsrcIdx++)
+ SCH_FREE(pdschCfg->timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
+ }
+
+ if(ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres == true)
+ {
+ pucchCfg = &ueCb->ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfg;
+ SCH_FREE(pucchCfg->resrcSet,sizeof(SchPucchResrcSetCfg));
+ if(pucchCfg->resrc)
+ {
+ deleteSchPucchResrcCfg(pucchCfg->resrc);
+ SCH_FREE(pucchCfg->resrc, sizeof(SchPucchResrcCfg));
+ }
+ SCH_FREE(pucchCfg->format1, sizeof(SchPucchFormatCfg));
+ SCH_FREE(pucchCfg->format2, sizeof(SchPucchFormatCfg));
+ SCH_FREE(pucchCfg->format3, sizeof(SchPucchFormatCfg));
+ SCH_FREE(pucchCfg->format4, sizeof(SchPucchFormatCfg));
+ SCH_FREE(pucchCfg->schedReq, sizeof(SchPucchSchedReqCfg));
+ SCH_FREE(pucchCfg->multiCsiCfg, sizeof(SchPucchMultiCsiCfg));
+ SCH_FREE(pucchCfg->spatialInfo, sizeof(SchPucchSpatialCfg));
+ SCH_FREE(pucchCfg->dlDataToUlAck, sizeof(SchPucchDlDataToUlAck));
+ SCH_FREE(pucchCfg->powerControl,sizeof(SchPucchPowerControl));
+ }
+ SCH_FREE(ueCb->ueCfg.spCellCfg.servCellCfg.bwpInactivityTmr, sizeof(uint8_t));
+ deleteSchPdschServCellCfg(&ueCb->ueCfg.spCellCfg.servCellCfg.pdschServCellCfg);
+ }
+ /*Need to Free the memory allocated for S-NSSAI*/
+ for(ueLcIdx = 0; ueLcIdx < MAX_NUM_LC; ueLcIdx++)
+ {
+ SCH_FREE(ueCb->ulInfo.ulLcCtxt[ueLcIdx].snssai, sizeof(Snssai));
+ SCH_FREE(ueCb->dlInfo.dlLcCtxt[ueLcIdx].snssai, sizeof(Snssai));
+ }
+
+ memset(ueCb, 0, sizeof(SchUeCb));
+ }
+}
+
+/*******************************************************************
+*
+* @brief Function for Ue Delete request from MAC to SCH
+*
+* @details
+*
+* Function : MacSchUeDeleteReq
+*
+* Functionality: Function for Ue Delete request from MAC to SCH
+*
+* @params[in] Pst *pst, SchUeDelete *ueDelete
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t MacSchUeDeleteReq(Pst *pst, SchUeDelete *ueDelete)
+{
+ uint8_t idx=0, ueId=0, ueIdToDel=0, ret=ROK;
+ ErrorCause result;
+ SchCellCb *cellCb = NULLP;
+ Inst inst = pst->dstInst - SCH_INST_START;
+ CmLList *node = NULL, *next = NULL;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_UE_DELETE_REQ_TO_SCH\n");
+#endif
+
+ if(!ueDelete)
+ {
+ DU_LOG("\nERROR --> SCH : MacSchUeDeleteReq(): Ue Delete request failed");
+ ret = RFAILED;
+ }
+ DU_LOG("\nDEBUG --> SCH : Ue Delete request received for crnti[%d]", ueDelete->crnti);
+
+ cellCb = schCb[inst].cells[idx];
+
+ if(cellCb->cellId != ueDelete->cellId)
+ {
+ DU_LOG("\nERROR --> SCH : MacSchUeDeleteReq(): cell Id is not available");
+ result = INVALID_CELLID;
+ }
+ else
+ {
+ GET_UE_ID(ueDelete->crnti, ueId);
+ if(( cellCb->ueCb[ueId-1].crnti == ueDelete->crnti) && ( cellCb->ueCb[ueId-1].state == SCH_UE_STATE_ACTIVE))
+ {
+ deleteSchUeCb(&cellCb->ueCb[ueId-1]);
+ ueIdToDel = ueId;
+ /* Remove UE from ueToBeScheduled list */
+ node = cellCb->ueToBeScheduled.first;
+ while(node)
+ {
+ next = node->next;
+ ueId = *(uint8_t *)node->node;
+ if(ueId == ueIdToDel)
+ {
+ SCH_FREE(node->node, sizeof(uint8_t));
+ deleteNodeFromLList(&cellCb->ueToBeScheduled, node);
+ break;
+ }
+ node = next;
+ }
+ cellCb->numActvUe--;
+ result = NOT_APPLICABLE;
+ }
+ else
+ {
+ DU_LOG("\nERROR --> SCH : MacSchUeDeleteReq(): SchUeCb not found");
+ result = INVALID_UEID;
+ }
+ }
+
+ if(result == NOT_APPLICABLE)
+ {
+ SchSendUeDeleteRspToMac(inst, ueDelete, RSP_OK, result);
+ }
+ else
+ {
+ SchSendUeDeleteRspToMac(inst, ueDelete, RSP_NOK, result);
+ ret = RFAILED;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Fill and send Cell delete response to MAC
+ *
+ * @details
+ *
+ * Function : SchSendCellDeleteRspToMac
+ *
+ * Functionality: Fill and send Cell delete response to MAC
+ *
+ * @params[in] SchCellDelete *ueDelete, Inst inst, SchMacRsp result
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t SchSendCellDeleteRspToMac(SchCellDelete *ueDelete, Inst inst, SchMacRsp result)
+{
+ Pst rspPst;
+ uint8_t ret=0;
+
+ SchCellDeleteRsp delRsp;
+
+ DU_LOG("\nINFO --> SCH : Filling Cell Delete response");
+ memset(&delRsp, 0, sizeof(SchCellDeleteRsp));
+ delRsp.cellId = ueDelete->cellId;
+ delRsp.rsp = result;
+
+ /* Filling response post */
+ memset(&rspPst, 0, sizeof(Pst));
+ FILL_PST_SCH_TO_MAC(rspPst, inst);
+ rspPst.event = EVENT_CELL_DELETE_RSP_TO_MAC;
+ ret = SchCellDeleteRspOpts[rspPst.selector](&rspPst, &delRsp);
+ if(ret == RFAILED)
+ {
+ DU_LOG("\nERROR --> SCH : SchSendCellDeleteRspToMac(): failed to send the Cell Delete response");
+ return ret;
+ }
+ return ret;
+}
+
+/*******************************************************************
+ *
+ * @brief Function for cellCb Deletion
+ *
+ * @details
+ *
+ * Function : deleteSchCellCb
+ *
+ * Functionality: Function for cellCb Deletion
+ *
+ * @params[in] SchCellDelete *cellDelete
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void deleteSchCellCb(SchCellCb *cellCb)
+{
+ uint8_t sliceIdx=0, slotIdx=0;
+ CmLListCp *list=NULL;
+ CmLList *node=NULL, *next=NULL;
+ SchPageInfo *tempNode = NULLP;
+
+ if(cellCb->schDlSlotInfo)
+ {
+ for(slotIdx=0; slotIdx<cellCb->numSlots; slotIdx++)
+ {
+ list = &cellCb->schDlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList;
+ node = list->first;
+ while(node)
+ {
+ next = node->next;
+ SCH_FREE(node->node, sizeof(FreePrbBlock));
+ deleteNodeFromLList(list, node);
+ node = next;
+ }
+ SCH_FREE(cellCb->schDlSlotInfo[slotIdx], sizeof(SchDlSlotInfo));
+ }
+ SCH_FREE(cellCb->schDlSlotInfo, cellCb->numSlots *sizeof(SchDlSlotInfo*));
+ }
+
+ if(cellCb->schUlSlotInfo)
+ {
+ for(slotIdx=0; slotIdx<cellCb->numSlots; slotIdx++)
+ {
+ list = &cellCb->schUlSlotInfo[slotIdx]->prbAlloc.freePrbBlockList;
+ node = list->first;
+ while(node)
+ {
+ next = node->next;
+ SCH_FREE(node->node, sizeof(FreePrbBlock));
+ deleteNodeFromLList(list, node);
+ node = next;
+ }
+ SCH_FREE(cellCb->schUlSlotInfo[slotIdx], sizeof(SchUlSlotInfo));
+ }
+ SCH_FREE(cellCb->schUlSlotInfo, cellCb->numSlots * sizeof(SchUlSlotInfo*));
+ }
+
+ if(cellCb->cellCfg.plmnInfoList.snssai)
+ {
+ for(sliceIdx=0; sliceIdx<cellCb->cellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
+ {
+ SCH_FREE(cellCb->cellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
+ }
+ SCH_FREE(cellCb->cellCfg.plmnInfoList.snssai, cellCb->cellCfg.plmnInfoList.numSliceSupport*sizeof(Snssai*));
+ }
+
+ for(uint16_t idx =0; idx<MAX_SFN; idx++)
+ {
+ list = &cellCb->pageCb.pageIndInfoRecord[idx];
+ node = list->first;
+ while(node)
+ {
+ next = node->next;
+ if(node->node)
+ {
+ tempNode = (SchPageInfo*)(node->node);
+ SCH_FREE(tempNode->pagePdu, tempNode->msgLen);
+ SCH_FREE(node->node, sizeof(SchPageInfo));
+ }
+ deleteNodeFromLList(list, node);
+ node = next;
+ }
+ }
+
+ /* Remove all UE from ueToBeScheduled list and deallocate */
+ node = cellCb->ueToBeScheduled.first;
+ while(node)
+ {
+ next = node->next;
+ SCH_FREE(node->node, sizeof(uint8_t));
+ cmLListDelFrm(&cellCb->ueToBeScheduled, node);
+ SCH_FREE(node, sizeof(CmLList));
+ node = next;
+ }
+
+ memset(cellCb, 0, sizeof(SchCellCb));
+
+}
+
+/*******************************************************************
+ *
+ * @brief Function for cell Delete request from MAC to SCH
+ *
+ * @details
+ *
+ * Function : MacSchCellDeleteReq
+ *
+ * Functionality: Function for cell Delete request from MAC to SCH
+ *
+ * @params[in] Pst *pst, SchCellDelete *cellDelete
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+
+uint8_t MacSchCellDeleteReq(Pst *pst, SchCellDelete *cellDelete)
+{
+ uint8_t cellIdx=0, ret = RFAILED;
+ Inst inst = pst->dstInst - SCH_INST_START;
+ SchMacRsp result= RSP_OK;
+
+#ifdef CALL_FLOW_DEBUG_LOG
+ DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CELL_DELETE_REQ_TO_SCH\n");
+#endif
+
+ if(!cellDelete)
+ {
+ DU_LOG("\nERROR --> SCH : MacSchCellDeleteReq(): Ue Delete request failed");
+ }
+ else
+ {
+ GET_CELL_IDX(cellDelete->cellId, cellIdx);
+ if(schCb[inst].cells[cellIdx] == NULLP)
+ {
+ DU_LOG("\nERROR --> SCH : MacSchCellDeleteReq(): cell Id[%d] is not available", cellDelete->cellId);
+ result = RSP_NOK;
+ }
+ else
+ {
+ if(schCb[inst].cells[cellIdx]->cellId == cellDelete->cellId)
+ {
+ deleteSchCellCb(schCb[inst].cells[cellIdx]);
+ result = RSP_OK;
+ ret = ROK;
+ SCH_FREE(schCb[inst].cells[cellIdx], sizeof(SchCellCb));
+ DU_LOG("\nINFO --> SCH : Sending Cell Delete response to MAC");
+ }
+ else
+ {
+ DU_LOG("\nERROR --> SCH : MacSchCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId);
+ result = RSP_NOK;
+ }
+ }
+
+ if(SchSendCellDeleteRspToMac(cellDelete, inst, result)!=ROK)
+ {
+ DU_LOG("\nERROR --> SCH : MacSchCellDeleteReq(): failed to send Cell Delete response");
+ ret = RFAILED;
+ }
+ }
+ return ret;
+}
+/*******************************************************************
+ *
+ * @brief Function updates DL HARQ Feedback
+ *
+ * @details
+ *
+ * Function : schUpdateHarqFdbk
+ *
+ * Functionality: Function updates DL HARQ feedback
+ *
+ * @params[in] SchUeCb *ueCb, UE cb struct pointer
+ * @params[in] uint8_t numHarq, number of HARQ processes in feedback
+ * @params[in] uint8_t *harqPayload, harq feedback payload received
+ * @params[in] SlotTimingInfo *slotInd, slot timing information
+ * @return void
+ *
+ * ****************************************************************/
+void schUpdateHarqFdbk(SchUeCb *ueCb, uint8_t numHarq, uint8_t *harqPayload, SlotTimingInfo *slotInd)
+{
+ SchDlHqProcCb *hqP;
+ SchHqDlMap *hqDlMap;
+ CmLList *node;
+ uint8_t fdbkPos = 0;
+
+ hqDlMap = ueCb->hqDlmap[slotInd->slot];
+
+ if (ueCb->cellCb->raCb[ueCb->ueId-1].raState == SCH_RA_STATE_MSG2_HANDLE)
+ {
+ return;
+ }
+ if (ueCb->cellCb->raCb[ueCb->ueId-1].raState != SCH_RA_STATE_MSG4_PENDING)
+ {
+ node = hqDlMap->hqList.first;
+ while(node)
+ {
+ hqP = (SchDlHqProcCb*)node->node;
+ node = node->next;
+ cmLListDelFrm(&hqDlMap->hqList, &hqP->ulSlotLnk);
+ /*
+ Decode harq feedback if needed post FAPI message decoding also or check how to decode this FAPI msg.
+ case 1 semi static harq Ack/Nack codebook //Supported
+ case 2 dynamic harq ACK/NACK codebook //Not supported
+ */
+ schDlHqFeedbackUpdate(hqP, harqPayload[fdbkPos++], HQ_TB_ACKED);//Marking 2nd TB as ACKED for now as only one TB to be used
+ }
+ }
+ else
+ {
+ node = hqDlMap->hqList.first;
+ hqP = (SchDlHqProcCb*)node->node;
+ cmLListDelFrm(&hqDlMap->hqList, &hqP->ulSlotLnk);
+ schMsg4FeedbackUpdate(hqP, harqPayload[fdbkPos++]);
+ }
+}