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