/******************************************************************************* ################################################################################ # Copyright (c) [2017-2019] [Radisys] # # # # Licensed under the Apache License, Version 2.0 (the "License"); # # you may not use this file except in compliance with the License. # # You may obtain a copy of the License at # # # # http://www.apache.org/licenses/LICENSE-2.0 # # # # Unless required by applicable law or agreed to in writing, software # # distributed under the License is distributed on an "AS IS" BASIS, # # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # # See the License for the specific language governing permissions and # # limitations under the License. # ################################################################################ *******************************************************************************/ /* header include files (.h) */ #include "common_def.h" #include "lrg.h" #include "lrg.x" #include "du_app_mac_inf.h" #include "mac_sch_interface.h" #include "lwr_mac_upr_inf.h" #include "mac.h" #include "mac_utils.h" /* Function pointer for sending rach ind from MAC to SCH */ MacSchRachIndFunc macSchRachIndOpts[]= { packMacSchRachInd, /* packing for loosely coupled */ MacSchRachInd, /* packing for tightly coupled */ packMacSchRachInd /* packing for light weight loosely coupled */ }; /* Function pointer for sending RACH resource request from MAC to SCH */ MacSchRachRsrcReqFunc macSchRachRsrcReqOpts[] = { packMacSchRachRsrcReq, /* packing for loosely coupled */ MacSchRachRsrcReq, /* packing for tightly coupled */ packMacSchRachRsrcReq /* packing for light weight loosely coupled */ }; /* Function pointer for sending RACH resource response from MAC to DU APP */ MacDuRachRsrcRspFunc macDuRachRsrcRspOpts[] = { packDuMacRachRsrcRsp, /* packing for loosely coupled */ DuProcMacRachRsrcRsp, /* packing for tightly coupled */ packDuMacRachRsrcRsp /* packing for light weight loosly coupled */ }; /* Function pointer for sending RACH resource release from MAC to SCH */ MacSchRachRsrcRelFunc macSchRachRsrcRelOpts[] = { packMacSchRachRsrcRel, /* packing for loosely coupled */ MacSchRachRsrcRel, /* packing for tightly coupled */ packMacSchRachRsrcRel /* packing for light weight loosely coupled */ }; /******************************************************************* * * @brief Sends RACH indication to SCH * * @details * * Function : sendRachIndMacToSch * * Functionality: * Sends RACH indication to SCH * * @params[in] RACH indication info * @return ROK - success * RFAILED - failure * * ****************************************************************/ uint8_t sendRachIndMacToSch(RachIndInfo *rachInd) { Pst pst; FILL_PST_MAC_TO_SCH(pst, EVENT_RACH_IND_TO_SCH); return(*macSchRachIndOpts[pst.selector])(&pst, rachInd); } /******************************************************************* * * @brief Adds an entry in list of RA Cb and fills RACH ind info * * @details * * Function : createMacRaCb * * Functionality: * Adds an entry in list of RA Cb and fills RACH ind info * * @params[in] Pointer to cellCB, * Pointer to RACH Indication information * @return ROK - SUCCESS * RFAILED - FAILURE * * ****************************************************************/ uint8_t createMacRaCb(MacCellCb *cellCb, RachIndInfo *rachIndInfo) { int8_t ueIdx = -1; uint8_t ssbIdx = 0; uint16_t crnti = 0; MacUeCb *ueCb = NULLP; /* Search if a UE CB is already present to which the incoming preamble index was dedicated */ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) { /* Check if ueCb has a crnti alloted to it. If not, it means this ueIdx * has no UE context stored in it, hence searching for preamble index in * this ueCb is not required */ if(cellCb->ueCb[ueIdx].crnti) { for(ssbIdx = 0; ssbIdx < cellCb->ueCb[ueIdx].cfraResource.numSsb; ssbIdx++) { if(cellCb->ueCb[ueIdx].cfraResource.ssbResource[ssbIdx].raPreambleIdx == rachIndInfo->preambleIdx) { ueCb = &cellCb->ueCb[ueIdx]; break; } } if(ueCb) break; } } if(ueCb) { /* If UE context is already present as in case of handover, fetch CRNTI from * UE CB allocated during UE context creation */ crnti = ueCb->crnti; } else { /* If UE context not present, assign CRNTI to this UE */ ueIdx = getFreeBitFromUeBitMap(rachIndInfo->cellId); if(ueIdx == -1) { DU_LOG("\nERROR --> MAC : Failed to find free UE Idx in UE bit map of cell Id [%d]", rachIndInfo->cellId); return RFAILED; } /* Calculate CRNTI from UE Index */ GET_CRNTI(crnti, ueIdx+1); /* Store in raCb */ memset(&cellCb->macRaCb[ueIdx], 0, sizeof(MacRaCbInfo)); cellCb->macRaCb[ueIdx].cellId = rachIndInfo->cellId; cellCb->macRaCb[ueIdx].crnti = crnti; /* Initialize MSG4 HARQ PROC CB */ cellCb->macRaCb[ueIdx].msg4HqInfo.procId = MAX_NUM_HARQ_PROC; } /* Store in Rach Indication message to be sent to SCH */ rachIndInfo->crnti = crnti; return ROK; } /******************************************************************* * * @brief Processes RACH indication from PHY * * @details * * Function : fapiMacRachInd * * Functionality: * Processes RACH indication from PHY * * @params[in] Post structure * Rach indication message * @return ROK - success * RFAILED - failure * * ****************************************************************/ uint8_t fapiMacRachInd(Pst *pst, RachInd *rachInd) { uint8_t ret = ROK; uint8_t pduIdx = 0; uint8_t preambleIdx = 0; uint16_t cellIdx = 0; RachIndInfo *rachIndInfo = NULLP; MacCellCb *cellCb = NULLP; DU_LOG("\nINFO --> MAC : Received RACH indication"); /* Considering one pdu and one preamble */ pduIdx = 0; preambleIdx = 0; /* Validate cell Id */ GET_CELL_IDX(rachInd->cellId, cellIdx); if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == rachInd->cellId)) cellCb = macCb.macCell[cellIdx]; if(!cellCb) { DU_LOG("\nERROR --> MAC : Invalid Cell ID [%d] received in RACH Indication", rachInd->cellId); return RFAILED; } MAC_ALLOC(rachIndInfo, sizeof(RachIndInfo)); if(!rachIndInfo) { DU_LOG("\nERROR --> MAC : Memory allocation failure in fapiMacRachInd"); MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachInd, sizeof(RachInd)); return RFAILED; } rachIndInfo->cellId = rachInd->cellId; rachIndInfo->timingInfo.sfn = rachInd->timingInfo.sfn; rachIndInfo->timingInfo.slot = rachInd->timingInfo.slot; rachIndInfo->slotIdx = rachInd->rachPdu[pduIdx].slotIdx; rachIndInfo->symbolIdx = rachInd->rachPdu[pduIdx].symbolIdx; rachIndInfo->freqIdx = rachInd->rachPdu[pduIdx].freqIdx; rachIndInfo->preambleIdx = rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].preamIdx; rachIndInfo->timingAdv = rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].timingAdv; /* Store the value in macRaCb */ if((ret = createMacRaCb(cellCb, rachIndInfo)) == ROK) { /* Send RACH Indication to SCH */ ret = sendRachIndMacToSch(rachIndInfo); } /* Free sharable buffer used to send RACH Indication from lower MAC to MAC */ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachInd, sizeof(RachInd)); return ret; } /******************************************************************* * * @brief Processes RACH Resource request from DU APP * * @details * * Function : MacProcRachRsrcReq * * Functionality: Processes RACH resource request from DU APP. * Fills and sends RACH resource request towards SCH. * * @params[in] Post structure * RACH resource request * @return ROK - success * RFAILED - failure * * ****************************************************************/ uint8_t MacProcRachRsrcReq(Pst *pst, MacRachRsrcReq *rachRsrcReq) { uint8_t ret = RFAILED; uint16_t cellIdx = 0; Pst schPst; MacCellCb *cellCb = NULLP; MacUeCb *ueCb = NULLP; SchRachRsrcReq *schRachRsrcReq = NULLP; DU_LOG("\nINFO --> MAC : Recieved RACH Resource Request for Cell ID [%d] UE ID [%d]",\ rachRsrcReq->cellId, rachRsrcReq->ueId); /* Fetch Cell Cb */ GET_CELL_IDX(rachRsrcReq->cellId, cellIdx); if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == rachRsrcReq->cellId)) { cellCb = macCb.macCell[cellIdx]; /* Fetch UE Cb */ if(cellCb->ueCb[rachRsrcReq->ueId-1].ueId == rachRsrcReq->ueId) { ueCb = &cellCb->ueCb[rachRsrcReq->ueId-1]; /* Allocate memory to RACH resource request to be sent to SCH */ MAC_ALLOC(schRachRsrcReq, sizeof(SchRachRsrcReq)); if(schRachRsrcReq) { /* Fill SCH RACH resource request from information received from DU APP to MAC */ schRachRsrcReq->cellId = rachRsrcReq->cellId; schRachRsrcReq->crnti = ueCb->crnti; schRachRsrcReq->numSsb = rachRsrcReq->numSsb; memcpy(schRachRsrcReq->ssbIdx, rachRsrcReq->ssbIdx, sizeof(schRachRsrcReq->ssbIdx)); /* Send RACH resource request from MAC to SCH */ FILL_PST_MAC_TO_SCH(schPst, EVENT_RACH_RESOURCE_REQUEST_TO_SCH); ret = (*macSchRachRsrcReqOpts[schPst.selector])(&schPst, schRachRsrcReq); } else DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource request to SCH"); } else DU_LOG("\nERROR --> MAC : UE ID [%d] not found", rachRsrcReq->ueId); } else DU_LOG("\nERROR --> MAC : Cell ID [%d] not found", rachRsrcReq->cellId); /* Free sharable buffer used to send RACH reource request from DU APP to MAC */ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachRsrcReq, sizeof(MacRachRsrcReq)); return ret; } /******************************************************************* * * @brief Processes RACH Resource response from SCH * * @details * * Function : MacProcSchRachRsrcRsp * * Functionality: Processes RACH resource response from SCH * Fills and sends RACH resource response towards DU APP * * @params[in] Post structure * RACH resource response * @return ROK - success * RFAILED - failure * * ****************************************************************/ uint8_t MacProcSchRachRsrcRsp(Pst *pst, SchRachRsrcRsp *schRachRsrcRsp) { uint16_t cellIdx = 0; Pst rspPst; MacRachRsrcRsp *rachRsrcRsp = NULLP; MacCellCb *cellCb = NULLP; MacUeCb *ueCb = NULLP; DU_LOG("\nINFO --> MAC : Received RACH resource response from SCH : Cell ID [%d] CRNTI [%d]", \ schRachRsrcRsp->cellId, schRachRsrcRsp->crnti); /* Fill RACH resource response to send to DU APP */ MAC_ALLOC_SHRABL_BUF(rachRsrcRsp, sizeof(MacRachRsrcRsp)); if(!rachRsrcRsp) { DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource response"); MAC_FREE(schRachRsrcRsp, sizeof(SchRachRsrcRsp)); return RFAILED; } rachRsrcRsp->cellId = schRachRsrcRsp->cellId; GET_UE_ID(schRachRsrcRsp->crnti, rachRsrcRsp->ueId); rachRsrcRsp->result = MAC_DU_APP_RSP_OK; /* Fill Pst structure to send RACH resource response from MAC to DU APP */ FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_RACH_RESOURCE_RSP); /* If negative response is received from SCH, send it further to DU APP */ if(schRachRsrcRsp->result == RSP_NOK) { DU_LOG("\nINFO --> MAC : RACH Resource response from SCH : Result [FAILURE]"); rachRsrcRsp->result = MAC_DU_APP_RSP_NOK; } else { DU_LOG("\nINFO --> MAC : RACH Resource response from SCH : Result [SUCCESS]"); /* Fetch Cell Cb */ GET_CELL_IDX(schRachRsrcRsp->cellId, cellIdx); if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == schRachRsrcRsp->cellId)) { cellCb = macCb.macCell[cellIdx]; /* Fetch UE Cb */ if(cellCb->ueCb[rachRsrcRsp->ueId-1].crnti == schRachRsrcRsp->crnti) ueCb = &cellCb->ueCb[rachRsrcRsp->ueId-1]; else { DU_LOG("\nERROR --> MAC : CRNTI [%d] not found", schRachRsrcRsp->crnti); rachRsrcRsp->result = MAC_DU_APP_RSP_NOK; } } else { DU_LOG("\nERROR --> MAC : Cell ID [%d] not found", schRachRsrcRsp->cellId); rachRsrcRsp->result = MAC_DU_APP_RSP_NOK; } } /* Fill SSB RACH resource info if SCH has sent a positive response and * processing of SCH RACH resource response at MAC has been successful so far */ if(rachRsrcRsp->result == MAC_DU_APP_RSP_OK) { rachRsrcRsp->newCrnti = ueCb->crnti; rachRsrcRsp->cfraResource.numSsb = schRachRsrcRsp->cfraResource.numSsb; memcpy(rachRsrcRsp->cfraResource.ssbResource, schRachRsrcRsp->cfraResource.ssbResource, \ rachRsrcRsp->cfraResource.numSsb * sizeof(MacCfraSsbResource)); /* Copy resources to UE CB in MAC */ memcpy(&ueCb->cfraResource, &rachRsrcRsp->cfraResource, sizeof(MacCfraResource)); } /* Free SCH RACH resource response */ MAC_FREE(schRachRsrcRsp, sizeof(SchRachRsrcRsp)); /* Send RACH resource response to DU APP */ FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_RACH_RESOURCE_RSP); return (*macDuRachRsrcRspOpts[rspPst.selector])(&rspPst, rachRsrcRsp); } /******************************************************************* * * @brief Processes RACH Resource release from DU APP * * @details * * Function : MacProcRachRsrcRel * * Functionality: Processes RACH resource release from DU APP. * Fills and sends RACH resource release towards SCH. * * @params[in] Post structure * RACH resource release * @return ROK - success * RFAILED - failure * * ****************************************************************/ uint8_t MacProcRachRsrcRel(Pst *pst, MacRachRsrcRel *rachRsrcRel) { uint8_t ret = RFAILED; uint16_t cellIdx = 0; Pst schPst; MacCellCb *cellCb = NULLP; MacUeCb *ueCb = NULLP; SchRachRsrcRel *schRachRsrcRel = NULLP; DU_LOG("\nINFO --> MAC : Recieved RACH Resource Release for Cell ID [%d] UE ID [%d]",\ rachRsrcRel->cellId, rachRsrcRel->ueId); /* Fetch Cell Cb */ GET_CELL_IDX(rachRsrcRel->cellId, cellIdx); if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == rachRsrcRel->cellId)) { cellCb = macCb.macCell[cellIdx]; /* Fetch UE Cb */ if(cellCb->ueCb[rachRsrcRel->ueId-1].ueId == rachRsrcRel->ueId) { ueCb = &cellCb->ueCb[rachRsrcRel->ueId-1]; /* Allocate memory to RACH resource release to be sent to SCH */ MAC_ALLOC(schRachRsrcRel, sizeof(SchRachRsrcRel)); if(schRachRsrcRel) { /* Fill SCH RACH resource release from information received from DU APP to MAC */ memset(schRachRsrcRel, 0, sizeof(SchRachRsrcRel)); schRachRsrcRel->cellId = rachRsrcRel->cellId; schRachRsrcRel->crnti = ueCb->crnti; memcpy(&schRachRsrcRel->cfraResource, &ueCb->cfraResource, sizeof(schRachRsrcRel->cfraResource)); /* Release RACH resources at MAC */ memset(&ueCb->cfraResource, 0, sizeof(MacCfraResource)); /* Send RACH resource release from MAC to SCH */ FILL_PST_MAC_TO_SCH(schPst, EVENT_RACH_RESOURCE_RELEASE_TO_SCH); ret = (*macSchRachRsrcRelOpts[schPst.selector])(&schPst, schRachRsrcRel); } else DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource release to SCH"); } else DU_LOG("\nERROR --> MAC : UE ID [%d] not found", rachRsrcRel->ueId); } else DU_LOG("\nERROR --> MAC : Cell ID [%d] not found", rachRsrcRel->cellId); /* Free sharable buffer used to send RACH reource release from DU APP to MAC */ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachRsrcRel, sizeof(MacRachRsrcRel)); return ret; } /* spec-38.211 Table 6.3.3.1-7 */ uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX] = {0, 2, 4, 6, 8, 10, 12, 13, 15, 17, 19, 23, 27, 34, 46, 69}; /******************************************************************* * * @brief Processes UL scheduling info from SCH * * @details * * Function : MacProcUlSchInfo * * Functionality: Processes UL scheduling info from SCH * * @params[in] Post structure * UL scheduling info * @return ROK - success * RFAILED - failure * * ****************************************************************/ uint8_t MacProcUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo) { uint16_t cellIdx; #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UL_SCH_INFO\n"); #endif GET_CELL_IDX(ulSchedInfo->cellId, cellIdx); if(ulSchedInfo != NULLP) { MacUlSlot *currUlSlot = &macCb.macCell[cellIdx]->ulSlot[ulSchedInfo->slotIndInfo.slot % macCb.macCell[cellIdx]->numOfSlots]; memcpy(&currUlSlot->ulInfo, ulSchedInfo, sizeof(UlSchedInfo)); } return ROK; } /********************************************************************** End of file **********************************************************************/