X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch.c;h=5eb32b1e3d033e35d1fdfdb57497033ae940b66a;hb=6636207100c598cd70537d177670ef131e263931;hp=fe18fec2efe14a32717edaa854c2bbda69e2f811;hpb=b5a77f556b20a2acd7d653367fdcac030461f85b;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch.c b/src/5gnrsch/sch.c index fe18fec2e..5eb32b1e3 100644 --- a/src/5gnrsch/sch.c +++ b/src/5gnrsch/sch.c @@ -47,31 +47,8 @@ #include "mac_sch_interface.h" #include "sch.h" #include "sch_utils.h" +#include "sch_fcfs.h" -void SchFillCfmPst(Pst *reqPst,Pst *cfmPst,RgMngmt *cfm); - -/* local defines */ -SchCellCfgCfmFunc SchCellCfgCfmOpts[] = -{ - packSchCellCfgCfm, /* LC */ - MacProcSchCellCfgCfm, /* TC */ - packSchCellCfgCfm /* LWLC */ -}; - -SchSliceCfgRspFunc SchSliceCfgRspOpts[] = -{ - packSchSliceCfgRsp, /* LC */ - MacProcSchSliceCfgRsp, /* TC */ - packSchSliceCfgRsp /* LWLC */ - -}; - -SchSliceReCfgRspFunc SchSliceReCfgRspOpts[] = -{ - packSchSliceReCfgRsp, /* LC */ - MacProcSchSliceReCfgRsp, /* TC */ - packSchSliceReCfgRsp /* LWLC */ -}; /** * @brief Task Initiation function. * @@ -113,6 +90,24 @@ uint8_t schActvInit(Ent entity, Inst instId, Region region, Reason reason) return ROK; } /* schActvInit */ +/** + * @brief Scheduler All Apis initialized. + * + * @details + * + * Function : schAllApisInit + * + * This function initializes all Scheduler APIs/functionality for each kind + * of scheduler type. + * + * @param[in] Inst inst, the Scheduler instance + * @return void + **/ +void schAllApisInit(Inst inst) +{ + schFcfsAllApisInit(&schCb[inst].allApis[SCH_FCFS]); +} + /** * @brief Scheduler instance Configuration Handler. * @@ -178,7 +173,8 @@ uint8_t SchInstCfg(RgCfg *cfg, Inst dInst) /* Set Config done in TskInit */ schCb[inst].schInit.cfgDone = TRUE; DU_LOG("\nINFO --> SCH : Scheduler gen config done"); - + + schAllApisInit(inst); return ret; } @@ -207,10 +203,6 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) RgMngmt cfm; Pst cfmPst; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : GENERAL_CFG_REQ\n"); -#endif - if(pst->dstInst < SCH_INST_START) { DU_LOG("\nERROR --> SCH : Invalid inst ID"); @@ -257,102 +249,6 @@ uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg) return ROK; }/*-- SchProcGenCfgReq --*/ -/** - * @brief slot indication from MAC to SCH. - * - * @details - * - * Function : MacSchSlotInd - * - * This API is invoked by PHY to indicate slot indication to Scheduler for - * a cell. - * - * @param[in] Pst *pst - * @param[in] SlotTimingInfo *slotInd - * @return S16 - * -# ROK - * -# RFAILED - **/ -uint8_t MacSchSlotInd(Pst *pst, SlotTimingInfo *slotInd) -{ - Inst inst = pst->dstInst-SCH_INST_START; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SLOT_IND_TO_SCH\n"); -#endif - - schProcessSlotInd(slotInd, inst); - - return ROK; -} /* MacSchSlotInd */ - -/******************************************************************* - * - * @brief Processes Rach indication from MAC - * - * @details - * - * Function : MacSchRachInd - * - * Functionality: - * Processes Rach indication from MAC - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t MacSchRachInd(Pst *pst, RachIndInfo *rachInd) -{ - Inst inst = pst->dstInst-SCH_INST_START; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_RACH_IND_TO_SCH\n"); -#endif - - DU_LOG("\nINFO --> SCH : Received Rach indication"); - schProcessRachInd(rachInd, inst); - return ROK; -} - -/******************************************************************* - * - * @brief Processes CRC indication from MAC - * - * @details - * - * Function : MacSchCrcInd - * - * Functionality: - * Processes CRC indication from MAC - * - * @params[in] Post structure - * Crc Indication - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t MacSchCrcInd(Pst *pst, CrcIndInfo *crcInd) -{ -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_CRC_IND_TO_SCH\n"); -#endif - - switch(crcInd->crcInd[0]) - { - case CRC_FAILED: - DU_LOG("\nDEBUG --> SCH : Received CRC indication. CRC Status [FAILURE]"); - break; - case CRC_PASSED: - DU_LOG("\nDEBUG --> SCH : Received CRC indication. CRC Status [PASS]"); - break; - default: - DU_LOG("\nDEBUG --> SCH : Invalid CRC state %d", crcInd->crcInd[0]); - return RFAILED; - } - return ROK; -} - #ifdef NR_TDD /** *@brief Returns TDD periodicity in micro seconds @@ -674,7 +570,10 @@ uint8_t schInitCellCb(Inst inst, SchCellCfg *schCellCfg) cell->firstSsbTransmitted = false; cell->firstSib1Transmitted = false; fillSsbStartSymb(cell); - cmLListInit(&cell->ueToBeScheduled); + +#ifdef NR_DRX + memset(cell->drxCb, 0, MAX_DRX_SIZE*sizeof(SchDrxCb)); +#endif schCb[inst].cells[inst] = cell; DU_LOG("\nINFO --> SCH : Cell init completed for cellId:%d", cell->cellId); @@ -859,7 +758,7 @@ void fillSchSib1Cfg(uint8_t mu, uint8_t bandwidth, uint8_t numSlots, SchSib1Cfg * -# ROK * -# RFAILED **/ -uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) +uint8_t SchProcCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) { uint8_t ret = ROK; SchCellCb *cellCb; @@ -872,10 +771,6 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0}; SchPdschConfig pdschCfg; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SCH_CELL_CFG\n"); -#endif - schInitCellCb(inst, schCellCfg); cellCb = schCb[inst].cells[inst]; //cells is of MAX_CELLS, why inst cellCb->macInst = pst->srcInst; @@ -908,6 +803,15 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) cellCb->actvUeBitMap = 0; cellCb->boIndBitMap = 0; + cellCb->cellCfg.schHqCfg.maxDlDataHqTx = SCH_MAX_NUM_DL_HQ_TX; + cellCb->cellCfg.schHqCfg.maxMsg4HqTx = SCH_MAX_NUM_MSG4_TX; + cellCb->cellCfg.schHqCfg.maxUlDataHqTx = SCH_MAX_NUM_UL_HQ_TX; + cellCb->cellCfg.schRachCfg.maxMsg3Tx = SCH_MAX_NUM_MSG3_TX; + + cellCb->schAlgoType = SCH_FCFS; + cellCb->api = &schCb[inst].allApis[cellCb->schAlgoType]; /* For FCFS */ + cellCb->api->SchCellCfgReq(cellCb); + /* Fill and send Cell config confirm */ memset(&rspPst, 0, sizeof(Pst)); FILL_PST_SCH_TO_MAC(rspPst, pst->dstInst); @@ -916,9 +820,198 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) schCellCfgCfm.cellId = schCellCfg->cellId; schCellCfgCfm.rsp = RSP_OK; - ret = (*SchCellCfgCfmOpts[rspPst.selector])(&rspPst, &schCellCfgCfm); + ret = MacMessageRouter(&rspPst, (void *)&schCellCfgCfm); + 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(SchCellDeleteReq *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 = MacMessageRouter(&rspPst, (void *)&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; slotIdxnumSlots; 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; slotIdxnumSlots; 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; sliceIdxcellCfg.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; idxpageCb.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; + } + } + + cellCb->api->SchCellDeleteReq(cellCb); + + memset(cellCb, 0, sizeof(SchCellCb)); +} + +/******************************************************************* + * + * @brief Function for cell Delete request from MAC to SCH + * + * @details + * + * Function : SchProcCellDeleteReq + * + * Functionality: Function for cell Delete request from MAC to SCH + * + * @params[in] Pst *pst, SchCellDelete *cellDelete + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcCellDeleteReq(Pst *pst, SchCellDeleteReq *cellDelete) +{ + uint8_t cellIdx=0, ret = RFAILED; + Inst inst = pst->dstInst - SCH_INST_START; + SchMacRsp result= RSP_OK; + + if(!cellDelete) + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): Ue Delete request failed"); + } + else + { + GET_CELL_IDX(cellDelete->cellId, cellIdx); + if(schCb[inst].cells[cellIdx] == NULLP) + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): 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 : SchProcCellDeleteReq(): cell Id[%d] is not available",cellDelete->cellId); + result = RSP_NOK; + } + } + if(SchSendCellDeleteRspToMac(cellDelete, inst, result)!=ROK) + { + DU_LOG("\nERROR --> SCH : SchProcCellDeleteReq(): failed to send Cell Delete response"); + ret = RFAILED; + } + } + return ret; } /******************************************************************* @@ -927,7 +1020,7 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) * * @details * - * Function : MacSchDlRlcBoInfo + * Function : SchProcDlRlcBoInfo * * Functionality: * Processes DL RLC BO info from MAC @@ -937,26 +1030,21 @@ uint8_t SchHdlCellCfgReq(Pst *pst, SchCellCfg *schCellCfg) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) +uint8_t SchProcDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) { uint8_t lcId = 0; uint16_t ueId = 0; bool isLcIdValid = false; SchUeCb *ueCb = NULLP; SchCellCb *cell = NULLP; - Inst inst = pst->dstInst-SCH_INST_START; - CmLListCp *lcLL = NULLP; - -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_DL_RLC_BO_INFO_TO_SCH\n"); -#endif + Inst inst = pst->dstInst-SCH_INST_START; DU_LOG("\nDEBUG --> SCH : Received RLC BO Status indication LCId [%d] BO [%d]", dlBoInfo->lcId, dlBoInfo->dataVolume); cell = schCb[inst].cells[inst]; if(cell == NULLP) { - DU_LOG("\nERROR --> SCH : MacSchDlRlcBoInfo(): Cell does not exists"); + DU_LOG("\nERROR --> SCH : SchProcDlRlcBoInfo(): Cell does not exists"); return RFAILED; } @@ -981,28 +1069,20 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) *Thus clearing out the LC from the Lc priority list*/ if(dlBoInfo->dataVolume == 0) { - /*Check the LC is Dedicated or default and accordingly LCList will - * be used*/ - if(ueCb->dlInfo.dlLcCtxt[lcId].isDedicated) - { - lcLL = &(ueCb->dlLcPrbEst.dedLcInfo->dedLcList); - } - else - { - lcLL = &(ueCb->dlLcPrbEst.defLcList); - } - handleLcLList(lcLL, lcId, DELETE); + /* TODO : Check the LC is Dedicated or default and accordingly LCList + * will be used*/ return ROK; } if(lcId == SRB0_LCID) { cell->raCb[ueId -1].msg4recvd = true; - cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume; - + cell->raCb[ueId -1].dlMsgPduLen = dlBoInfo->dataVolume; } else { + /* TODO : These part of changes will be corrected during DL scheduling as + * per K0 - K1 -K2 */ SET_ONE_BIT(ueId, cell->boIndBitMap); if(ueCb->dlInfo.dlLcCtxt[lcId].lcId == lcId) { @@ -1014,9 +1094,8 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) return RFAILED; } } - /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cell, ueId); + cell->api->SchDlRlcBoInfo(cell, ueId); return ROK; } @@ -1026,7 +1105,7 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) * * @details * - * Function : MacSchBsr + * Function : SchProcBsr * * Functionality: * Processes DL BSR from MAC @@ -1037,17 +1116,13 @@ uint8_t MacSchDlRlcBoInfo(Pst *pst, DlRlcBoInfo *dlBoInfo) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) +uint8_t SchProcBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) { Inst schInst = pst->dstInst-SCH_INST_START; SchCellCb *cellCb = NULLP; SchUeCb *ueCb = NULLP; uint8_t lcgIdx = 0; -#ifdef CALL_FLOW_DEBUG_LOG - DU_LOG("\nCall Flow: ENTMAC -> ENTSCH : EVENT_SHORT_BSR\n"); -#endif - DU_LOG("\nDEBUG --> SCH : Received BSR"); if(bsrInd == NULLP) { @@ -1083,7 +1158,7 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) } /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cellCb, ueCb->ueId); + cellCb->api->SchBsr(cellCb, ueCb->ueId); return ROK; } @@ -1093,7 +1168,7 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) * * @details * - * Function : MacSchSrUciInd + * Function : SchProcSrUciInd * * Functionality: * Processes SR UCI indication from MAC @@ -1104,17 +1179,13 @@ uint8_t MacSchBsr(Pst *pst, UlBufferStatusRptInd *bsrInd) * RFAILED - failure * * ****************************************************************/ -uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) +uint8_t SchProcSrUciInd(Pst *pst, SrUciIndInfo *uciInd) { 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"); -#endif - DU_LOG("\nDEBUG --> SCH : Received SR"); ueCb = schGetUeCb(cellCb, uciInd->crnti); @@ -1131,11 +1202,48 @@ uint8_t MacSchSrUciInd(Pst *pst, SrUciIndInfo *uciInd) } if(uciInd->numSrBits) { - ueCb->srRcvd = true; - + ueCb->srRcvd = true; /* Adding UE Id to list of pending UEs to be scheduled */ - addUeToBeScheduled(cellCb, ueCb->ueId); + cellCb->api->SchSrUciInd(cellCb, ueCb->ueId); + } + return ROK; +} + +/******************************************************************* + * + * @brief Processes DL HARQ indication from MAC + * + * @details + * + * Function : SchProcDlHarqInd + * + * Functionality: + * Processes DL HARQ indication from MAC + * + * @params[in] Post structure + * DL HARQ Indication + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t SchProcDlHarqInd(Pst *pst, DlHarqInd *dlHarqInd) +{ + Inst inst = pst->dstInst-SCH_INST_START; + SchUeCb *ueCb; + SchCellCb *cellCb = schCb[inst].cells[inst]; + + DU_LOG("\nDEBUG --> SCH : Received HARQ"); + + ueCb = schGetUeCb(cellCb, dlHarqInd->crnti); + + if(ueCb->state == SCH_UE_STATE_INACTIVE) + { + DU_LOG("\nERROR --> SCH : Crnti %d is inactive", dlHarqInd->crnti); + return ROK; } + + schUpdateHarqFdbk(ueCb, dlHarqInd->numHarq, dlHarqInd->harqPayload, &dlHarqInd->slotInd); + return ROK; } @@ -1411,58 +1519,6 @@ uint8_t allocatePrbUl(SchCellCb *cell, SlotTimingInfo slotTime, \ return ROK; } -/******************************************************************* - * - * @brief Add UE to ueToBeScheduled List - * - * @details - * - * Function : addUeToBeScheduled - * - * Functionality: - * Search if UE entry present in the list - * If yes, return. - * If no, add UE to the list - * - * @params[in] Cell control block - * Ue Idx to be added - * - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -uint8_t addUeToBeScheduled(SchCellCb *cell, uint8_t ueIdToAdd) -{ - uint8_t *ueId; - CmLList *node; - - /* Search if UE entry is already present in ueToBeScheduled list. - * If yes, another entry for same UE not needed. Hence, return */ - node = cell->ueToBeScheduled.first; - while(node) - { - ueId = (uint8_t *)node->node; - if(*ueId == ueIdToAdd) - return ROK; - node = node->next; - } - - /* If UE entry not present already, add UE to the end of ueToBeScheduled list */ - SCH_ALLOC(ueId, sizeof(uint8_t)); - if(!ueId) - { - DU_LOG("\nERROR --> SCH : Memory allocation failure in addUeToBeScheduled"); - return RFAILED; - } - *ueId = ueIdToAdd; - if(addNodeToLList(&cell->ueToBeScheduled, ueId, NULLP) != ROK) - { - DU_LOG("\nERROR --> SCH : Failed to add ueId [%d] to cell->ueToBeScheduled list", *ueId); - return RFAILED; - } - return ROK; -} - /******************************************************************************* * * @brief Try to find Best Free Block with Max Num PRB @@ -1623,7 +1679,7 @@ void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp) FILL_PST_SCH_TO_MAC(rspPst, inst); rspPst.event = EVENT_SLICE_CFG_RSP_TO_MAC; - SchSliceCfgRspOpts[rspPst.selector](&rspPst, &sliceCfgRsp); + MacMessageRouter(&rspPst, (void *)&sliceCfgRsp); } /******************************************************************************* @@ -1644,7 +1700,7 @@ void SchSendSliceCfgRspToMac(Inst inst, SchSliceCfgRsp sliceCfgRsp) * 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; @@ -1661,7 +1717,7 @@ uint8_t fillSliceCfgRsp(bool sliceReCfg, SchSliceCfg *storedSliceCfg, SchCellCb { sliceFound = false; /* Here comparing the slice cfg request with the slice stored in cellCfg */ - if(sliceReCfg != true) + if(sliceRecfg != true) { for(sliceIdx = 0; sliceIdxcellCfg.plmnInfoList.numSliceSupport; sliceIdx++) { @@ -1789,25 +1845,25 @@ uint8_t addSliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq, S * 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; cfgIdxnumOfConfiguredSlice; cfgIdx++) + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; 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)); } } /******************************************************************************* @@ -1816,7 +1872,7 @@ void freeSchSliceCfgReq(SchSliceCfgReq *cfgReq) * * @details * - * Function : MacSchSliceCfgReq + * Function : SchProcSliceCfgReq * * Functionality: * function is used to store the slice configuration Sch DB @@ -1828,7 +1884,7 @@ void freeSchSliceCfgReq(SchSliceCfgReq *cfgReq) * RFAILED - Failure * * ********************************************************************************/ -uint8_t MacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) +uint8_t SchProcSliceCfgReq(Pst *pst, SchSliceCfgReq *schSliceCfgReq) { uint8_t count = 0; Inst inst = pst->dstInst - SCH_INST_START; @@ -1880,7 +1936,7 @@ uint8_t MacSchSliceCfgReq(Pst *pst, SchSliceCfgReq *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; @@ -1892,15 +1948,15 @@ uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq return RFAILED; } - for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) + for(cfgIdx = 0; cfgIdxnumOfConfiguredSlice; cfgIdx++) { - if(cfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) + if(recfgRsp.listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK) { for(sliceIdx = 0; sliceIdxnumOfSliceConfigured; 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; } @@ -1908,7 +1964,7 @@ uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq } } } - freeSchSliceCfgReq(cfgReq); + freeSchSliceCfgReq(recfgReq); return ROK; } /******************************************************************************* @@ -1917,17 +1973,17 @@ uint8_t modifySliceCfgInSchDb(SchSliceCfg *storeSliceCfg, SchSliceCfgReq *cfgReq * * @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; @@ -1935,7 +1991,7 @@ void SchSendSliceReCfgRspToMac(Inst inst, SchSliceCfgRsp schSliceReCfgRsp) FILL_PST_SCH_TO_MAC(rspPst, inst); rspPst.event = EVENT_SLICE_RECFG_RSP_TO_MAC; - SchSliceReCfgRspOpts[rspPst.selector](&rspPst, &schSliceReCfgRsp); + MacMessageRouter(&rspPst, (void *)&schSliceRecfgRsp); } /******************************************************************************* * @@ -1943,48 +1999,48 @@ void SchSendSliceReCfgRspToMac(Inst inst, SchSliceCfgRsp schSliceReCfgRsp) * * @details * - * Function : MacSchSliceReCfgReq + * Function : SchProcSliceRecfgReq * * 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 SchProcSliceRecfgReq(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; } @@ -2101,6 +2157,199 @@ void schCfgPdcchMonOccOfPO(SchCellCb *cell) } } +/**************************************************************************** + * + * @brief Storing the paging information in SCH database + * + * @details + * + * Function : schAddPagingIndtoList + * + * Functionality: Storing the paging information in SCH database + * + * @params[in] CmLListCp *storedPageList, CmLList *pageIndInfo + * + * @return ROK - sucess + * RFAILED - failure + * + *************************************************************************/ +uint8_t schAddPagingIndtoList(CmLListCp *storedPageList,void * pageIndInfo) +{ + CmLList *firstNodeOfList = NULLP; + CmLList *currentNodeInfo = NULLP; + SchPageInfo *tempNode = NULLP, *recvdNode = NULLP; + + recvdNode = (SchPageInfo*) pageIndInfo; + CM_LLIST_FIRST_NODE(storedPageList,firstNodeOfList); + + SCH_ALLOC(currentNodeInfo, sizeof(CmLList)); + if(!currentNodeInfo) + { + DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Memory allocation failed"); + return RFAILED; + } + + currentNodeInfo->node = (PTR)pageIndInfo; + while(firstNodeOfList) + { + tempNode = (SchPageInfo*)(firstNodeOfList->node); + if ((recvdNode->pageTxTime.slot < tempNode->pageTxTime.slot)) + { + cmLListInsCrnt(storedPageList, currentNodeInfo); + break; + } + else if ((recvdNode->pageTxTime.slot == tempNode->pageTxTime.slot)) + { + DU_LOG("\nERROR --> SCH : schAddPagingIndtoList() : Slot[%d] is already present in the list", recvdNode->pageTxTime.slot); + return RFAILED; + } + else + { + CM_LLIST_NEXT_NODE(storedPageList, firstNodeOfList); + } + } + + if(!firstNodeOfList) + { + cmLListAdd2Tail(storedPageList, currentNodeInfo); + } + DU_LOG("\nDEBUG --> SCH : Paging information is stored successfully for PF:%d, Slot:%d",\ + recvdNode->pageTxTime.sfn, recvdNode->pageTxTime.slot); + return ROK; +} + +/**************************************************************************** + * + * @brief Process paging indication at SCH recevied form MAC + * + * @details + * + * Function : SchProcPagingInd + * + * Functionality: Process paging indication at SCH recevied form MAC + * + * @params[in] Pst *pst, SchPageInd *pageInd + * + * @return void + * + *************************************************************************/ +uint8_t SchProcPagingInd(Pst *pst, SchPageInd *pageInd) +{ + uint8_t ret = RFAILED; + uint16_t cellIdx = 0; + Inst inst = pst->dstInst - SCH_INST_START; + SchCellCb *cellCb = NULLP; + SchPageInfo *pageInfo = NULLP; + + if(pageInd) + { + DU_LOG("\nDEBUG --> SCH : Received paging indication from MAC for cellId[%d]",\ + pageInd->cellId); + + /* Fetch Cell CB */ + for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++) + { + if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == pageInd->cellId)) + { + cellCb = schCb[inst].cells[cellIdx]; + break; + } + } + if(cellCb) + { + if(pageInd->i_s > cellCb->cellCfg.sib1SchCfg.pageCfg.numPO) + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): i_s should not be greater than number of paging occasion"); + } + else + { + SCH_ALLOC(pageInfo, sizeof(SchPageInfo)); + if(pageInfo) + { + pageInfo->pf = pageInd->pf; + pageInfo->i_s = pageInd->i_s; + pageInfo->pageTxTime.cellId = pageInd->cellId; + pageInfo->pageTxTime.sfn = (pageInd->pf + cellCb->pageCb.pagMonOcc[pageInd->i_s].frameOffset) % MAX_SFN; + pageInfo->pageTxTime.slot = cellCb->pageCb.pagMonOcc[pageInd->i_s].pagingOccSlot; + pageInfo->mcs = DEFAULT_MCS; + pageInfo->msgLen = pageInd->pduLen; + SCH_ALLOC(pageInfo->pagePdu, pageInfo->msgLen); + if(!pageInfo->pagePdu) + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory"); + } + else + { + memcpy(pageInfo->pagePdu, pageInd->pagePdu, pageInfo->msgLen); + ret = schAddPagingIndtoList(&cellCb->pageCb.pageIndInfoRecord[pageInfo->pageTxTime.sfn], pageInfo); + if(ret != ROK) + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to store paging record"); + } + } + } + else + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Failed to allocate memory"); + } + } + } + else + { + DU_LOG("\nERROR --> SCH : Cell ID [%d] not found", pageInd->cellId); + } + SCH_FREE(pageInd->pagePdu, pageInd->pduLen); + SCH_FREE(pageInd, sizeof(SchPageInd)); + } + else + { + DU_LOG("\nERROR --> SCH : SchProcPagingInd(): Received null pointer"); + } + return ret; +} + + +/*********************************************************** + * + * Func : SchFillCfmPst + * + * + * Desc : Fills the Confirmation Post Structure cfmPst using the reqPst + * and the cfm->hdr.response. + * + * + * Ret : Void + * + * Notes: + * + * File : rg_sch_lmm.c + * + **********************************************************/ +Void SchFillCfmPst +( +Pst *reqPst, +Pst *cfmPst, +RgMngmt *cfm +) +{ + Inst inst; + + inst = (reqPst->dstInst - SCH_INST_START); + + cfmPst->srcEnt = ENTMAC; + cfmPst->srcInst = (Inst) 1; + cfmPst->srcProcId = schCb[inst].schInit.procId; + cfmPst->dstEnt = ENTMAC; + cfmPst->dstInst = (Inst) 0; + cfmPst->dstProcId = reqPst->srcProcId; + + cfmPst->selector = cfm->hdr.response.selector; + cfmPst->region = cfm->hdr.response.mem.region; + cfmPst->pool = cfm->hdr.response.mem.pool; + + return; +} + /********************************************************************** End of file **********************************************************************/