src/5gnrmac/rg_ram.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
  19 /************************************************************************
  20
  21      Name:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_ram.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_ram.c
  32 @brief This file has APIs to handle the random access procedure functionality.
  33 */
  34
  35 static const char* RLOG_MODULE_NAME="MAC";
  36 static int RLOG_FILE_ID=132;
  37 static int RLOG_MODULE_ID=4096;
  38
  39 /* header include files (.h) */
  40 #include "common_def.h"
  41 #include "rg_env.h"        /* MAC Environment Defines */
  42 #include "crg.h"           /* CRG Interface defines */
  43 #include "rgu.h"           /* RGU Interface defines */
  44 #include "tfu.h"           /* TFU Interface defines */
  45 #include "rg_sch_inf.h"           /* RGR Interface defines */
  46 #include "lrg.h"           /* LRG Interface defines */
  47
  48 #include "rg.h"            /* MAC defines */
  49 #include "rg_err.h"        /* MAC error defines */
  50
  51 /* header/extern include files (.x) */
  52
  53 #include "crg.x"           /* CRG Interface includes */
  54 #include "rgu.x"           /* RGU Interface includes */
  55 #include "tfu.x"           /* TFU Interface includes */
  56 #include "rg_sch_inf.x"    /* SCH Interface includes */
  57 #include "rg_prg.x"        /* PRG Interface includes */
  58 #include "lrg.x"           /* LRG Interface includes */
  59
  60 #include "du_app_mac_inf.h"
  61 #include "rg.x"            /* MAC includes */
  62
  63 /* local defines */
  64
  65 /* local typedefs */
  66
  67 /* forward references */
  68
  69 /***********************************************************
  70  *
  71  *     Func : rgRAMFreeUeCb
  72  *
  73  *
  74  *     Desc :
  75  *     - Processing Steps:
  76  *        - Frees UE control block.
  77  *
  78  *     Ret  : Void
  79  *
  80  *     Notes:
  81  *
  82  *     File :
  83  *
  84  **********************************************************/
  85 Void rgRAMFreeUeCb(Inst  inst,RgUeCb *ue)
  86 {
  87    rgDHMFreeUe(inst,&ue->dl.hqEnt);
  88
  89    /*ccpu00117052 - MOD - Passing double pointer for proper NULLP
  90                           assignment */
  91    /* De-allocate the Ue */
  92    rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
  93
  94    /* Stack Crash problem for TRACE5 changes. Added the return below */
  95    return;
  96
  97 }  /* rgRAMFreeUeCb */
  98
  99 /**
 100  * @brief Handler for Random Access control block creation.
 101  *
 102  * @details
 103  *
 104  *     Function : rgRAMCreateUeCb
 105  *                Creates a raCb and gives the same to scheduler for its updation.
 106  *
 107  *
 108  *  @param[in]       RgCellCb       *cell
 109  *  @param[in]       CmLteRnti      tmpCrnti
 110  *  @param[out]      RgErrInfo      *err
 111  *  @return  RgUeCb*
 112  **/
 113 RgUeCb* rgRAMCreateUeCb(RgCellCb *cell,CmLteRnti  tmpCrnti,Bool insert,RgErrInfo *err)
 114 {
 115    Inst       inst = cell->macInst - RG_INST_START;
 116    RgUeCb    *ueCb = NULLP;
 117
 118    RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,"CREATE UECB FOR CRNTI:%d",
 119              tmpCrnti);
 120    /* Allocate the Ue control block */
 121    if (rgAllocSBuf(inst,(Data **)&ueCb, sizeof(*ueCb)) != ROK)
 122    {
 123       RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
 124                 "Memory allocation FAILED for CRNTI:%d",tmpCrnti);
 125       err->errCause = RGERR_RAM_MEM_EXHAUST;
 126       return (NULLP);
 127    }
 128
 129    /* Inititialize Ue control block */
 130    ueCb->ueId = tmpCrnti;
 131
 132    /* Initialize the lists of the UE */
 133    rgDBMInitUe(ueCb);
 134
 135    if(insert == TRUE)
 136    {
 137       /* MS_FIX : Remove stale UEs if present */
 138       RgUeCb *staleUe = NULLP;
 139       /* Insert the created raCb into raCb list of cell */
 140       ueCb->rachLstEnt.next = NULLP;
 141       ueCb->rachLstEnt.prev = NULLP;
 142       ueCb->rachLstEnt.node = (PTR)(ueCb);
 143       /* MS_FIX : Remove stale UEs if present */
 144       staleUe = rgDBMGetUeCbFromRachLst (cell, tmpCrnti);
 145       if (staleUe)
 146       {
 147          rgDBMDelUeCbFromRachLst(cell, staleUe);
 148          rgRAMFreeUeCb(inst,staleUe);
 149       }
 150       rgDBMInsUeCbInRachLst(cell, ueCb);
 151    }
 152
 153    return (ueCb);
 154 }  /* rgRAMCreateUeCb */
 155
 156 /**
 157  * @brief Function for handling cell delete.
 158  *
 159  * @details
 160  *
 161  *     Function : rgRAMFreeCell
 162  *
 163  *     This function shall be invoked whenever a cell needs to be deleted.
 164  *     This shall remove raCbs and raReqs stored in cell.
 165  *
 166  *
 167  *  @param[in,out] RgCellCb  *cell
 168  *  @return  S16
 169  *      -# ROK
 170  **/
 171 S16 rgRAMFreeCell(RgCellCb *cell)
 172 {
 173    Inst    inst = cell->macInst - RG_INST_START;
 174    RgUeCb  *ueCb;
 175
 176    /* Free CURRENT CRG cfg list */
 177    while ((ueCb = rgDBMGetNextUeCbFromRachLst(cell, NULLP)) != NULLP)
 178    {
 179       rgDBMDelUeCbFromRachLst(cell, ueCb);
 180       rgRAMFreeUeCb(inst,ueCb);
 181    }
 182
 183    return ROK;
 184 } /* rgRAMFreeCell */
 185 /**
 186  * @brief Function for handling RA response scheduled for a subframe.
 187  *
 188  * @details
 189  *
 190  *     Function : rgHndlRaResp
 191  *
 192  *     This function shall be invoked whenever scheduler is done with the
 193  *     allocations of random access responses for a subframe RgSchMacSfAllocReq.
 194  *
 195  *     Processing steps :
 196  *
 197  *     This shall invoke RAM to create ueCbs for all the rapIds allocated and
 198  *     shall invoke MUX to create RAR PDUs for raRntis allocated.
 199  *
 200  *
 201  *  @param[in] RgCellCb          *cell,
 202  *  @param[in] CmLteTimingInfo   timingInfo,
 203  *  @param[in] RgInfRarInfo      *rarInfo
 204  *  @param[in/out] RgErrInfo     *err
 205  *  @return  S16
 206  *      -# ROK
 207  **/
 208 S16 rgHndlRaResp(RgCellCb *cell,CmLteTimingInfo timingInfo,RgInfRarInfo *rarInfo,RgErrInfo *err)
 209 {
 210    uint8_t  idx1,idx2;
 211    Buffer   *rarPdu;
 212    RgDlSf   *dlSf;
 213    uint8_t  idx;
 214
 215    if(NULLP == rarInfo->raRntiInfo)
 216    {
 217       return RFAILED;
 218    }
 219
 220    idx = (timingInfo.slot % RG_NUM_SUB_FRAMES);
 221    dlSf = &cell->subFrms[idx];
 222
 223    /* Create RAR PDUs for all the allocated RA-RNTIs */
 224    for(idx1 = 0; idx1 < rarInfo->numRaRntis; idx1++)
 225    {
 226       if(ROK == (rgMUXBldRarPdu(cell,
 227                      &rarInfo->raRntiInfo[idx1], &rarPdu, err)))
 228       {
 229          /* Create RaCbs for all the rapIds allocated */
 230          for(idx2 = 0; idx2 < rarInfo->raRntiInfo[idx1].numCrnti; idx2++)
 231          {
 232             if(FALSE == rarInfo->raRntiInfo[idx1].crntiInfo[idx2].isContFree)
 233             {
 234                if(rgRAMCreateUeCb(cell,
 235                   rarInfo->raRntiInfo[idx1].crntiInfo[idx2].tmpCrnti,
 236                   TRUE, err) == NULLP)
 237                {
 238                   return RFAILED;
 239                }
 240             }
 241          }
 242          /* Store the created RAR PDU */
 243          dlSf->raRsp[dlSf->numRaRsp].pdcch.rnti =
 244             rarInfo->raRntiInfo[idx1].raRnti;
 245
 246          dlSf->raRsp[dlSf->numRaRsp].pdcch.dci =
 247             rarInfo->raRntiInfo[idx1].dciInfo;
 248
 249          dlSf->raRsp[dlSf->numRaRsp].rar = rarPdu;
 250          /* ccpu00132314-ADD-Adding txPower offset for the PDSCH transmission */
 251          dlSf->raRsp[dlSf->numRaRsp].txPwrOffset =
 252                rarInfo->txPwrOffset;
 253
 254          dlSf->numRaRsp++;
 255       }
 256       else
 257       {
 258          RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RARNTI:%d Creation of RAR"
 259                   "PDU for failed", rarInfo->raRntiInfo[idx1].raRnti);
 260          continue;
 261       }
 262    } /* end of raRntis loop */
 263    return ROK;
 264 } /* end of rgHndlRaResp */
 265
 266 /**********************************************************************
 267
 268          End of file
 269 **********************************************************************/