src/5gnrmac/mac_rach.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17  *******************************************************************************/
  18 /* header include files (.h) */
  19 #include "common_def.h"
  20 #include "lrg.h"
  21 #include "lrg.x"
  22 #include "du_app_mac_inf.h"
  23 #include "mac_sch_interface.h"
  24 #include "lwr_mac_upr_inf.h"
  25 #include "mac.h"
  26 #include "mac_utils.h"
  27
  28 /* Function pointer for sending rach ind from MAC to SCH */
  29 MacSchRachIndFunc macSchRachIndOpts[]=
  30 {
  31    packMacSchRachInd,   /* packing for loosely coupled */
  32    MacSchRachInd,       /* packing for tightly coupled */
  33    packMacSchRachInd    /* packing for light weight loosely coupled */
  34 };
  35
  36 /* Function pointer for sending RACH resource request from MAC to SCH */
  37 MacSchRachRsrcReqFunc macSchRachRsrcReqOpts[] =
  38 {
  39    packMacSchRachRsrcReq,   /* packing for loosely coupled */
  40    MacSchRachRsrcReq,       /* packing for tightly coupled */
  41    packMacSchRachRsrcReq    /* packing for light weight loosely coupled */
  42 };
  43
  44 /* Function pointer for sending RACH resource response from MAC to DU APP */
  45 MacDuRachRsrcRspFunc macDuRachRsrcRspOpts[] =
  46 {
  47    packDuMacRachRsrcRsp,   /* packing for loosely coupled */
  48    DuProcMacRachRsrcRsp,   /* packing for tightly coupled */
  49    packDuMacRachRsrcRsp    /* packing for light weight loosly coupled */
  50 };
  51
  52 /*******************************************************************
  53  *
  54  * @brief Sends RACH indication to SCH
  55  *
  56  * @details
  57  *
  58  *    Function : sendRachIndMacToSch
  59  *
  60  *    Functionality:
  61  *     Sends RACH indication to SCH
  62  *
  63  * @params[in] RACH indication info
  64  * @return ROK     - success
  65  *         RFAILED - failure
  66  *
  67  * ****************************************************************/
  68 uint8_t sendRachIndMacToSch(RachIndInfo *rachInd)
  69 {
  70    Pst pst;
  71
  72    FILL_PST_MAC_TO_SCH(pst, EVENT_RACH_IND_TO_SCH);
  73    return(*macSchRachIndOpts[pst.selector])(&pst, rachInd);
  74 }
  75
  76 /*******************************************************************
  77  *
  78  * @brief Adds an entry in list of RA Cb and fills RACH ind info
  79  *
  80  * @details
  81  *
  82  *    Function : createMacRaCb
  83  *
  84  *    Functionality:
  85  *     Adds an entry in list of RA Cb and fills RACH ind info
  86  *
  87  * @params[in] Pointer to cellCB,
  88  *             Pointer to RACH Indication information
  89  * @return ROK - SUCCESS
  90  *         RFAILED - FAILURE
  91  *
  92  * ****************************************************************/
  93 uint8_t createMacRaCb(MacCellCb *cellCb, RachIndInfo *rachIndInfo)
  94 {
  95    int8_t ueIdx = -1;
  96    uint8_t  ssbIdx = 0;
  97    uint16_t crnti = 0;
  98    MacUeCb  *ueCb = NULLP;
  99
 100    /* Search if a UE CB is already present to which the incoming preamble index was dedicated */
 101    for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 102    {
 103       /* Check if ueCb has a crnti alloted to it. If not, it means this ueIdx
 104        * has no UE context stored in it, hence searching for preamble index in
 105        * this ueCb is not required */
 106       if(cellCb->ueCb[ueIdx].crnti)
 107       {
 108          for(ssbIdx = 0; ssbIdx < cellCb->ueCb[ueIdx].cfraResource.numSsb; ssbIdx++)
 109          {
 110             if(cellCb->ueCb[ueIdx].cfraResource.ssbResource[ssbIdx].raPreambleIdx == rachIndInfo->preambleIdx)
 111             {
 112                ueCb = &cellCb->ueCb[ueIdx];
 113                break;
 114             }
 115          }
 116          if(ueCb)
 117             break;
 118       }
 119    }
 120
 121    if(ueCb)
 122    {
 123       /* If UE context is already present as in case of handover, fetch CRNTI from
 124        * UE CB allocated during UE context creation */
 125       crnti = ueCb->crnti;
 126    }
 127    else
 128    {
 129       /* If UE context not present, assign CRNTI to this UE */
 130       ueIdx = getFreeBitFromUeBitMap(rachIndInfo->cellId);
 131       if(ueIdx == -1)
 132       {
 133          DU_LOG("\nERROR  -->  MAC : Failed to find free UE Idx in UE bit map of cell Id [%d]", rachIndInfo->cellId);
 134          return RFAILED;
 135       }
 136
 137       /* Calculate CRNTI from UE Index */
 138       GET_CRNTI(crnti, ueIdx+1);
 139
 140       /* Store in raCb */
 141       cellCb->macRaCb[ueIdx].cellId = rachIndInfo->cellId;
 142       cellCb->macRaCb[ueIdx].crnti  = crnti;
 143    }
 144
 145    /* Store in Rach Indication message to be sent to SCH */
 146    rachIndInfo->crnti  = crnti;
 147    return ROK;
 148 }
 149
 150 /*******************************************************************
 151  *
 152  * @brief Processes RACH indication from PHY
 153  *
 154  * @details
 155  *
 156  *    Function : fapiMacRachInd
 157  *
 158  *    Functionality:
 159  *      Processes RACH indication from PHY
 160  *
 161  * @params[in] Post structure
 162  *             Rach indication message
 163  * @return ROK     - success
 164  *         RFAILED - failure
 165  *
 166  * ****************************************************************/
 167 uint8_t fapiMacRachInd(Pst *pst, RachInd *rachInd)
 168 {
 169    uint8_t      ret = ROK;
 170    uint8_t      pduIdx = 0;
 171    uint8_t      preambleIdx = 0;
 172    uint16_t     cellIdx = 0;
 173    RachIndInfo  *rachIndInfo = NULLP;
 174    MacCellCb    *cellCb = NULLP;
 175
 176    DU_LOG("\nINFO  -->  MAC : Received RACH indication");
 177    /* Considering one pdu and one preamble */
 178    pduIdx = 0;
 179    preambleIdx = 0;
 180
 181    /* Validate cell Id */
 182    GET_CELL_IDX(rachInd->cellId, cellIdx);
 183    if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == rachInd->cellId))
 184          cellCb = macCb.macCell[cellIdx];
 185
 186    if(!cellCb)
 187    {
 188       DU_LOG("\nERROR  --> MAC : Invalid Cell ID [%d] received in RACH Indication", rachInd->cellId);
 189       return RFAILED;
 190    }
 191
 192    MAC_ALLOC(rachIndInfo, sizeof(RachIndInfo));
 193    if(!rachIndInfo)
 194    {
 195       DU_LOG("\nERROR  --> MAC : Memory allocation failure in fapiMacRachInd");
 196       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachInd, sizeof(RachInd));
 197       return RFAILED;
 198    }
 199
 200    rachIndInfo->cellId = rachInd->cellId;
 201    rachIndInfo->timingInfo.sfn = rachInd->timingInfo.sfn;
 202    rachIndInfo->timingInfo.slot = rachInd->timingInfo.slot;
 203    rachIndInfo->slotIdx = rachInd->rachPdu[pduIdx].slotIdx;
 204    rachIndInfo->symbolIdx = rachInd->rachPdu[pduIdx].symbolIdx;
 205    rachIndInfo->freqIdx = rachInd->rachPdu[pduIdx].freqIdx;
 206    rachIndInfo->preambleIdx = rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].preamIdx;
 207    rachIndInfo->timingAdv = rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].timingAdv;
 208
 209    /* Store the value in macRaCb */
 210    if((ret = createMacRaCb(cellCb, rachIndInfo)) == ROK)
 211    {
 212       /* Send RACH Indication to SCH */
 213       ret = sendRachIndMacToSch(rachIndInfo);
 214    }
 215
 216    /* Free sharable buffer used to send RACH Indication from lower MAC to MAC */
 217    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachInd, sizeof(RachInd));
 218
 219    return ret;
 220 }
 221
 222 /*******************************************************************
 223  *
 224  * @brief Processes RACH Resource request from DU APP
 225  *
 226  * @details
 227  *
 228  *    Function : MacProcRachRsrcReq
 229  *
 230  *    Functionality: Processes RACH resource request from DU APP.
 231  *      Fills and sends RACH resource request towards SCH.
 232  *
 233  * @params[in] Post structure
 234  *             RACH resource request
 235  * @return ROK     - success
 236  *         RFAILED - failure
 237  *
 238  * ****************************************************************/
 239 uint8_t MacProcRachRsrcReq(Pst *pst, MacRachRsrcReq *rachRsrcReq)
 240 {
 241    uint8_t   ret = RFAILED;
 242    uint16_t  cellIdx = 0;
 243    Pst       schPst;
 244    MacCellCb *cellCb = NULLP;
 245    MacUeCb   *ueCb = NULLP;
 246    SchRachRsrcReq *schRachRsrcReq = NULLP;
 247
 248    DU_LOG("\nINFO  -->  MAC : Recieved RACH Resource Request for Cell ID [%d] UE ID [%d]",\
 249          rachRsrcReq->cellId, rachRsrcReq->ueId);
 250
 251    /* Fetch Cell Cb */
 252    GET_CELL_IDX(rachRsrcReq->cellId, cellIdx);
 253    if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == rachRsrcReq->cellId))
 254    {
 255       cellCb = macCb.macCell[cellIdx];
 256
 257       /* Fetch UE Cb */
 258       if(cellCb->ueCb[rachRsrcReq->ueId-1].ueId == rachRsrcReq->ueId)
 259       {
 260          ueCb = &cellCb->ueCb[rachRsrcReq->ueId-1];
 261          /* Allocate memory to RACH resource request to be sent to SCH */
 262          MAC_ALLOC(schRachRsrcReq, sizeof(SchRachRsrcReq));
 263          if(schRachRsrcReq)
 264          {
 265             /* Fill SCH RACH resource request from information received from DU APP to MAC */
 266             schRachRsrcReq->cellId = rachRsrcReq->cellId;
 267             schRachRsrcReq->crnti = ueCb->crnti;
 268             schRachRsrcReq->numSsb = rachRsrcReq->numSsb;
 269             memcpy(schRachRsrcReq->ssbIdx, rachRsrcReq->ssbIdx, sizeof(schRachRsrcReq->ssbIdx));
 270
 271             /* Send RACH resource request from MAC to SCH */
 272             FILL_PST_MAC_TO_SCH(schPst, EVENT_RACH_RESOURCE_REQUEST_TO_SCH);
 273             ret = (*macSchRachRsrcReqOpts[schPst.selector])(&schPst, schRachRsrcReq);
 274          }
 275          else
 276             DU_LOG("\nERROR  -->  MAC : Memory allocation failed for RACH resource request to SCH");
 277       }
 278       else
 279          DU_LOG("\nERROR  -->  MAC : UE ID [%d] not found", rachRsrcReq->ueId);
 280    }
 281    else
 282       DU_LOG("\nERROR  -->  MAC : Cell ID [%d] not found", rachRsrcReq->cellId);
 283
 284    /* Free sharable buffer used to send RACH reource request from DU APP to MAC */
 285    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachRsrcReq, sizeof(MacRachRsrcReq));
 286    return ret;
 287 }
 288
 289 /*******************************************************************
 290  *
 291  * @brief Processes RACH Resource response from SCH
 292  *
 293  * @details
 294  *
 295  *    Function : MacProcSchRachRsrcRsp
 296  *
 297  *    Functionality: Processes RACH resource response from SCH
 298  *      Fills and sends RACH resource response towards DU APP
 299  *
 300  * @params[in] Post structure
 301  *             RACH resource response
 302  * @return ROK     - success
 303  *         RFAILED - failure
 304  *
 305  * ****************************************************************/
 306 uint8_t MacProcSchRachRsrcRsp(Pst *pst, SchRachRsrcRsp *schRachRsrcRsp)
 307 {
 308    uint16_t cellIdx = 0;
 309    Pst rspPst;
 310    MacRachRsrcRsp *rachRsrcRsp = NULLP;
 311    MacCellCb *cellCb = NULLP;
 312    MacUeCb   *ueCb = NULLP;
 313
 314    DU_LOG("\nINFO  -->  MAC : Received RACH resource response from SCH : Cell ID [%d] CRNTI [%d]", \
 315          schRachRsrcRsp->cellId, schRachRsrcRsp->crnti);
 316
 317    /* Fill RACH resource response to send to DU APP */
 318    MAC_ALLOC_SHRABL_BUF(rachRsrcRsp, sizeof(MacRachRsrcRsp));
 319    if(!rachRsrcRsp)
 320    {
 321       DU_LOG("\nERROR  -->  MAC : Memory allocation failed for RACH resource response");
 322       MAC_FREE(schRachRsrcRsp, sizeof(SchRachRsrcRsp));
 323       return RFAILED;
 324    }
 325    rachRsrcRsp->cellId = schRachRsrcRsp->cellId;
 326    GET_UE_ID(schRachRsrcRsp->crnti, rachRsrcRsp->ueId);
 327    rachRsrcRsp->result = MAC_DU_APP_RSP_OK;
 328
 329    /* Fill Pst structure to send RACH resource response from MAC to DU APP */
 330    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_RACH_RESOURCE_RSP);
 331
 332    /* If negative response is received from SCH, send it further to DU APP */
 333    if(schRachRsrcRsp->result == RSP_NOK)
 334    {
 335       DU_LOG("\nINFO  -->  MAC : RACH Resource response from SCH : Result [FAILURE]");
 336       rachRsrcRsp->result = MAC_DU_APP_RSP_NOK;
 337    }
 338    else
 339    {
 340       DU_LOG("\nINFO  -->  MAC : RACH Resource response from SCH : Result [SUCCESS]");
 341
 342       /* Fetch Cell Cb */
 343       GET_CELL_IDX(schRachRsrcRsp->cellId, cellIdx);
 344       if(macCb.macCell[cellIdx] && (macCb.macCell[cellIdx]->cellId == schRachRsrcRsp->cellId))
 345       {
 346          cellCb = macCb.macCell[cellIdx];
 347
 348          /* Fetch UE Cb */
 349          if(cellCb->ueCb[rachRsrcRsp->ueId-1].crnti == schRachRsrcRsp->crnti)
 350             ueCb = &cellCb->ueCb[rachRsrcRsp->ueId-1];
 351          else
 352          {
 353             DU_LOG("\nERROR  -->  MAC : CRNTI [%d] not found", schRachRsrcRsp->crnti);
 354             rachRsrcRsp->result = MAC_DU_APP_RSP_NOK;
 355          }
 356       }
 357       else
 358       {
 359          DU_LOG("\nERROR  -->  MAC : Cell ID [%d] not found", schRachRsrcRsp->cellId);
 360          rachRsrcRsp->result = MAC_DU_APP_RSP_NOK;
 361       }
 362    }
 363
 364    /* Fill SSB RACH resource info if SCH has sent a positive response and
 365     * processing of SCH RACH resource response at MAC has been successful so far */
 366    if(rachRsrcRsp->result == MAC_DU_APP_RSP_OK)
 367    {
 368       rachRsrcRsp->newCrnti = ueCb->crnti;
 369       rachRsrcRsp->cfraResource.numSsb = schRachRsrcRsp->cfraResource.numSsb;
 370       memcpy(rachRsrcRsp->cfraResource.ssbResource, schRachRsrcRsp->cfraResource.ssbResource, \
 371          rachRsrcRsp->cfraResource.numSsb * sizeof(MacCfraSsbResource));
 372
 373       /* Copy resources to UE CB in MAC */
 374       memcpy(&ueCb->cfraResource, &rachRsrcRsp->cfraResource, sizeof(MacCfraResource));
 375    }
 376
 377    /* Free SCH RACH resource response */
 378    MAC_FREE(schRachRsrcRsp, sizeof(SchRachRsrcRsp));
 379
 380    /* Send RACH resource response to DU APP */
 381    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_RACH_RESOURCE_RSP);
 382    return (*macDuRachRsrcRspOpts[rspPst.selector])(&rspPst, rachRsrcRsp);
 383 }
 384
 385 /* spec-38.211 Table 6.3.3.1-7 */
 386 uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX] =
 387 {0, 2, 4, 6, 8, 10, 12, 13, 15, 17, 19, 23, 27, 34, 46, 69};
 388
 389 /*******************************************************************
 390  *
 391  * @brief Processes UL scheduling info from SCH
 392  *
 393  * @details
 394  *
 395  *    Function : MacProcUlSchInfo
 396  *
 397  *    Functionality: Processes UL scheduling info from SCH
 398  *
 399  * @params[in] Post structure
 400  *             UL scheduling info
 401  * @return ROK     - success
 402  *         RFAILED - failure
 403  *
 404  * ****************************************************************/
 405 uint8_t MacProcUlSchInfo(Pst *pst, UlSchedInfo *ulSchedInfo)
 406 {
 407    uint16_t  cellIdx;
 408
 409 #ifdef CALL_FLOW_DEBUG_LOG
 410    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_UL_SCH_INFO\n");
 411 #endif
 412
 413    GET_CELL_IDX(ulSchedInfo->cellId, cellIdx);
 414    if(ulSchedInfo != NULLP)
 415    {
 416       MacUlSlot *currUlSlot =
 417          &macCb.macCell[cellIdx]->ulSlot[ulSchedInfo->slotIndInfo.slot % MAX_SLOTS];
 418       memcpy(&currUlSlot->ulInfo, ulSchedInfo, sizeof(UlSchedInfo));
 419    }
 420    return ROK;
 421 }
 422
 423 /**********************************************************************
 424   End of file
 425  **********************************************************************/
 426