#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[] =
{
Pst pst;
FILL_PST_MAC_TO_SCH(pst, EVENT_RACH_IND_TO_SCH);
- return(*macSchRachIndOpts[pst.selector])(&pst, rachInd);
+ return(SchMessageRouter(&pst, (void *)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;
}
/*******************************************************************
* ****************************************************************/
uint8_t fapiMacRachInd(Pst *pst, RachInd *rachInd)
{
- uint8_t pduIdx;
- uint8_t preambleIdx;
- RachIndInfo *rachIndInfo;
+ 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)
{
rachIndInfo->timingAdv = rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].timingAdv;
/* Store the value in macRaCb */
- createMacRaCb(rachIndInfo);
+ 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));
- /* Send RACH Indication to SCH */
- return(sendRachIndMacToSch(rachIndInfo));
+ return ret;
}
/*******************************************************************
/* 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);
+ ret = SchMessageRouter(&schPst, (void *)schRachRsrcReq);
}
else
DU_LOG("\nERROR --> MAC : Memory allocation failed for RACH resource request to SCH");
}
}
- /* TODO : Check if ra-preamble index is to be stored in UE CB */
-
/* 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->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 */
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 = SchMessageRouter(&schPst, (void *)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};
if(ulSchedInfo != NULLP)
{
MacUlSlot *currUlSlot =
- &macCb.macCell[cellIdx]->ulSlot[ulSchedInfo->slotIndInfo.slot % MAX_SLOTS];
+ &macCb.macCell[cellIdx]->ulSlot[ulSchedInfo->slotIndInfo.slot % macCb.macCell[cellIdx]->numOfSlots];
memcpy(&currUlSlot->ulInfo, ulSchedInfo, sizeof(UlSchedInfo));
}
return ROK;