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 EXTERN 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]  U32            tmrVal
  77   *   @return  Void
  78   */
  79 #ifdef ANSI
  80 Void rgSCHTmrStartTmr
  81 (
  82 RgSchCellCb *cell,
  83 Ptr         cb,
  84 S16         tmrEvnt,
  85 U32         tmrVal
  86 )
  87 #else
  88 Void rgSCHTmrStartTmr (cell, cb, tmrEvnt, tmrVal)
  89 RgSchCellCb *cell;
  90 Ptr         cb;
  91 S16         tmrEvnt;
  92 U32         tmrVal;
  93 #endif
  94 {
  95    CmTmrArg          arg;
  96    RgSchUeCb         *ue;
  97 #ifdef LTE_ADV
  98    RgSchUeCellInfo *sCellCb = NULLP;
  99 #endif
 100
 101 #ifndef LTE_ADV
 102    ue = (RgSchUeCb*)cb;
 103 #else
 104    if(tmrEvnt == RG_SCH_TMR_SCELL_DEACT)
 105    {
 106       sCellCb = (RgSchUeCellInfo *)cb;
 107    }
 108    else
 109    {
 110       ue = (RgSchUeCb*)cb;
 111    }
 112 #endif
 113
 114    switch (tmrEvnt)
 115    {
 116       case RG_SCH_TMR_ACKNACK_REP:
 117          arg.timers = &(ue->ackNakRepCb.ackNakRepTmr);
 118          RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
 119             "Hit AckNackRep timer");
 120          break;
 121       case RG_SCH_TMR_MEASGAP:
 122          arg.timers = &(ue->measGapCb.measGapTmr);
 123          break;
 124       case RG_SCH_TMR_UL_ACKNACK:
 125          arg.timers = &(ue->ackNakRepCb.ackNakRepUlInactvTmr);
 126          break;
 127       case RG_SCH_TMR_DL_ACKNACK:
 128          arg.timers = &(ue->ackNakRepCb.ackNakRepDlInactvTmr);
 129          break;
 130       case RG_SCH_TMR_UL_MEASGAP:
 131          arg.timers = &(ue->measGapCb.measGapUlInactvTmr);
 132          break;
 133       case RG_SCH_TMR_DL_MEASGAP:
 134          arg.timers = &(ue->measGapCb.measGapDlInactvTmr);
 135          break;
 136       case RG_SCH_TMR_TA:
 137          arg.timers = &(ue->taTmr);
 138          break;
 139         /*MS_WORKAROUND for CR FIXME */
 140 #ifndef RGR_V1
 141       case RG_SCH_TMR_BSR:
 142          {
 143             arg.timers = &(ue->bsrTmr);
 144             break;
 145          }
 146 #else
 147       case RG_SCH_TMR_BSR:
 148          {
 149 #ifdef NO_BSR_SR_5GTF
 150             RETVOID;
 151 #endif
 152             arg.timers = &(ue->bsrTmr);
 153             break;
 154          }
 155 #endif
 156       case RG_SCH_TMR_TXMODE_TRNSTN:
 157          {
 158             arg.timers = &(ue->txModeTransTmr);
 159             break;
 160          }
 161 #ifdef LTE_ADV
 162       case RG_SCH_TMR_SCELL_DEACT:
 163          {
 164             arg.timers = &(sCellCb->deactTmr);
 165             break;
 166          }
 167       case RG_SCH_TMR_SCELL_ACT_DELAY:
 168          {
 169             sCellCb = (RgSchUeCellInfo *)cb;
 170             arg.timers = &(sCellCb->actDelayTmr);
 171             break;
 172          }
 173 #endif
 174       default:
 175          RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
 176             "rgSCHTmrStartTmr() Incorrect Timer event");
 177          RETVOID;
 178    }
 179
 180    arg.tqCp = &(cell->tqCp);
 181    arg.tq   = cell->tq;
 182    arg.cb   = (PTR)cb;
 183    arg.evnt = tmrEvnt;
 184    arg.wait = tmrVal;
 185    arg.max  = 1;
 186    arg.tNum = NOTUSED;
 187    cmPlcCbTq(&arg);
 188    RETVOID;
 189
 190 } /* end of */
 191
 192  /** @brief This function stops the timer.
 193   *
 194   * @details
 195   *
 196   *     Function: rgSCHTmrStopTmr
 197   *
 198   *         Processing steps:
 199   *         - Stops timer at scheduler.
 200   *
 201   *   @param[in]  RgSchCellCb    *cell
 202   *   @param[in]  S16            tmrEvnt
 203   *   @param[in]  Ptr            cb
 204   *   @return  Void
 205   */
 206 #ifdef ANSI
 207 Void rgSCHTmrStopTmr
 208 (
 209 RgSchCellCb   *cell,
 210 S16           tmrEvnt,
 211 Ptr           cb
 212 )
 213 #else
 214 Void rgSCHTmrStopTmr (cell, tmrEvnt, cb)
 215 RgSchCellCb   *cell;
 216 S16           tmrEvnt;
 217 Ptr           cb;
 218 #endif
 219 {
 220    CmTmrArg          arg;
 221    RgSchUeCb         *ue;
 222 #ifdef LTE_ADV
 223    RgSchUeCellInfo *sCellCb = NULLP;
 224 #endif
 225
 226 #ifndef LTE_ADV
 227    ue = (RgSchUeCb*)cb;
 228 #else
 229    if(tmrEvnt == RG_SCH_TMR_SCELL_DEACT)
 230    {
 231       sCellCb = (RgSchUeCellInfo *)cb;
 232    }
 233    else
 234    {
 235       ue = (RgSchUeCb*)cb;
 236    }
 237 #endif
 238
 239    switch (tmrEvnt)
 240    {
 241       case RG_SCH_TMR_ACKNACK_REP:
 242          arg.timers = &(ue->ackNakRepCb.ackNakRepTmr);
 243          break;
 244       case RG_SCH_TMR_MEASGAP:
 245          arg.timers = &(ue->measGapCb.measGapTmr);
 246          break;
 247       case RG_SCH_TMR_UL_ACKNACK:
 248          arg.timers = &(ue->ackNakRepCb.ackNakRepUlInactvTmr);
 249          break;
 250       case RG_SCH_TMR_DL_ACKNACK:
 251          arg.timers = &(ue->ackNakRepCb.ackNakRepDlInactvTmr);
 252          break;
 253       case RG_SCH_TMR_UL_MEASGAP:
 254          arg.timers = &(ue->measGapCb.measGapUlInactvTmr);
 255          break;
 256       case RG_SCH_TMR_DL_MEASGAP:
 257          arg.timers = &(ue->measGapCb.measGapDlInactvTmr);
 258          break;
 259       case RG_SCH_TMR_TA:
 260          arg.timers = &(ue->taTmr);
 261          break;
 262                 /*MS_WORKAROUND for CR FIXME */
 263 #ifndef RGR_V1
 264       case RG_SCH_TMR_BSR:
 265
 266          {
 267             arg.timers = &(ue->bsrTmr);
 268             break;
 269          }
 270 #else
 271       case RG_SCH_TMR_BSR:
 272          {
 273 #ifdef NO_BSR_SR_5GTF
 274             RETVOID;
 275 #endif
 276             arg.timers = &(ue->bsrTmr);
 277             break;
 278          }
 279
 280 #endif
 281       case RG_SCH_TMR_TXMODE_TRNSTN:
 282          {
 283             arg.timers = &(ue->txModeTransTmr);
 284             break;
 285          }
 286 #ifdef LTE_ADV
 287       case RG_SCH_TMR_SCELL_DEACT:
 288          {
 289             arg.timers = &(sCellCb->deactTmr);
 290             break;
 291          }
 292       case RG_SCH_TMR_SCELL_ACT_DELAY:
 293          {
 294             sCellCb = (RgSchUeCellInfo *)cb;
 295             arg.timers = &(sCellCb->actDelayTmr);
 296             break;
 297          }
 298 #endif
 299
 300       default:
 301          RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
 302             "rgSCHTmrStopTmr() Incorrect Timer event");
 303          RETVOID;
 304    }
 305
 306    arg.tqCp = &(cell->tqCp);
 307    arg.tq   = cell->tq;
 308    arg.cb   = (PTR)cb;
 309    arg.evnt = tmrEvnt;
 310    arg.wait = NOTUSED;
 311    arg.max  = 0;
 312    arg.tNum = NOTUSED;
 313    cmRmvCbTq(&arg);
 314    RETVOID;
 315 } /* end of */
 316
 317  /** @brief This function handles timer expiry.
 318   *
 319   * @details
 320   *
 321   *     Function: rgSCHTmrProcTmr
 322   *
 323   *         Processing steps:
 324   *         - Handles processing on timer expiry at scheduler.
 325   *
 326   *   @param[in]  Ptr            cb
 327   *   @param[in]  S16            tmrEvnt
 328   *   @return  Void
 329   */
 330 #ifdef ANSI
 331 Void rgSCHTmrProcTmr
 332 (
 333 Ptr         cb,
 334 S16         tmrEvnt
 335 )
 336 #else
 337 Void rgSCHTmrProcTmr (cb, tmrEvnt)
 338 Ptr         cb;
 339 S16         tmrEvnt;
 340 #endif
 341 {
 342    RgSchUeCb      *ue = NULLP;
 343 #ifdef LTE_ADV
 344    RgSchUeCellInfo *sCellCb = NULLP;
 345 #endif
 346
 347 #ifndef LTE_ADV
 348    ue = (RgSchUeCb*)cb;
 349 #else
 350    if(tmrEvnt == RG_SCH_TMR_SCELL_DEACT)
 351    {
 352       sCellCb = (RgSchUeCellInfo *)cb;
 353    }
 354    else
 355    {
 356       ue = (RgSchUeCb*)cb;
 357    }
 358 #endif
 359
 360
 361    switch (tmrEvnt)
 362    {
 363       case RG_SCH_TMR_ACKNACK_REP:
 364          rgSCHAckNakRepTmrExpry (ue);
 365          break;
 366       case RG_SCH_TMR_MEASGAP:
 367          rgSCHMeasGapANRepTmrExpry (ue);
 368          break;
 369       case RG_SCH_TMR_UL_MEASGAP:
 370       case RG_SCH_TMR_UL_ACKNACK:
 371          rgSCHMeasGapANRepUlInactvTmrExpry (ue, (U8)tmrEvnt);
 372          break;
 373       case RG_SCH_TMR_DL_ACKNACK:
 374       case RG_SCH_TMR_DL_MEASGAP:
 375          rgSCHMeasGapANRepDlInactvTmrExpry (ue, (U8)tmrEvnt);
 376          break;
 377       case RG_SCH_TMR_TA:
 378 #ifdef EMTC_ENABLE
 379          /*TODO Needto handle TA Timer expiry for EMTC UE*/
 380          if(TRUE == ue->isEmtcUe)
 381          {
 382             RLOG0(L_INFO,"TA Timer Expiry is not handled for EMTC UE\n");
 383             break;
 384          }
 385 #endif
 386          rgSCHDhmProcTAExp (ue);
 387          break;
 388                 /*MS_WORKAROUND for CR FIXME */
 389 #ifndef RGR_V1
 390       case RG_SCH_TMR_BSR:
 391          {
 392             rgSCHCmnBsrTmrExpry(ue);
 393          }
 394          break;
 395 #else
 396       case RG_SCH_TMR_BSR:
 397          {
 398             rgSCHCmnBsrTmrExpry(ue);
 399          }
 400          break;
 401
 402 #endif
 403       case RG_SCH_TMR_TXMODE_TRNSTN:
 404          {
 405             ue->txModeTransCmplt = TRUE;
 406             break;
 407          }
 408 #ifdef LTE_ADV
 409       case RG_SCH_TMR_SCELL_DEACT:
 410          {
 411             rgSCHSCellDeactTmrExpry(sCellCb);
 412             break;
 413          }
 414       case RG_SCH_TMR_SCELL_ACT_DELAY:
 415          {
 416             sCellCb = (RgSchUeCellInfo *)cb;
 417             rgSCHSCellActivation(sCellCb);
 418             break;
 419          }
 420 #endif
 421       default:
 422         if(ue)
 423         {
 424            RLOG_ARG0(L_ERROR,DBG_INSTID,ue->cell->instIdx,
 425                  "rgSCHTmrProcTmr() Incorrect Timer event");
 426         }
 427          RETVOID;
 428    }
 429    RETVOID;
 430 } /* end of */
 431
 432 \f
 433 /**********************************************************************
 434
 435          End of file
 436 **********************************************************************/