src/5gnrsch/rg_sch_tmr.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_sch_tmr.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_tmr.c
  32 @brief This module does processing related to timers for the scheduler.
  33 */
  34 static const char* RLOG_MODULE_NAME="MAC";
  35 static int RLOG_MODULE_ID=4096;
  36 static int RLOG_FILE_ID=175;
  37
  38 /* header include files -- defines (.h) */
  39 #include "common_def.h"
  40 #include "tfu.h"           /* RGU defines */
  41 #include "lrg.h"           /* layer management defines for LTE-MAC */
  42 #include "rgr.h"           /* layer management defines for LTE-MAC */
  43 #include "rg_env.h"            /* defines and macros for MAC */
  44 #include "rg_sch_err.h"            /* defines and macros for MAC */
  45 #include "rg_sch_inf.h"            /* defines and macros for MAC */
  46 #include "rg_sch.h"            /* defines and macros for MAC */
  47 #include "rl_interface.h"
  48 #include "rl_common.h"
  49
  50
  51 /* header/extern include files (.x) */
  52 #include "tfu.x"           /* RGU types */
  53 #include "lrg.x"           /* layer management typedefs for MAC */
  54 #include "rgr.x"           /* layer management typedefs for MAC */
  55 #include "rg_sch_inf.x"            /* typedefs for MAC */
  56 #include "rg_sch.x"            /* typedefs for MAC */
  57
  58 #ifdef LTE_ADV
  59 Void rgSCHSCellActivation ARGS((
  60 RgSchUeCellInfo  *sCell
  61 ));
  62 #endif
  63  /** @brief This function is a utility function to start timers, it is a
  64   * generic function.
  65   *
  66   * @details
  67   *
  68   *     Function: rgSCHTmrStartTmr
  69   *
  70   *         Processing steps:
  71   *         - Starts timer at scheduler
  72   *
  73   *   @param[in]  RgSchCellCb    *cell
  74   *   @param[in]  Ptr            cb
  75   *   @param[in]  S16            tmrEvnt
  76   *   @param[in]  uint32_t            tmrVal
  77   *   @return  Void
  78   */
  79 Void rgSCHTmrStartTmr(RgSchCellCb *cell,Ptr cb,S16 tmrEvnt,uint32_t tmrVal)
  80 {
  81    CmTmrArg          arg;
  82    RgSchUeCb         *ue;
  83 #ifdef LTE_ADV
  84    RgSchUeCellInfo *sCellCb = NULLP;
  85 #endif
  86
  87 #ifndef LTE_ADV
  88    ue = (RgSchUeCb*)cb;
  89 #else
  90    if(tmrEvnt == RG_SCH_TMR_SCELL_DEACT)
  91    {
  92       sCellCb = (RgSchUeCellInfo *)cb;
  93    }
  94    else
  95    {
  96       ue = (RgSchUeCb*)cb;
  97    }
  98 #endif
  99
 100    switch (tmrEvnt)
 101    {
 102       case RG_SCH_TMR_ACKNACK_REP:
 103          arg.timers = &(ue->ackNakRepCb.ackNakRepTmr);
 104          RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
 105             "Hit AckNackRep timer");
 106          break;
 107       case RG_SCH_TMR_MEASGAP:
 108          arg.timers = &(ue->measGapCb.measGapTmr);
 109          break;
 110       case RG_SCH_TMR_UL_ACKNACK:
 111          arg.timers = &(ue->ackNakRepCb.ackNakRepUlInactvTmr);
 112          break;
 113       case RG_SCH_TMR_DL_ACKNACK:
 114          arg.timers = &(ue->ackNakRepCb.ackNakRepDlInactvTmr);
 115          break;
 116       case RG_SCH_TMR_UL_MEASGAP:
 117          arg.timers = &(ue->measGapCb.measGapUlInactvTmr);
 118          break;
 119       case RG_SCH_TMR_DL_MEASGAP:
 120          arg.timers = &(ue->measGapCb.measGapDlInactvTmr);
 121          break;
 122       case RG_SCH_TMR_TA:
 123          arg.timers = &(ue->taTmr);
 124          break;
 125         /*MS_WORKAROUND for CR FIXME */
 126 #ifndef RGR_V1
 127       case RG_SCH_TMR_BSR:
 128          {
 129             arg.timers = &(ue->bsrTmr);
 130             break;
 131          }
 132 #else
 133       case RG_SCH_TMR_BSR:
 134          {
 135 #ifdef NO_BSR_SR_5GTF
 136             return;
 137 #endif
 138             arg.timers = &(ue->bsrTmr);
 139             break;
 140          }
 141 #endif
 142       case RG_SCH_TMR_TXMODE_TRNSTN:
 143          {
 144             arg.timers = &(ue->txModeTransTmr);
 145             break;
 146          }
 147 #ifdef LTE_ADV
 148       case RG_SCH_TMR_SCELL_DEACT:
 149          {
 150             arg.timers = &(sCellCb->deactTmr);
 151             break;
 152          }
 153       case RG_SCH_TMR_SCELL_ACT_DELAY:
 154          {
 155             sCellCb = (RgSchUeCellInfo *)cb;
 156             arg.timers = &(sCellCb->actDelayTmr);
 157             break;
 158          }
 159 #endif
 160       default:
 161          RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
 162             "rgSCHTmrStartTmr() Incorrect Timer event");
 163          return;
 164    }
 165
 166    arg.tqCp = &(cell->tqCp);
 167    arg.tq   = cell->tq;
 168    arg.cb   = (PTR)cb;
 169    arg.evnt = tmrEvnt;
 170    arg.wait = tmrVal;
 171    arg.max  = 1;
 172    arg.tNum = NOTUSED;
 173    cmPlcCbTq(&arg);
 174    return;
 175
 176 } /* end of */
 177
 178  /** @brief This function stops the timer.
 179   *
 180   * @details
 181   *
 182   *     Function: rgSCHTmrStopTmr
 183   *
 184   *         Processing steps:
 185   *         - Stops timer at scheduler.
 186   *
 187   *   @param[in]  RgSchCellCb    *cell
 188   *   @param[in]  S16            tmrEvnt
 189   *   @param[in]  Ptr            cb
 190   *   @return  Void
 191   */
 192 Void rgSCHTmrStopTmr(RgSchCellCb *cell,S16 tmrEvnt,Ptr cb)
 193 {
 194    CmTmrArg          arg;
 195    RgSchUeCb         *ue;
 196 #ifdef LTE_ADV
 197    RgSchUeCellInfo *sCellCb = NULLP;
 198 #endif
 199
 200 #ifndef LTE_ADV
 201    ue = (RgSchUeCb*)cb;
 202 #else
 203    if(tmrEvnt == RG_SCH_TMR_SCELL_DEACT)
 204    {
 205       sCellCb = (RgSchUeCellInfo *)cb;
 206    }
 207    else
 208    {
 209       ue = (RgSchUeCb*)cb;
 210    }
 211 #endif
 212
 213    switch (tmrEvnt)
 214    {
 215       case RG_SCH_TMR_ACKNACK_REP:
 216          arg.timers = &(ue->ackNakRepCb.ackNakRepTmr);
 217          break;
 218       case RG_SCH_TMR_MEASGAP:
 219          arg.timers = &(ue->measGapCb.measGapTmr);
 220          break;
 221       case RG_SCH_TMR_UL_ACKNACK:
 222          arg.timers = &(ue->ackNakRepCb.ackNakRepUlInactvTmr);
 223          break;
 224       case RG_SCH_TMR_DL_ACKNACK:
 225          arg.timers = &(ue->ackNakRepCb.ackNakRepDlInactvTmr);
 226          break;
 227       case RG_SCH_TMR_UL_MEASGAP:
 228          arg.timers = &(ue->measGapCb.measGapUlInactvTmr);
 229          break;
 230       case RG_SCH_TMR_DL_MEASGAP:
 231          arg.timers = &(ue->measGapCb.measGapDlInactvTmr);
 232          break;
 233       case RG_SCH_TMR_TA:
 234          arg.timers = &(ue->taTmr);
 235          break;
 236                 /*MS_WORKAROUND for CR FIXME */
 237 #ifndef RGR_V1
 238       case RG_SCH_TMR_BSR:
 239
 240          {
 241             arg.timers = &(ue->bsrTmr);
 242             break;
 243          }
 244 #else
 245       case RG_SCH_TMR_BSR:
 246          {
 247 #ifdef NO_BSR_SR_5GTF
 248             return;
 249 #endif
 250             arg.timers = &(ue->bsrTmr);
 251             break;
 252          }
 253
 254 #endif
 255       case RG_SCH_TMR_TXMODE_TRNSTN:
 256          {
 257             arg.timers = &(ue->txModeTransTmr);
 258             break;
 259          }
 260 #ifdef LTE_ADV
 261       case RG_SCH_TMR_SCELL_DEACT:
 262          {
 263             arg.timers = &(sCellCb->deactTmr);
 264             break;
 265          }
 266       case RG_SCH_TMR_SCELL_ACT_DELAY:
 267          {
 268             sCellCb = (RgSchUeCellInfo *)cb;
 269             arg.timers = &(sCellCb->actDelayTmr);
 270             break;
 271          }
 272 #endif
 273
 274       default:
 275          RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
 276             "rgSCHTmrStopTmr() Incorrect Timer event");
 277          return;
 278    }
 279
 280    arg.tqCp = &(cell->tqCp);
 281    arg.tq   = cell->tq;
 282    arg.cb   = (PTR)cb;
 283    arg.evnt = tmrEvnt;
 284    arg.wait = NOTUSED;
 285    arg.max  = 0;
 286    arg.tNum = NOTUSED;
 287    cmRmvCbTq(&arg);
 288    return;
 289 } /* end of */
 290
 291  /** @brief This function handles timer expiry.
 292   *
 293   * @details
 294   *
 295   *     Function: rgSCHTmrProcTmr
 296   *
 297   *         Processing steps:
 298   *         - Handles processing on timer expiry at scheduler.
 299   *
 300   *   @param[in]  Ptr            cb
 301   *   @param[in]  S16            tmrEvnt
 302   *   @return  Void
 303   */
 304 Void rgSCHTmrProcTmr(Ptr cb,S16 tmrEvnt)
 305 {
 306    RgSchUeCb      *ue = NULLP;
 307 #ifdef LTE_ADV
 308    RgSchUeCellInfo *sCellCb = NULLP;
 309 #endif
 310
 311 #ifndef LTE_ADV
 312    ue = (RgSchUeCb*)cb;
 313 #else
 314    if(tmrEvnt == RG_SCH_TMR_SCELL_DEACT)
 315    {
 316       sCellCb = (RgSchUeCellInfo *)cb;
 317    }
 318    else
 319    {
 320       ue = (RgSchUeCb*)cb;
 321    }
 322 #endif
 323
 324
 325    switch (tmrEvnt)
 326    {
 327       case RG_SCH_TMR_ACKNACK_REP:
 328          rgSCHAckNakRepTmrExpry (ue);
 329          break;
 330       case RG_SCH_TMR_MEASGAP:
 331          rgSCHMeasGapANRepTmrExpry (ue);
 332          break;
 333       case RG_SCH_TMR_UL_MEASGAP:
 334       case RG_SCH_TMR_UL_ACKNACK:
 335          rgSCHMeasGapANRepUlInactvTmrExpry (ue, (uint8_t)tmrEvnt);
 336          break;
 337       case RG_SCH_TMR_DL_ACKNACK:
 338       case RG_SCH_TMR_DL_MEASGAP:
 339          rgSCHMeasGapANRepDlInactvTmrExpry (ue, (uint8_t)tmrEvnt);
 340          break;
 341       case RG_SCH_TMR_TA:
 342 #ifdef EMTC_ENABLE
 343          /*TODO Needto handle TA Timer expiry for EMTC UE*/
 344          if(TRUE == ue->isEmtcUe)
 345          {
 346             RLOG0(L_INFO,"TA Timer Expiry is not handled for EMTC UE\n");
 347             break;
 348          }
 349 #endif
 350          rgSCHDhmProcTAExp (ue);
 351          break;
 352                 /*MS_WORKAROUND for CR FIXME */
 353 #ifndef RGR_V1
 354       case RG_SCH_TMR_BSR:
 355          {
 356             rgSCHCmnBsrTmrExpry(ue);
 357          }
 358          break;
 359 #else
 360       case RG_SCH_TMR_BSR:
 361          {
 362             rgSCHCmnBsrTmrExpry(ue);
 363          }
 364          break;
 365
 366 #endif
 367       case RG_SCH_TMR_TXMODE_TRNSTN:
 368          {
 369             ue->txModeTransCmplt = TRUE;
 370             break;
 371          }
 372 #ifdef LTE_ADV
 373       case RG_SCH_TMR_SCELL_DEACT:
 374          {
 375             rgSCHSCellDeactTmrExpry(sCellCb);
 376             break;
 377          }
 378       case RG_SCH_TMR_SCELL_ACT_DELAY:
 379          {
 380             sCellCb = (RgSchUeCellInfo *)cb;
 381             rgSCHSCellActivation(sCellCb);
 382             break;
 383          }
 384 #endif
 385       default:
 386         if(ue)
 387         {
 388            RLOG_ARG0(L_ERROR,DBG_INSTID,ue->cell->instIdx,
 389                  "rgSCHTmrProcTmr() Incorrect Timer event");
 390         }
 391          return;
 392    }
 393    return;
 394 } /* end of */
 395
 396 \f
 397 /**********************************************************************
 398
 399          End of file
 400 **********************************************************************/