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