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