src/5gnrmac/rg.h

   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:   MAC layer
  22
  23     Type:   H include file
  24
  25     Desc:   Defines required by LTE-MAC
  26
  27     File:   rg.h
  28
  29 **********************************************************************/
  30
  31 /** @file rg.h
  32 @brief This file contains definitons for Mac.
  33 */
  34 \f
  35
  36 #ifndef __RGH__
  37 #define __RGH__
  38
  39 #include "rl_interface.h"
  40 #include "rl_common.h"
  41
  42
  43 #ifdef L2_OPTMZ
  44 #include "gen.x"           /* general layer */
  45 #include "ssi.x"           /* system service interface */
  46 #include "ss_strm.h"
  47 #include "ss_strm.x"
  48 #include "ss_queue.h"
  49 #include "ss_queue.x"
  50 #include "ss_task.x"
  51 #include "ss_msg.x"
  52
  53 #define RG_MAC_HDR_SIZE 250
  54 #define RG_MAC_CE_SIZE  250
  55 U32 MacPtrAddress;
  56 U32 macHeader[2];
  57
  58 #define RG_ADD_DBuf(_dBuf,_size,_mBuf)\
  59 { \
  60   SsMsgInfo *mInfo = NULLP; \
  61   mInfo = (SsMsgInfo *)_mBuf->b_rptr; \
  62   ssGetDBufOfSize(mInfo->region,_size, &_dBuf); \
  63   SUpdMsg(_mBuf, _dBuf,0);\
  64   _dBuf->b_wptr = _dBuf->b_rptr =  (_dBuf->b_datap->db_base + 5);\
  65   MacPtrAddress = (U32)_dBuf->b_wptr;\
  66 }
  67 #endif
  68
  69
  70
  71 #define RGLAYERNAME     "MAC"
  72 #define RG_MAX_TB_PER_UE 2
  73 #define RG_MAX_BCCH_DLSCH 2
  74 #define RG_INVALID_RNTI   0x0000
  75
  76 #define RG_MAX_NUM_DED_LC 10       /* maximum dedicated logical channels in a UE */
  77 #define RG_MAX_NUM_CMN_LC 5       /* maximum number of common logical
  78                                      channels in a cell */
  79 #define RG_MAX_LCG_PER_UE 4
  80 #define RG_CON_RES_ID_SZ  6
  81 #define RG_MAX_RA_RNTI   60
  82
  83 /* Added support for SPS*/
  84 #ifdef LTEMAC_SPS
  85 #define RG_ADDL_SPS_OCC_FOR_EXP_REL 2
  86
  87 #define RG_SPS_SID_PACKET_SIZE 10
  88 #define RG_SPS_LCG_ID  1
  89
  90 #endif
  91
  92 /* Well known RNTIS */
  93 #define RG_SI_RNTI        0xffff
  94 #define RG_P_RNTI         0xfffe
  95
  96 #define RG_MAX_UPPERSAP               3
  97 #define RG_MAX_LOWERSAP               1
  98 #define RG_TQ_SIZE                    10   /* Timing Queue Size */
  99 #define RG_MAX_TIMER     RG_MAX_LOWERSAP   /* MAX number of MAC timers */
 100 #define RG_NMB_CELL_HASHBIN           10   /* Number of Hash Bins for cell hash
 101                                               table */
 102 #define RG_NMB_UE_HASHBIN             10   /* Number of Hash Bins for UE hash
 103                                               table */
 104 #define RG_BNDREQ_TMR    1    /* Bind Request timer event value */
 105 #define RG_MAX_BNDRETRY  2    /* Max number of Bind Retries for TFU SAP */
 106
 107
 108 #define RG_UE_TQ_SIZE    10   /* Timing Queue Size */
 109
 110 #define RG_INVALID_SCHD_TYPE 255
 111 #define RG_MAX_UE_PER_CELL 0xFFFF /*!< Maximum number of UEs per cell */
 112 #ifdef EIGHT_UE_PER_TTI_CHANGES
 113 #define RG_MAX_UE_BIN_PER_CELL 1024 /*!< Maximum number of UE bins per cell */
 114 #else
 115 #define RG_MAX_UE_BIN_PER_CELL 128 /*!< Maximum number of UE bins per cell */
 116 #endif
 117 #define RG_MIN_DL_BW       6    /*!< Minimum Downlink bandwidth in RBs */
 118 #define RG_MAX_DL_BW       110  /*!< Maximum Downlink bandwidth in RBs */
 119 #define RG_MIN_UL_BW       6    /*!< Minimum Uplink bandwidth in RBs */
 120 #define RG_MAX_UL_BW       110  /*!< Maximum Uplink bandwidth in RBs */
 121 #define RG_MIN_CFI_VAL     1    /*!< Minimum value for CFI */
 122 #define RG_MAX_CFI_VAL     3    /*!< Maximum value for CFI */
 123 #define RG_QM_BPSK         2    /*!< Qm value for BPSK */
 124 #define RG_QM_QPSK         4    /*!< Qm value for QPSK */
 125 #define RG_QM_64QAM        6    /*!< Qm value for 64QAM */
 126 #define RG_MIN_SRS_SFCFG_IDX 0  /*!< Minimum value for SRS subframe
 127                                      configurtion index */
 128 #define RG_MAX_SRS_SFCFG_IDX 15  /*!< Maximum value for SRS subframe
 129                                      configurtion index */
 130 #define RG_MAX_SRS_TX_OFFSET 8    /*!< Maximum number of SRS transmission
 131                                     offsets per cell */
 132 #define RG_MIN_MAC_RNTI      10   /*!< Minimum value of RNTI to be managed by
 133                                     MAC */
 134
 135 /* HARQ related MACROs */
 136 #define RG_NUM_DL_HQ_PROC 8
 137 #define RG_NUM_UL_HQ_PROC 8
 138 #define RG_MIN_HQ_TX 1
 139
 140 /* Group power related MACROs */
 141 #define RG_MAX_GRP_PWR_FMT3_IDX  15   /*!< Maximum index value for group power format 3 */
 142 #define RG_MAX_GRP_PWR_FMT3A_IDX 31   /*!< Maximum index value for group power format 3A */
 143
 144 /* MACROs to indicate cell specific config for cell to be active */
 145 #define RG_BCCH_BCH_CFG_DONE      (1<<0)
 146 #define RG_BCCH_DLSCH_CFG1_DONE    (1<<1)
 147 #define RG_BCCH_DLSCH_CFG2_DONE    (1<<2)
 148 #define RG_PCCH_CFG_DONE          (1<<3)
 149 #define RG_UL_CCCH_CFG_DONE       (1<<4)
 150 #define RG_DL_CCCH_CFG_DONE       (1<<5)
 151 #define RG_SCHD_CFG_DONE          (1<<6)
 152 #define RG_CELL_ACTIVE (RG_BCCH_BCH_CFG_DONE | RG_BCCH_DLSCH_CFG1_DONE |  RG_BCCH_DLSCH_CFG2_DONE | RG_PCCH_CFG_DONE | RG_UL_CCCH_CFG_DONE | RG_DL_CCCH_CFG_DONE)
 153 /* Logical channel realated MACROs */
 154 #define RG_INVALID_LCG_ID  255
 155 #define RG_INVALID_LC_ID   255
 156 #define RG_BCCH_BCH_IDX   0
 157 #define RG_BCCH_DLSCH_IDX 1
 158 #define RG_PCCH_IDX 2
 159
 160 /* constants for MIN & MAX qci*/
 161 #define RG_QCI_MIN 1
 162 #define RG_QCI_MAX 9
 163
 164 /* PUCCH related macros */
 165 #define RG_PUCCH_MAXVAL_CS    7   /*!< Maximum value for cyclic shift of PUCCH */
 166 #define RG_PUCCH_MINVAL_DS    1   /*!< Mininmum value for delta shift of PUCCH */
 167 #define RG_PUCCH_MAXVAL_DS    3   /*!< Maximum value for delta shift of PUCCH */
 168
 169 /* DUX related macros */
 170 #define RG_LCID_MASK 0x3F
 171
 172 #define RG_LCID_LEN 0x6
 173 #define RG_CCCH_LCID 0x00
 174 #define RG_DEDLC_MIN_LCID 0x01
 175 #define RG_DEDLC_MAX_LCID 0x0A
 176 #define RG_RES_MIN_LCID 0x0B
 177 #define RG_RES_MAX_LCID 0x18
 178 #define RG_EXT_PHR_LCID 0x19
 179 #define RG_PHR_LCID 0x1A
 180 #define RG_CRNTI_LCID 0X1B
 181 #define RG_TRUNC_BSR_LCID 0X1C
 182 #define RG_SHORT_BSR_LCID 0X1D
 183 #define RG_LONG_BSR_LCID  0X1E
 184 #define RG_PAD_LCID 0x3F
 185 #define RG_MAX_EXTN_PAD_SUBHDRS 0x02
 186 #define RG_REF_PCMAX  0xFF
 187
 188 #define RG_CCCH_SDU_PRSNT     (1<<0)
 189 #define RG_CRNTI_CE_PRSNT     (1<<1)
 190 #define RG_PHR_CE_PRSNT       (1<<2)
 191 #define RG_TRUNC_BSR_CE_PRSNT (1<<3)
 192 #define RG_SHORT_BSR_CE_PRSNT (1<<4)
 193 #define RG_LONG_BSR_CE_PRSNT  (1<<5)
 194 /* L2_COUNTERS */
 195 #define RG_ACTIVE_LC_PRSNT  (1<<6)
 196
 197 #ifdef LTEMAC_SPS
 198 #define RG_UL_SPS_ACT_PRSNT (1<<7)
 199 #endif
 200 #define RG_EXT_PHR_CE_PRSNT (1<<8)
 201
 202 /* LOGICAL CHANNEL */
 203 #define RG_MAX_LC_PER_UE      10
 204 /* Maximum number of common logical channel control blocks */
 205 #define RG_MAX_CMN_LC_CB      3
 206 #define RG_MAX_BCCH           2
 207
 208 #ifdef LTE_ADV
 209 #define RG_MAX_SCELL_PER_UE   7  /*!< MAX SCell can be Added per Cell */
 210 #endif /* LTE_ADV */
 211
 212 #define RG_OPTM_NUM_DED_LC    3
 213
 214 /* Random access related MACROs */
 215 #define RG_MAX_RA_PREAMBLE_FMT 3 /*!< Maximun value of Random access preamble
 216                                       format */
 217 #define RG_MAX_RA_WINSIZE    10  /*!< Maximum size of Random access response
 218                                       window in subframes */
 219 #define RG_MIN_RA_WINSIZE    2   /*!< Minimum size of Random access response
 220                                       window in subframes */
 221 #define RG_MIN_NUM_RA_PREAMBLE 4 /*!< Minimum number of Random access
 222                                       preambles */
 223 #define RG_MAX_NUM_RA_PREAMBLE 64 /*!< Maximim number of Random access
 224                                       preambles */
 225 #define RG_NUM_RA_RB     6
 226
 227 #define RG_MAX_RA_RSP_ALLOC    4 /*!< Maximum number of Random access
 228                                       allocations */
 229 #define RG_CRG_CFG 1          /* CRG configuration element */
 230 #define RG_RGR_CFG 2          /* RGR configuration element */
 231
 232 #define RG_NUM_ITBS         27
 233 #define RG_MAX_NUM_RB       110
 234
 235 #define RG_MAX_NUM_PAD_HDRS 2
 236
 237 /* Changes for MIMO feature addition */
 238 /* Removed dependency on MIMO compile-time flag */
 239 #define RG_MAX_LYR_PERCW    2
 240
 241 #ifdef LTE_TDD
 242 #define RG_MAX_DL_HARQ_NUM   15
 243 #else
 244 #define RG_MAX_DL_HARQ_NUM   8
 245 #endif
 246
 247 #define MAC_MEM_REGION       4
 248 #define MAC_POOL 1
 249 /* allocate and zero out a MAC static buffer */
 250 #define MAC_ALLOC(_datPtr, _size)                            \
 251 {                                                            \
 252    S16 _ret;                                                 \
 253    _ret = SGetSBuf(MAC_MEM_REGION, MAC_POOL,                 \
 254                     (Data **)&_datPtr, _size);               \
 255    if(_ret == ROK)                                           \
 256       cmMemset((U8*)_datPtr, 0, _size);                      \
 257    else                                                      \
 258       _datPtr = NULLP;                                       \
 259 }
 260
 261 /* free a static buffer */
 262 #define MAC_FREE(_datPtr, _size)                             \
 263    if(_datPtr)                                               \
 264       SPutSBuf(MAC_MEM_REGION, MAC_POOL,                     \
 265          (Data *)_datPtr, _size);
 266
 267 /* Allocate shared memory to be used for LWLC
 268  * during inter-layer communication */
 269 #define MAC_ALLOC_SHRABL_BUF(_buf, _size)                    \
 270 {                                                            \
 271    if(SGetStaticBuffer(MAC_MEM_REGION, MAC_POOL,             \
 272       (Data **)&_buf, (Size) _size, 0) == ROK)               \
 273    {                                                         \
 274       cmMemset((U8 *)(_buf), 0, _size);                      \
 275    }                                                         \
 276    else                                                      \
 277    {                                                         \
 278       (_buf) = NULLP;                                        \
 279    }                                                         \
 280 }
 281
 282 /* Free shared memory, received through LWLC */
 283 #define MAC_FREE_SHRABL_BUF(_region, _pool,_buf, _size)       \
 284 {                                                            \
 285    if (_buf != NULLP)                                        \
 286    {                                                         \
 287       (Void) SPutStaticBuffer(_region, _pool,                \
 288             (Data *) _buf, (Size) _size, 0);                 \
 289        _buf = NULLP;                                         \
 290    }                                                         \
 291 }
 292
 293 /* Free shared memory, received through LWLC */
 294 #define MAC_FREE_MEM(_region, _pool, _datPtr, _size)         \
 295    if(_datPtr)                                               \
 296        SPutSBuf(_region, _pool,(Data *)_datPtr, _size);      \
 297    _datPtr = NULL;
 298
 299 #define RG_LCG_ISCFGD(lcg) ((lcg)->lcgId != RG_INVALID_LCG_ID)
 300 /* Corrected the check for dlCcchId */
 301 #define RG_DLCCCH_ISCFGD(cell) ((cell)->dlCcchId != RG_INVALID_LC_ID)
 302 #define RG_ULCCCH_ISCFGD(cell) ((cell)->ulCcchId != RG_INVALID_LC_ID)
 303 /* After merging from 2.1 to 2.2 */
 304 #define RG_CALC_SF_DIFF(_time1, _time2)\
 305    (_time1.sfn*RG_NUM_SUB_FRAMES_5G+_time1.slot) < (_time2.sfn*RG_NUM_SUB_FRAMES_5G+_time2.slot)?\
 306      ((_time1.sfn+RG_MAX_SFN)*RG_NUM_SUB_FRAMES_5G+_time1.slot) -\
 307        (_time2.sfn*RG_NUM_SUB_FRAMES_5G+_time2.slot) : \
 308      (_time1.sfn*RG_NUM_SUB_FRAMES_5G+_time1.slot) - (_time2.sfn*RG_NUM_SUB_FRAMES_5G+_time2.slot)
 309 /*LTE_L2_MEAS_PHASE2*/
 310 #define RG_CALC_SFN_SF_DIFF(_time1,_sfnCycle, _time2)\
 311 (((_time1.sfn+RG_MAX_SFN * _sfnCycle)*RG_NUM_SUB_FRAMES_5G) + _time1.slot -\
 312 (_time2.sfn*RG_NUM_SUB_FRAMES_5G + _time2.slot))
 313
 314 #define RG_EXT_LCID(_lcId, _byte) {\
 315       (_lcId) = (_byte) & RG_LCID_MASK; \
 316 }
 317 #define RG_EXT_FORMT_BIT(_fmtBit, _byte) {\
 318       (_fmtBit) = ((_byte) >> RG_LCID_LEN) & 0x01; \
 319 }
 320
 321 #define RG_EXT_EXTN_BIT(_extnBit, _byte) {\
 322       (_extnBit) = ((_byte) >> RG_LCID_LEN) & 0x01; \
 323 }
 324
 325 #ifndef MS_MBUF_CORRUPTION
 326 #define MS_BUF_ADD_ALLOC_CALLER()
 327 #endif
 328
 329 #define RG_PACK_PAD(_padBuf,_size,_sduBuf) { \
 330   Buffer *sduEnd = NULLP; \
 331   SsMsgInfo *mInfo = NULLP; \
 332   mInfo = (SsMsgInfo *)_sduBuf->b_rptr; \
 333   ssGetDBufOfSize(mInfo->region,_size, &_padBuf); \
 334   if (_padBuf == NULLP) \
 335   { \
 336     RLOG0(L_ERROR, "RGERR_MUX_BLD_CEHDR_FAIL");\
 337     RETVALUE(RFAILED);\
 338   } \
 339   if (mInfo->endptr == NULLP) { \
 340     sduEnd = _sduBuf; \
 341     }\
 342   else \
 343   {  \
 344     sduEnd = mInfo->endptr; \
 345   } \
 346   sduEnd->b_cont = _padBuf; \
 347   padBuf->b_wptr += _size; \
 348   mInfo = (SsMsgInfo *)_sduBuf->b_rptr; \
 349   mInfo->endptr = _padBuf; \
 350   mInfo->len += _size; \
 351 }
 352
 353 #define RG_PACK_SDU(_sdusBuf, _sduBuf, _ret) {\
 354    _ret = SCatMsg(_sdusBuf, _sduBuf, M1M2);\
 355 }
 356
 357 #define RG_PACK_LAST_SDU_SHDR(_subHdr, _lcId, _mBuf, _ret) {\
 358    _ret = ROK;\
 359    _subHdr.shLen = 1;\
 360    _subHdr.shData[0] = (0x1F & _lcId);\
 361    MS_BUF_ADD_ALLOC_CALLER(); \
 362    _ret = SAddPstMsgMult(&_subHdr.shData[0], _subHdr.shLen, _mBuf);\
 363 }
 364
 365 #define RGADDTOCRNTTIME(crntTime, toFill, incr)          \
 366    if ((crntTime.slot + incr) > (RG_NUM_SUB_FRAMES_5G - 1))   \
 367       toFill.sfn = (crntTime.sfn + 1);      \
 368    else                                                  \
 369       toFill.sfn = crntTime.sfn;                              \
 370    toFill.slot = (crntTime.slot + incr) % RG_NUM_SUB_FRAMES_5G; \
 371    if (toFill.sfn >= RG_MAX_SFN) \
 372    { \
 373       toFill.sfn%=RG_MAX_SFN; \
 374    } \
 375
 376 #define RGSUBFRMCRNTTIME(crntTime, toFill, dcr)    \
 377 {                                                  \
 378    if (crntTime.sfn == 0)                          \
 379 {                                                  \
 380    if ((crntTime.slot - (dcr)) < 0)              \
 381    {                                               \
 382       toFill.sfn = RG_MAX_SFN - 1;                 \
 383    }                                               \
 384    else                                            \
 385    {                                               \
 386    toFill.sfn = crntTime.sfn;                      \
 387    }                                               \
 388 }                                                  \
 389 else                                               \
 390 {                                                  \
 391    if ((crntTime.slot - (dcr)) < 0)              \
 392    {                                               \
 393    toFill.sfn = crntTime.sfn - 1;                  \
 394    }                                               \
 395    else                                            \
 396    toFill.sfn = crntTime.sfn;                      \
 397 }                                                  \
 398 toFill.slot = (RG_NUM_SUB_FRAMES_5G + crntTime.slot - (dcr)) % (RG_NUM_SUB_FRAMES_5G);                                   \
 399 }
 400
 401 #define RGCPYTIMEINFO(src, dst)  \
 402    dst.sfn    = src.sfn;     \
 403    dst.slot   = src.slot;
 404 #define RG_TIMEINFO_SAME(x, y) ((x.sfn == y.sfn) && (x.slot == y.slot))
 405
 406
 407 #define rgPBuf(_inst)  rgCb[_inst].rgInit.prntBuf
 408
 409 /* Debug Prints for MAC */
 410 #ifdef DEBUGP
 411 #define RGDBGERRNEW(_inst,_args)          \
 412                   DBGP(&rgCb[_inst].rgInit, RGLAYERNAME, DBGMASK_ERR, _args)
 413 #define RGDBGINFONEW(_inst,_args)         \
 414                   DBGP(&rgCb[_inst].rgInit, RGLAYERNAME, DBGMASK_INFO, _args)
 415 #else
 416 #define RGDBGERRNEW(_inst,_args)
 417 #define RGDBGINFONEW(_inst,_args)
 418 #endif /* #ifdef DEBUGP */
 419 #define RGDBGPRM(_inst,_args)
 420 #define RGDBGERR(_inst,_args)
 421 #define RGDBGINFO(_inst,_args)
 422
 423 #ifdef ERRCLS_KW
 424 #define RG_NULL_CHECK(_inst, _ptr )     \
 425    if((_ptr) == NULLP)  \
 426    {                                               \
 427       RGDBGERRNEW(_inst, (rgPBuf(_inst),"Null Pointer detected"));\
 428       SExit();\
 429    }
 430 #define RG_ARRAY_BOUND_CHECK(_inst, _array, _idxVal)     \
 431    if((_idxVal) >= (sizeof(_array)/sizeof(_array[0]))) \
 432    {                                               \
 433       RGDBGERRNEW(_inst, (rgPBuf(_inst),"Array Bound Check Failed"));\
 434       SExit();\
 435    }
 436 #else
 437 #define RG_NULL_CHECK(_inst, _ptr )
 438 #define RG_ARRAY_BOUND_CHECK(_inst, _array, _idxVal)
 439 #endif
 440
 441 /* Macro to free the message buffer and initialize it to zero */
 442 /***********************************************************
 443  *
 444  *     Name : RG_FREE_MSG
 445  *
 446  *     Desc : Macro to free the message buffer and initialize it to zero
 447  *
 448  *     Input  : mBuf - message buffer pointer to be retunrned
 449  *
 450  *     Output : None.
 451  *
 452  *     Notes: None
 453  *
 454  **********************************************************/
 455 #define RG_FREE_MSG(_buf)\
 456 {\
 457    if (NULLP != (_buf)) \
 458    { \
 459       SPutMsg((_buf)); \
 460       _buf = NULLP; \
 461    } \
 462 }
 463
 464 #define RG_FREE_MEM(_mem)\
 465 {\
 466    if (NULLP != (_mem)) \
 467    { \
 468       cmFreeMem((_mem)); \
 469       _mem = NULLP; \
 470    } \
 471 }
 472
 473 #ifdef L2_OPTMZ
 474 #define RG_FREE_TB(_tb)\
 475 {\
 476    U32 lchIdx, pduIdx;\
 477    SResetMBuf(_tb->macHdr);\
 478    SResetMBuf(_tb->macCes);\
 479    _tb->tbPres = FALSE;\
 480    _tb->tbSize = 0;\
 481    _tb->padSize = 0;\
 482    for(lchIdx = 0; lchIdx < _tb->numLch; lchIdx++) \
 483    {\
 484       for(pduIdx = 0; pduIdx < _tb->lchInfo[lchIdx].numPdu; pduIdx++)\
 485       {\
 486           if(_tb->lchInfo[lchIdx].mBuf[pduIdx] != NULL)\
 487           {\
 488             SPutMsg(_tb->lchInfo[lchIdx].mBuf[pduIdx]);\
 489             _tb->lchInfo[lchIdx].freeBuff = FALSE;\
 490           }\
 491           _tb->lchInfo[lchIdx].mBuf[pduIdx] = NULL;\
 492       }\
 493       _tb->lchInfo[lchIdx].numPdu = 0;\
 494    }\
 495    _tb->numLch = 0;\
 496 }
 497
 498 #define RG_FREE_SAVED_TB(_tb)\
 499 {\
 500    U32 lchIdx, pduIdx;\
 501    RG_FREE_MSG(_tb->macHdr);\
 502    RG_FREE_MSG(_tb->macCes);\
 503    _tb->tbPres = FALSE;\
 504    _tb->tbSize = 0;\
 505    _tb->padSize = 0;\
 506    for(lchIdx = 0; lchIdx < 10; lchIdx++) \
 507    {\
 508       for(pduIdx = 0; pduIdx < 4; pduIdx++)\
 509       {\
 510           if(_tb->lchInfo[lchIdx].freeBuff == TRUE)\
 511           {\
 512             SPutMsg(_tb->lchInfo[lchIdx].mBuf[pduIdx]);\
 513             _tb->lchInfo[lchIdx].freeBuff = FALSE;\
 514           }\
 515           _tb->lchInfo[lchIdx].mBuf[pduIdx] = NULL;\
 516       }\
 517       _tb->lchInfo[lchIdx].numPdu = 0;\
 518    }\
 519    _tb->numLch = 0;\
 520 }
 521
 522 #endif
 523
 524 /***********************************************************
 525  *
 526  *     Name : RG_DROP_RGUDDATREQ_MBUF
 527  *
 528  *     Desc : Macro to free the message buffers and initialize them to zero
 529  *
 530  *     Input  : _datreq - Dedicated Data Request pointer which has mBufs
 531  *              to be freed
 532  *
 533  *     Output : None.
 534  *
 535  *     Notes: None
 536  *
 537  **********************************************************/
 538 #define RG_DROP_RGUDDATREQ_MBUF(_datReq)\
 539 {\
 540    U32 idx5,idx6,idx7;\
 541    for (idx5=0; idx5 < _datReq.nmbOfTbs; idx5++)\
 542    {\
 543       for (idx6=0; idx6 < _datReq.datReqTb[idx5].nmbLch; idx6++)\
 544       {\
 545          for (idx7=0; \
 546                idx7 < _datReq.datReqTb[idx5].lchData[idx6].pdu.numPdu; \
 547                idx7++)\
 548          {\
 549             RG_FREE_MSG(_datReq.datReqTb[idx5].\
 550                   lchData[idx6].pdu.mBuf[idx7]);\
 551          }\
 552       }\
 553    }\
 554 }
 555
 556 /***********************************************************
 557  *
 558  *     Name : RG_DROP_RGUCDATREQ_MBUF
 559  *
 560  *     Desc : Macro to free the message buffers and initialize them to zero
 561  *
 562  *     Input  : _datreq - Common Data Request pointer which has mBufs
 563  *              to be freed
 564  *
 565  *     Output : None.
 566  *
 567  *     Notes: None
 568  *
 569  **********************************************************/
 570 #define RG_DROP_RGUCDATREQ_MBUF(_datReq)\
 571 {\
 572    if (_datReq != NULLP)\
 573    {\
 574       RG_FREE_MSG(_datReq->pdu);\
 575    }\
 576 }
 577
 578 /* RRM_SP1_START */
 579 #define RG_UPD_GBR_PRB(_cellCb, _qci, _prbUsed) {\
 580    if(_qci <= RG_MAX_QCI_REPORTS)\
 581    {\
 582       _cellCb->qcisUlPrbCnt[_qci-1] += _prbUsed;\
 583    }\
 584 }
 585 /* RRM_SP1_END */
 586
 587 /* Macros for memory region and pool determination */
 588 #define RG_GET_MEM_REGION(rgCb)  (rgCb.rgInit.region)
 589 #define RG_GET_MEM_POOL(rgCb)    (rgCb.rgInit.pool)
 590
 591
 592 /* MUX related macros */
 593 #define RG_RAR_SHDR_LEN                1
 594 #define RG_RAR_ELEM_LEN                6
 595 #define RG_MAX_SDU_SUB_HDR_LEN         3
 596 #define RG_MAX_PAD_ARR_SZ              4096 /* Changing from 400 to 4096 */
 597 #define RG_PAD_BYTE                    0x00
 598
 599 #define RG_HDR_TYPE_CRES                1
 600 #define RG_HDR_TYPE_TA                  2
 601 #ifdef LTE_ADV
 602 #define RG_HDR_TYPE_SCELL_ACT           3
 603 #endif
 604
 605 #define RG_SDU_SHDR_LEN 1
 606 #define RG_FIXDSZ_CE_SHDR_LEN 1
 607 #define RG_PAD_SHDR_LEN 1
 608 #define RG_CRES_LEN    6
 609 #define RG_TA_LEN      1
 610 #ifdef LTE_ADV
 611 #define RG_SCELL_ACT_CE_LEN 1
 612 #define RG_SCELL_CE_ELM_LEN (RG_FIXDSZ_CE_SHDR_LEN+RG_SCELL_ACT_CE_LEN)
 613 #endif
 614 #define RG_CRES_ELM_LEN (RG_FIXDSZ_CE_SHDR_LEN+RG_CRES_LEN)
 615 #define RG_TA_ELM_LEN   (RG_FIXDSZ_CE_SHDR_LEN+RG_TA_LEN)
 616
 617
 618 /* Values of below macros not yet defined in 5G-NR hence using LTE values till
 619  * They are defined
 620  */
 621 #define RG_CRES_LCID_IDX               0x1C
 622 #define RG_TA_LCID_IDX                 0x1D
 623 #ifdef LTE_ADV
 624 #define RG_SCELL_LCID_IDX              0x1B
 625 #endif
 626 #define RG_PAD_LCID_IDX               0x3F
 627
 628 /* Structure member offset computation macro    */
 629 #define OffsetOf(type, field)                                                 \
 630          (PTR) (&(((type *) NULLP)->field))
 631
 632 #define RG_MAX_SUBFRAMES_IN_SFN        9
 633 #define RG_MAX_SFN                     1024
 634 #ifdef RGAC_5GTF
 635 #define RG_NUM_SUB_FRAMES              50
 636 #else
 637 #define RG_NUM_SUB_FRAMES              10
 638 #endif
 639 #define RG_NUM_SUB_FRAMES_5G           50
 640 /* RRM_SP1_START */
 641 #define RG_MAX_QCI_REPORTS         4
 642 /* RRM_SP1_END */
 643
 644 #ifdef LTE_L2_MEAS
 645 #define RG_NUM_UL_SUB_FRAMES              16
 646 #define RG_MAX_QCI_VALUE                  10
 647
 648 #ifdef EIGHT_UE_PER_TTI_CHANGES
 649 /* Tuned according to TDD Cfg Mode2 and 2UE/TTI.
 650  *  * Need to tune if NumUE/TTI is increased */
 651 #define RG_MAX_DFRD_FREE_BUFS             64 /* 64 - 8UE/TTI */
 652 #define RG_MAX_FREE_BUFS_PERTTI           16 /* 16 - 8UE/TTI */
 653 #endif
 654
 655 #define RG_CALC_SF_DIFF(_time1, _time2)\
 656       (_time1.sfn*RG_NUM_SUB_FRAMES_5G+_time1.slot) < (_time2.sfn*RG_NUM_SUB_FRAMES_5G+_time2.slot)?\
 657      ((_time1.sfn+RG_MAX_SFN)*RG_NUM_SUB_FRAMES_5G+_time1.slot) -\
 658        (_time2.sfn*RG_NUM_SUB_FRAMES_5G+_time2.slot) : \
 659      (_time1.sfn*RG_NUM_SUB_FRAMES_5G+_time1.slot) - (_time2.sfn*RG_NUM_SUB_FRAMES_5G+_time2.slot)
 660
 661 #define RG_TTI_CYCLE_INVLD                0xFFFFFFFF
 662 #define RG_CALC_TTI_CNT(_cellCb, _ttiCnt)\
 663      _ttiCnt = (RG_NUM_SUB_FRAMES_5G * (_cellCb->crntTime.sfn + (_cellCb->ttiCycle * 1024)) )+\
 664                _cellCb->crntTime.slot;
 665 #endif /* LTE_L2_MEAS */
 666
 667 /* Tuned according to TDD Cfg Mode2 and 2UE/TTI.
 668  * Need to tune if NumUE/TTI is increased */
 669 #define RG_MAX_DFRD_FREE_BUFS             32 /* 16- 2 UE per TTI 32 - 4UE/TTI */
 670 #define RG_MAX_FREE_BUFS_PERTTI           8 /* 4 - 2 Ue per TTI, 8 - 4UE/TTI */
 671
 672
 673 /* Define for the block size for memory allocation */
 674 /* RG_BLKSZ changed from 2048 to 1500*/
 675 #define RG_BLKSZ                       1500
 676
 677 /* Defines for RGU Statistics types */
 678 #define RG_RGU_SDU_DROP 1
 679 #define RG_RGU_SDU_RCVD 2
 680
 681 /* MACROS for General Statistics */
 682 #define RG_CFG_ADD      1
 683 #define RG_CFG_DEL      2
 684
 685 #define RG_HQ_FDB_IND_CB_TYPE_HQ_ENT      1
 686 #define RG_HQ_FDB_IND_CB_TYPE_RA_CB       2
 687
 688 /* MACRO for validating the mac instance id */
 689 #define RG_IS_INST_VALID(_inst)\
 690 {\
 691    if(_inst >= RG_MAX_INST)\
 692    {\
 693       RETVALUE(RFAILED);\
 694    }\
 695 }
 696
 697 /*
 698  * Removed unused hash-define which defines the
 699  * index for releasing the subframe.
 700  */
 701
 702 /* Value used to set nDmrs in uplink grant if nDmrs is not applicable */
 703 #define RG_INVALID_NDMRS  10
 704
 705 #define RG_SEND_TRC_IND(_inst,_mBuf, _event) rgLMMTrcInd(_inst,_mBuf, _event)
 706
 707 /* Note: Any changes to these enums should reflect to */
 708 /** @details Enums for special argument
 709  *
 710 */
 711 typedef enum
 712 {
 713    RG_DIAG_NA
 714 } RgDiagSplArg;
 715
 716 #ifdef SS_DIAG
 717 #define RG_DIAG_LVL0(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)                        \
 718 {                                                                                                \
 719    if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL0)                                                         \
 720    {                                                                                             \
 721       ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL0, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
 722    }                                                                                             \
 723 }
 724
 725 /** @details Macro definition for LTE-MAC error logs
 726  *
 727 */
 728 #define RG_DIAG_LVL1(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)            \
 729 {                                                                 \
 730    if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL1)                             \
 731    {                                                              \
 732       ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL1, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
 733    }                                                              \
 734 }
 735
 736 /** @details Macro definition for LTE-MAC critical logs
 737  *
 738 */
 739 #define RG_DIAG_LVL2(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)       \
 740 {                                                              \
 741    if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL2)                            \
 742    {                                                              \
 743       ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL2, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
 744    }                                                              \
 745 }
 746
 747 /** @details Macro definition for LTE-MAC logs
 748  *
 749 */
 750 #define RG_DIAG_LVL3(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)        \
 751 {                                                              \
 752    if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL3)                            \
 753    {                                                              \
 754       ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL3, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
 755    }                                                              \
 756 }
 757
 758 /** @details Macro definition for LTE-MAC logs
 759  *
 760 */
 761 #define RG_DIAG_LVL4(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)        \
 762 {                                                              \
 763    if(rgCb[_inst].rgInit.logMask & SS_DIAG_LVL4)                            \
 764    {                                                              \
 765       ssDiagFix(_tknId, _splArgEnum, ENTRG, rgCb[_inst].rgInit.inst, SS_DIAG_LVL4, SS_DIAG_MSG_TYPE_FIXED, _splArg, _arg1, _arg2, _arg3, _arg4, _string);\
 766    }                                                              \
 767 }
 768
 769 #else
 770
 771 #define RG_DIAG_LVL0(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)                        \
 772 {                                                                                                \
 773 }
 774
 775 /** @details Macro definition for LTE-MAC error logs
 776  *
 777 */
 778 #define RG_DIAG_LVL1(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)            \
 779 {                                                                 \
 780 }
 781
 782 /** @details Macro definition for LTE-MAC critical logs
 783  *
 784 */
 785 #define RG_DIAG_LVL2(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)       \
 786 {                                                              \
 787 }
 788
 789 /** @details Macro definition for LTE-MAC logs
 790  *
 791 */
 792 #define RG_DIAG_LVL3(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)        \
 793 {                                                              \
 794 }
 795
 796 /** @details Macro definition for LTE-MAC logs
 797  *
 798 */
 799 #define RG_DIAG_LVL4(_inst,_tknId, _splArgEnum, _splArg, _string, _arg1, _arg2, _arg3, _arg4)        \
 800 {                                                              \
 801 }
 802 #endif
 803 #define DEFAULT_CELLS 1
 804 #endif /* __RGH__ */
 805 \f
 806 /**********************************************************************
 807          End of file
 808 **********************************************************************/